Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
"""Skill statistics are optional, attributable facts, not inferred task success."""
from __future__ import annotations
import asyncio
from concurrent.futures import ThreadPoolExecutor
from copy import deepcopy
from dataclasses import replace
from datetime import datetime, timedelta, timezone
import json
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import Mock
import httpx
import pytest
from sqlalchemy import func, select, text
from sqlalchemy.exc import IntegrityError
from core import skill_observability as runtime
from core.managed_skills import ManagedSkill
from storage import agent_events_retention, skill_observability as store
from storage.db import create_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage.models import agent_events, agent_sessions, scopes, skill_usage_daily
NOW = datetime(2026, 9, 7, 12, tzinfo=timezone.utc)
@pytest.fixture
def engine():
ensure_sqlite_state()
result = create_sqlite_engine()
yield result
result.dispose()
def skill(name="docs", *, body="Read the docs.\n", source=1):
return ManagedSkill(name, "Project documentation", Path("/fixture/project/skills") / name, (source, 0), body)
def load(*, instant=NOW, session_id=None, item=None, error=None):
result = runtime.observation(
"skill.load_result",
runtime.load_result("docs", item or skill(), duration_ms=12, error_code=error),
session_id=session_id,
)
result["metadata"]["observed_at"] = store.timestamp(instant)
return result
def write(engine, event, **kwargs):
with engine.begin() as conn:
return store.record(conn, event, enabled=lambda: True, now=NOW, **kwargs)
def counts(engine):
with engine.connect() as conn:
return (
conn.execute(select(func.count()).select_from(agent_events)).scalar_one(),
conn.execute(select(func.sum(skill_usage_daily.c.load_success_count))).scalar_one(),
)
def seed_session(engine, session_id="ses-test"):
instant = store.timestamp(NOW)
with engine.begin() as conn:
conn.execute(
scopes.insert().values(
id="scope-test",
platform="web",
scope_type="channel",
native_id="native-scope",
is_private=1,
supports_threads=1,
metadata_json="{}",
first_seen_at=instant,
last_seen_at=instant,
updated_at=instant,
)
)
conn.execute(
agent_sessions.insert().values(
id=session_id,
scope_id="scope-test",
agent_name="codex",
agent_backend="codex",
agent_variant="default",
session_anchor="anchor",
native_session_id="native",
status="active",
metadata_json="{}",
model="mutable-current-model",
created_at=instant,
updated_at=instant,
)
)
return session_id
def test_idempotence_and_real_repeats(engine):
event = load()
assert write(engine, event) == "accepted"
assert write(engine, event) == "duplicate"
assert write(engine, load()) == "accepted"
assert counts(engine) == (2, 2)
with engine.connect() as conn:
row = conn.execute(select(skill_usage_daily)).mappings().one()
assert row["session_id"] is None
assert row["load_duration_samples"] == 2
assert row["load_duration_ms_sum"] == 24
assert row["load_duration_ms_max"] == 12
assert row["loaded_body_bytes_sum"] == 2 * len(skill().body.encode())
conflicting = deepcopy(event)
conflicting["content"]["duration_ms"] = 99
with pytest.raises(store.ObservationError, match="observation_id_conflict"):
write(engine, conflicting)
assert counts(engine) == (2, 2)
def test_concurrent_duplicate_receipts_and_null_grain(engine):
event = load()
with ThreadPoolExecutor(max_workers=4) as executor:
results = list(executor.map(lambda _: write(engine, event), range(12)))
assert results.count("accepted") == 1
assert results.count("duplicate") == 11
with ThreadPoolExecutor(max_workers=4) as executor:
list(executor.map(lambda _: write(engine, load()), range(12)))
assert counts(engine) == (13, 13)
def test_event_and_projection_rollback_together(engine):
with engine.begin() as conn:
conn.execute(
text(
"CREATE TRIGGER reject_skill_bucket BEFORE INSERT ON skill_usage_daily "
"BEGIN SELECT RAISE(ABORT, 'projection rejected'); END"
)
)
with pytest.raises(IntegrityError, match="projection rejected"):
write(engine, load())
assert counts(engine) == (0, None)
def test_session_only_never_guesses_model_or_turn(engine):
session_id = seed_session(engine)
event = load(session_id=session_id)
event["turn_id"] = "old-shell-turn"
event["metadata"]["model"] = "old-shell-model"
event["metadata"]["backend"] = "claude"
event["metadata"]["trigger_kind"] = "task"
write(engine, event)
with engine.connect() as conn:
row = conn.execute(select(agent_events)).mappings().one()
meta = json.loads(row["metadata_json"])
assert (row["scope_id"], row["backend"], row["platform"]) == ("scope-test", "claude", "web")
assert row["turn_id"] is None and row["run_id"] is None
assert meta["model"] is None and meta["trigger_kind"] == "unknown"
assert meta["correlation_level"] == "session_only"
with pytest.raises(store.ObservationError, match="session_missing"):
write(engine, load(session_id="missing-session"))
def test_clear_is_narrow_and_rejects_late_receipts(engine):
event = load()
write(engine, event)
with engine.begin() as conn:
row = dict(conn.execute(select(agent_events)).mappings().one())
conn.execute(agent_events.insert().values(**{**row, "id": "keep-tool", "event_type": "tool_call"}))
conn.execute(agent_events.insert().values(**{**row, "id": "keep-user", "visibility": "user"}))
assert store.clear(conn, now=NOW) == {"events": 1, "daily_rows": 1}
with pytest.raises(store.ObservationError, match="observation_cleared"):
write(engine, event)
with engine.begin() as conn:
assert (
store.record(
conn, load(instant=NOW + timedelta(seconds=1)), enabled=lambda: True, now=NOW + timedelta(seconds=1)
)
== "accepted"
)
assert store.status(conn)["cleared_through"] == store.timestamp(NOW)
assert counts(engine) == (3, 1)
def test_disabled_writer_creates_nothing(engine):
with engine.begin() as conn:
assert store.record(conn, load(), enabled=lambda: False, now=NOW) == "disabled"
assert counts(engine) == (0, None)
def test_retention_boundaries_and_unrelated_rows(engine):
ages = (366, 365, 364, 91, 90, 89, 0)
for days in ages:
instant = NOW - timedelta(days=days)
with engine.begin() as conn:
store.record(conn, load(instant=instant), enabled=lambda: True, now=instant)
with engine.begin() as conn:
row = dict(conn.execute(select(agent_events).limit(1)).mappings().one())
conn.execute(agent_events.insert().values(**{**row, "id": "old-tool", "event_type": "tool_call"}))
conn.execute(agent_events.insert().values(**{**row, "id": "old-visible", "visibility": "user"}))
result = agent_events_retention.run_skill_retention(engine, now=NOW)
assert result == {"events": 4, "daily_rows": 2}
assert counts(engine) == (5, 5)
with engine.connect() as conn:
assert conn.execute(select(agent_events.c.id).where(agent_events.c.id == "old-tool")).scalar_one()
def test_physical_session_purge_removes_both_surfaces(engine):
from storage.sessions_service import _delete_agent_session_rows
session_id = seed_session(engine)
write(engine, load(session_id=session_id))
with engine.begin() as conn:
row = dict(conn.execute(select(agent_events)).mappings().one())
conn.execute(agent_events.insert().values(**{**row, "id": "keep-tool", "event_type": "tool_call"}))
assert (
_delete_agent_session_rows(
conn,
select(agent_sessions.c.id).where(agent_sessions.c.id == session_id),
reclaim_mode="pause",
reclaim_reason=None,
)
== 1
)
assert conn.execute(select(agent_sessions.c.id)).first() is None
assert conn.execute(select(skill_usage_daily.c.id)).first() is None
assert conn.execute(select(agent_events.c.id, agent_events.c.session_id)).all() == [("keep-tool", None)]
with pytest.raises(store.ObservationError, match="session_missing"):
write(engine, load(session_id=session_id))
def test_scope_delete_cascades_statistics(engine):
session_id = seed_session(engine)
write(engine, load(session_id=session_id))
with engine.begin() as conn:
conn.execute(scopes.delete().where(scopes.c.id == "scope-test"))
assert counts(engine) == (0, None)
def test_archiving_retained_session_keeps_statistics(engine):
from storage import messages_service
from storage.sessions_service import _delete_agent_session_rows
session_id = seed_session(engine)
write(engine, load(session_id=session_id))
with engine.begin() as conn:
messages_service.append(
conn,
session_id=session_id,
scope_id="scope-test",
platform="web",
author="user",
message_type="user",
text="Keep this conversation",
)
_delete_agent_session_rows(conn, select(agent_sessions.c.id), reclaim_mode="pause", reclaim_reason=None)
assert conn.execute(select(agent_sessions.c.status)).scalar_one() == "archived"
assert counts(engine) == (1, 1)
def test_schema_models_match_real_migration(engine, tmp_path):
import re
from sqlalchemy import inspect
from storage.models import metadata
declared = create_sqlite_engine(tmp_path / "declared.sqlite")
try:
metadata.create_all(declared)
with engine.connect() as migrated, declared.connect() as model:
def snapshot(conn):
columns = conn.exec_driver_sql("PRAGMA table_info(skill_usage_daily)").all()
# SQLite's INTEGER PRIMARY KEY is implicitly non-null either way.
columns = [tuple(row) if row[1] != "id" else (*row[:3], 1, *row[4:]) for row in columns]
checks = {
item["name"]: re.sub(r"\s+", "", item["sqltext"]).lower()
for item in inspect(conn).get_check_constraints("skill_usage_daily")
}
indexes = {
row[1]: (row[2], row[4]) for row in conn.exec_driver_sql("PRAGMA index_list(skill_usage_daily)")
}
foreign_keys = sorted(
tuple(row[2:]) for row in conn.exec_driver_sql("PRAGMA foreign_key_list(skill_usage_daily)")
)
return columns, checks, indexes, foreign_keys
assert snapshot(migrated) == snapshot(model)
finally:
declared.dispose()
def test_whole_window_unique_sessions_not_daily_sum(engine):
session_id = seed_session(engine)
write(engine, load(session_id=session_id))
write(engine, load(session_id=session_id, instant=NOW - timedelta(days=1)))
with engine.connect() as conn:
assert conn.execute(select(func.count(func.distinct(skill_usage_daily.c.session_id)))).scalar_one() == 1
assert conn.execute(select(func.count()).select_from(skill_usage_daily)).scalar_one() == 2
def test_revision_identity_and_privacy():
original = skill(body="Chinese: \u4e2d\u6587\n")
body_changed = replace(original, body="Changed\n")
description_changed = replace(original, description="Changed description")
a = runtime.load_result("docs", original, duration_ms=0)
b = runtime.load_result("docs", body_changed, duration_ms=0)
c = runtime.load_result("docs", description_changed, duration_ms=0)
assert a["skill_key"] == b["skill_key"] == c["skill_key"]
assert a["descriptor_sha256"] == b["descriptor_sha256"] != c["descriptor_sha256"]
assert len({a["skill_revision"], b["skill_revision"], c["skill_revision"]}) == 3
assert a["body_bytes"] == len(original.body.encode("utf-8"))
assert "/fixture" not in json.dumps(a) and "Chinese" not in json.dumps(a)
builtin = replace(original, priority=(0,), directory=Path("/snapshot/a/docs"))
moved = replace(builtin, directory=Path("/snapshot/b/docs"))
assert runtime.skill_descriptor(builtin) == runtime.skill_descriptor(moved)
def test_catalog_counts_actual_page_and_failures_only_load_attempts(engine):
items = [skill(f"skill-{i}") for i in range(26)]
content = runtime.catalog_result(items, page=2)
assert len(content["entries"]) == 1
assert content["entries"][0]["skill_name"] == "skill-9"
event = runtime.observation("skill.catalog_result", content)
event["metadata"]["observed_at"] = store.timestamp(NOW)
write(engine, event)
failure = load(error="output_interrupted")
write(engine, failure)
with engine.connect() as conn:
totals = conn.execute(
select(
func.sum(skill_usage_daily.c.catalog_offer_count),
func.sum(skill_usage_daily.c.load_success_count),
func.sum(skill_usage_daily.c.load_failure_count),
)
).one()
assert totals == (1, 0, 1)
@pytest.mark.parametrize(
"mutate",
[
lambda e: e["content"].update(body="private prompt"),
lambda e: e["content"].update(skill_name="../private/path"),
lambda e: e["content"].update(duration_ms=True),
lambda e: e["metadata"].update(schema_version=2),
lambda e: e["metadata"].update(observed_at=store.timestamp(NOW + timedelta(seconds=1))),
lambda e: e["metadata"].update(observed_at=store.timestamp(NOW - timedelta(days=2))),
],
)
def test_invalid_observations_do_not_write(engine, mutate):
event = load()
mutate(event)
with pytest.raises(store.ObservationError):
write(engine, event)
assert counts(engine) == (0, None)
@pytest.mark.parametrize("role", ["owner", "member", "editor", "viewer", None])
def test_manager_sql_access_including_cte(engine, role):
"""PERMISSIONS-019: Instance operational diagnostics admit Member and preserve query safety."""
from storage.read_only_query import ReadOnlyQueryError, run_read_only_query
from vibe.authorization import AuthorizationContext
write(engine, load())
remote = AuthorizationContext(is_remote=True, instance_role=role)
for table in ("skill_usage_daily", "agent_events"):
query = f"WITH stats AS (SELECT * FROM {table}) SELECT count(*) AS n FROM stats"
if role in {"member", "owner"}:
assert run_read_only_query(query, page_request=None, user_context=remote).rows == [{"n": 1}]
else:
with pytest.raises(ReadOnlyQueryError):
run_read_only_query(query, page_request=None, user_context=remote)
for query in ("DELETE FROM skill_usage_daily", "SELECT * FROM vault_secrets"):
with pytest.raises(ReadOnlyQueryError):
run_read_only_query(query, page_request=None, user_context=remote)
assert run_read_only_query("SELECT count(*) AS n FROM skill_usage_daily", page_request=None).rows == [{"n": 1}]
def test_cli_transport_failure_preserves_output_and_exit(monkeypatch, capsys):
from vibe import cli
from core import managed_skills
monkeypatch.setattr(managed_skills, "resolve_skills", lambda: [skill()])
monkeypatch.setattr(managed_skills, "load_skill", lambda *args, **kwargs: skill())
monkeypatch.setattr("vibe.internal_client.record_skill_observation_sync", Mock(side_effect=TimeoutError))
assert cli.cmd_skill(SimpleNamespace(skill_command="list", page=1)) == 0
assert json.loads(capsys.readouterr().out)["skills"] == [{"name": "docs", "description": "Project documentation"}]
assert cli.cmd_skill(SimpleNamespace(skill_command="load", names=["docs"])) == 0
output = capsys.readouterr()
assert "Read the docs." in output.out and output.err == ""
def test_cli_observes_actual_loaded_snapshot(monkeypatch):
from vibe import cli
winner = replace(skill(), body=None)
loaded = replace(skill(), body="New body\n")
monkeypatch.setattr("core.managed_skills.resolve_skills", lambda: [winner])
monkeypatch.setattr("core.managed_skills.load_skill", lambda *args, **kwargs: loaded)
submitted = Mock(return_value={"status": "queued"})
monkeypatch.setattr("vibe.internal_client.record_skill_observation_sync", submitted)
assert cli.cmd_skill(SimpleNamespace(skill_command="load", names=["docs"])) == 0
event = submitted.call_args.args[0]
assert event["content"]["skill_revision"] == runtime.load_result("docs", loaded, duration_ms=0)["skill_revision"]
def test_cli_observes_each_name_of_a_multi_skill_load(monkeypatch, capsys):
from vibe import cli
monkeypatch.setattr("core.managed_skills.resolve_skills", lambda: [skill()])
monkeypatch.setattr("core.managed_skills.load_skill", lambda *args, **kwargs: skill())
submitted = Mock(return_value={"status": "queued"})
monkeypatch.setattr("vibe.internal_client.record_skill_observation_sync", submitted)
assert cli.cmd_skill(SimpleNamespace(skill_command="load", names=["docs", "missing"])) == 1
capsys.readouterr()
loads = [call.args[0]["content"] for call in submitted.call_args_list]
assert [(event["skill_name"], event["error_code"]) for event in loads] == [("docs", None), ("missing", "not_found")]
def test_runtime_candidate_requires_acceptance(monkeypatch):
from core.system_prompt_injection import build_system_prompt_injection
sink = []
recorder = Mock()
controller = SimpleNamespace(skill_observability=recorder)
context = SimpleNamespace(platform_specific={"agent_session_id": "ses-test", "turn_token": "turn-test"})
monkeypatch.setattr("core.managed_skills.resolve_skills", lambda *args, **kwargs: [skill()])
prompt = build_system_prompt_injection(skills_cwd="/fixture", skill_catalog_sink=sink)
assert "docs" in prompt and len(sink) == 1
recorder.enqueue.assert_not_called()
runtime.accept_catalog(controller, context, sink[0])
event = recorder.enqueue.call_args.args[0]
assert event["session_id"] == "ses-test" and event["turn_id"] == "turn-test"
assert event["metadata"]["observation_channel"] == "runtime_prompt"
assert recorder.enqueue.call_args.kwargs == {"trusted_runtime": True}
@pytest.mark.asyncio
async def test_recorder_disabled_storage_failure_and_backpressure(engine, monkeypatch):
recorder = runtime.SkillObservationRecorder(engine=engine, enabled=lambda: False)
event = load(instant=store.utc_now())
assert recorder.enqueue(event) == "queued"
await recorder.queue.join()
assert recorder.health()["disabled"] == 1
recorder.enabled = lambda: True
monkeypatch.setattr(recorder, "_write", Mock(side_effect=RuntimeError("db unavailable")))
recorder.enqueue(event)
await recorder.queue.join()
assert recorder.health()["dropped"] == 1
for _ in range(runtime.MAX_PENDING_OBSERVATIONS):
assert recorder.enqueue(event) == "queued"
assert recorder.enqueue(event) == "dropped"
await recorder.close()
assert recorder.health()["pending"] == 0
assert recorder.enqueue(event) == "dropped"
assert counts(engine) == (0, None)
@pytest.mark.asyncio
async def test_internal_observation_boundary(engine):
from core.internal_server import create_app
controller = SimpleNamespace()
app = create_app(controller)
recorder = controller.skill_observability
recorder.engine = engine
recorder.enabled = lambda: True
async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://internal") as client:
event = load(instant=store.utc_now())
assert (await client.post("/internal/skill-observations", json=event)).json() == {"status": "queued"}
await recorder.queue.join()
assert counts(engine) == (1, 1)
event["metadata"]["observation_channel"] = "runtime_prompt"
assert (await client.post("/internal/skill-observations", json=event)).status_code == 400
assert (await client.post("/internal/skill-observations", content=b"x" * 33000)).status_code == 413
assert (await client.get("/internal/skill-observations/health")).json()["accepted"] == 1
await recorder.close()
@pytest.mark.asyncio
@pytest.mark.parametrize("exit_mode", ["return", "error", "cancel", "recovery_cancel", "bind_error"])
async def test_internal_server_owns_recorder_cleanup(engine, monkeypatch, tmp_path, exit_mode):
from core import internal_server
controller = SimpleNamespace(_delivery_recovery_complete=asyncio.Event())
started = asyncio.Event()
listener = SimpleNamespace(close=Mock())
async def serve(*, sockets):
assert sockets == [listener]
recorder = controller.skill_observability
recorder.engine = engine
recorder.enabled = lambda: True
assert recorder.enqueue(load(instant=store.utc_now())) == "queued"
await recorder.queue.join()
started.set()
if exit_mode == "error":
raise RuntimeError("server failed")
if exit_mode == "cancel":
await asyncio.Event().wait()
host = SimpleNamespace(
instance_id=None,
bearer_token=None,
bind=Mock(
side_effect=(
OSError("socket unavailable")
if exit_mode == "bind_error"
else lambda: SimpleNamespace(listener=listener)
)
),
publish=Mock(),
cleanup=Mock(side_effect=lambda bound: bound.listener.close()),
)
monkeypatch.setattr(internal_server, "_create_controller_loop_server", lambda _config: SimpleNamespace(serve=serve))
monkeypatch.setattr(internal_server.control_ipc, "select_control_ipc_host", lambda **_: host)
monkeypatch.setattr(internal_server, "_write_internal_server_status", Mock())
if exit_mode != "recovery_cancel":
controller._delivery_recovery_complete.set()
task = asyncio.create_task(internal_server.serve(controller))
if exit_mode == "cancel":
await asyncio.wait_for(started.wait(), timeout=5)
task.cancel()
elif exit_mode == "recovery_cancel":
await asyncio.sleep(0)
task.cancel()
if exit_mode in {"cancel", "recovery_cancel"}:
with pytest.raises(asyncio.CancelledError):
await task
elif exit_mode in {"error", "bind_error"}:
with pytest.raises((RuntimeError, OSError)):
await task
else:
await task
recorder = controller.skill_observability
assert recorder.closed
assert recorder.worker is None or recorder.worker.done()
assert recorder.enqueue(load()) == "dropped"
if exit_mode not in {"recovery_cancel", "bind_error"}:
assert counts(engine) == (1, 1)
listener.close.assert_called_once()
host.cleanup.assert_called_once()
def test_config_flag_is_strict_and_serialized():
from config.v2_config import RuntimeConfig, V2Config
assert RuntimeConfig(default_cwd=".").skill_observability_enabled is True
assert RuntimeConfig(default_cwd=".", skill_observability_enabled=False).skill_observability_enabled is False
for value in ("false", 0, 1, None):
with pytest.raises(ValueError, match="skill_observability_enabled"):
RuntimeConfig(default_cwd=".", skill_observability_enabled=value)
config = V2Config.default()
config.runtime.skill_observability_enabled = False
config.save()
assert V2Config.load().runtime.skill_observability_enabled is False
def test_collection_recovery_fails_closed(monkeypatch):
config = SimpleNamespace(
runtime=SimpleNamespace(skill_observability_enabled=True),
load_warnings=["Config JSON could not be parsed; using recovery defaults"],
)
monkeypatch.setattr("config.v2_config.V2Config.load", lambda: config)
assert runtime.collection_enabled() is False
config.load_warnings = ["Recovered invalid config section 'runtime.skill_observability_enabled'"]
assert runtime.collection_enabled() is False
config.load_warnings = []
assert runtime.collection_enabled() is True
def test_retention_uses_skill_partial_index(engine):
with engine.connect() as conn:
plan = conn.execute(
text(
"EXPLAIN QUERY PLAN SELECT id FROM agent_events WHERE "
+ str(store.SKILL_TRACE_FILTER)
+ " AND datetime(created_at) IS NOT NULL AND created_at < :cutoff LIMIT 1000"
),
{"cutoff": store.timestamp(NOW)},
).all()
assert "ix_agent_events_skill_created_id" in str(plan)
def test_clear_command_requires_explicit_confirmation(engine, capsys):
from vibe.cli import cmd_data_skill_usage
write(engine, load())
assert cmd_data_skill_usage(SimpleNamespace(clear=True, yes=False)) == 1
assert counts(engine) == (1, 1)
assert cmd_data_skill_usage(SimpleNamespace(clear=True, yes=True)) == 0
assert counts(engine) == (0, None)
@pytest.mark.parametrize(
"owner,clear,yes,code,error",
[
(False, False, False, "forbidden", "Instance Member or Owner access is required."),
(True, True, False, "confirmation_required", "Clearing Skill statistics requires --yes."),
(True, False, True, "invalid_arguments", "--yes requires --clear."),
],
)
def test_skill_usage_errors_name_the_refusal(monkeypatch, capsys, owner, clear, yes, code, error):
from vibe import cli
monkeypatch.setattr(
"storage.resource_access_service.resolve_resource_access_context",
lambda _caller: SimpleNamespace(can_manage_instance=owner),
)
assert cli.cmd_data_skill_usage(SimpleNamespace(clear=clear, yes=yes)) == 1
captured = capsys.readouterr()
assert captured.out == ""
payload = json.loads(captured.err)
assert payload["code"] == code
assert payload["error"] == error
def test_skill_usage_help_names_its_manager_floor(capsys):
from vibe import cli
with pytest.raises(SystemExit) as exit_info:
cli.build_parser().parse_args(["data", "skill-usage", "--help"])
assert exit_info.value.code == 0
output = capsys.readouterr().out
assert "Inspect or clear local Skill statistics (Instance Member or Owner)" in output
assert "Clear Skill events and daily statistics." in output
assert "Confirm clearing Skill statistics." in output
assert "Owner only" not in output
@pytest.mark.parametrize("role", ["owner", "member"])
def test_manager_cli_skill_diagnostics_use_real_storage(engine, monkeypatch, capsys, role):
from vibe import cli
from vibe.authorization import AuthorizationContext
write(engine, load())
monkeypatch.setattr(cli, "caller_resource_user_context", lambda _caller: AuthorizationContext(instance_role=role))
assert cli.cmd_data_skill_usage(SimpleNamespace(clear=False, yes=False)) == 0
assert json.loads(capsys.readouterr().out)["ok"] is True
assert counts(engine) == (1, 1)
assert cli.cmd_data_skill_usage(SimpleNamespace(clear=True, yes=True)) == 0
assert json.loads(capsys.readouterr().out)["ok"] is True
assert counts(engine) == (0, None)