agentacct 本地 Agent 工作账本

18@dataclass(frozen=True)
19class UsageSourceDiscovery:
20    client: str
21    display_name: str
22    status: SourceStatus
23    evidence: str
24    paths: list[str]
25    file_count: int
26    session_count: int | None
27    latest_updated_at: int | None
28    usage_confidence: str
29    cost_confidence: str
30    importer: str | None
31    notes: list[str]
32
33    def to_dict(self) -> dict[str, object]:
34        return asdict(self)
35

86def _discover_codex_source(codex_home: Path | None) -> UsageSourceDiscovery:
87    source_plan = resolve_usage_source_paths("codex", explicit_home=codex_home)
88    homes = list(source_plan.homes)
89    session_roots = [path for home in homes for path in (home / "sessions", home / "archived_sessions")]
90    active_session_roots = [home / "sessions" for home in homes]
91    files_by_home = [
92        _dedupe_paths(_matching_files(root, ["rollout-*.jsonl"]))
93        for root in active_session_roots
94    ]
95    files = _dedupe_paths(path for home_files in files_by_home for path in home_files)
96    db_paths_by_home = [
97        home / "state_5.sqlite" if _is_file(home / "state_5.sqlite") else None
98        for home in homes
99    ]
100    db_paths = [path for path in db_paths_by_home if path is not None]
101    db_session_ids_by_home = [
102        _sqlite_text_values(db_path, "threads", "id") if db_path is not None else set()
103        for db_path in db_paths_by_home
104    ]
105    db_usage_counts = [
106        _sqlite_count(db_path, "threads", where="tokens_used > 0") if db_path is not None else 0
107        for db_path in db_paths_by_home
108    ]
109    db_error_count = sum(
110        session_ids is None or usage_count is None
111        for session_ids, usage_count in zip(db_session_ids_by_home, db_usage_counts, strict=True)
112    )
113    db_usage_count = sum(count or 0 for count in db_usage_counts)
114    rollout_session_ids_by_home = [
115        _codex_rollout_session_ids(home_files, root=root)
116        for home_files, root in zip(files_by_home, active_session_roots, strict=True)
117    ]
118    session_count = sum(
119        len((db_session_ids or set()) | rollout_session_ids)
120        for db_session_ids, rollout_session_ids in zip(
121            db_session_ids_by_home,
122            rollout_session_ids_by_home,
123            strict=True,
124        )
125    )
126    paths = _existing_or_attempted_paths([*db_paths, *session_roots])
127    latest = _latest_mtime([*files, *db_paths])
128    # Rollout identity now produces an honest session observation even when a
129    # state-db row or token_count event is absent. Source discovery is only a
130    # presence scan, so a rollout file is enough to expose the import path;
131    # parse/usage truth remains the ingestion health endpoint's job.
132    found = session_count > 0
133    notes = ["rollout session identity and token_count events; local cost usually unavailable"]
134    if db_error_count:
135        notes.append(
136            f"{db_error_count} Codex state database(s) could not be read; inspect or repair state_5.sqlite"
137        )
138    if source_plan.omitted_home_count:
139        notes.append(f"source path plan omitted {source_plan.omitted_home_count} path(s) after its safety limit")
140    return UsageSourceDiscovery(
141        client="codex",
142        display_name="Codex",
143        status="error" if db_error_count else "found" if found else "missing",
144        evidence="state-db+rollout-jsonl",
145        paths=paths,
146        file_count=len(files),
147        session_count=session_count or None,
148        latest_updated_at=latest,
149        usage_confidence=USAGE_CLIENT_REPORTED if db_usage_count else USAGE_UNKNOWN,
150        cost_confidence=COST_UNKNOWN,
151        importer="agentacct usage import-local --client codex" if found else None,
152        notes=notes,
153    )

54# The ONLY tools whose responses may donate an evidenced event id. Every one
55# of them returns exactly one created event under a top-level "event" key
56# (mcp.py); read tools (sentinel_list_events, sentinel_get_event_summary,
57# sentinel_list_runs, sentinel_get_report, ...) echo foreign ids and must
58# never appear here.
59# frozen: the sentinel_* tool names survive the Agent Chronicle rename —
60# historical stores/logs/files carry them forever, and three shipped
61# instruction surfaces plus real user CLAUDE.md/AGENTS.md files quote them.
62SENTINEL_CREATION_TOOLS = frozenset(
63    {
64        "sentinel_record_event",
65        "sentinel_attach_client_context",
66        "sentinel_record_section",
67        "sentinel_record_agent_usage_debug",
68        "sentinel_record_machine_check",
69    }
70)
71
72# \Z (not $) so a trailing newline is rejected: 'evt_deadbeef\n' must NOT
73# pass at any of the .match() call sites ($ matches before a final newline).
74EVIDENCED_EVENT_ID_RE = re.compile(r"^evt_[0-9a-f]{6,64}\Z")
75
76# Real max observed in one session: 157 distinct created ids. The cap bounds
77# hostile/huge sessions; the true total is always preserved alongside so
78# overflow is visible, never silent.
79EVIDENCED_EVENT_IDS_CAP = 200
80
81# Codex fork rollouts can begin by replaying the parent's transcript, including
82# old MCP creation responses.  A small clock-skew allowance keeps near-boundary
83# facts joinable while still rejecting the impossible case: an event recorded
84# well before the alleged donor session existed.
85CODEX_REPLAY_CLOCK_SKEW_SECONDS = 5.0
86CODEX_REPLAY_REJECTION_REASON = "codex_event_before_session_start"
87CODEX_REPLAY_TIME_UNPROVEN_REASON = "codex_replay_timestamps_unproven"
88SOURCE_NAMESPACE_CONFLICT_REASON = "source_namespace_conflict"
89CROSS_KIND_DONOR_IDENTITY_CONFLICT_REASON = "cross_kind_donor_identity_conflict"
90CANONICAL_EVENT_IDENTITY_CONFLICT_REASON = "canonical_event_identity_conflict"
91
92# The documented MCP registration names (every current setup path writes
93# "agentacct"). Claude Code transcripts carry the registration key verbatim in
94# `mcp__<server>__<tool>`; Codex normalizes the config key to underscores in the
95# rollout `namespace` field (`mcp__agent_chronicle` / `mcp__agent_sentinel`; the
96# hyphen-free `agentacct` normalizes to itself). A custom registration name
97# loses evidence links (skipped-but-counted, never guessed) — documented in
98# INSTALL.md.
99#
100# ALL THREE names are accepted FOREVER: `agentacct` is what new installs now
101# register, and the pre-rename `agent-chronicle` / `agent-sentinel` keys stay
102# accepted because historical client logs carry them forever and pre-rename
103# registrations keep producing them in new sessions — dropping an old key would
104# silently unlink every pre-rename session on the next import.
105SENTINEL_SERVER_KEY = "agentacct"  # the name new installs register
106ACCEPTED_SERVER_KEYS = frozenset({"agentacct", "agent-chronicle", "agent-sentinel"})
107_CODEX_ACCEPTED_NAMESPACES = frozenset(
108    {"agentacct", "agent-chronicle", "agent_chronicle", "agent-sentinel", "agent_sentinel"}
109)
110_CLAUDE_TOOL_PREFIX = "mcp__"
111
112
113def extract_created_event_id(text: str) -> str | None:
114    """Strict single-created-event shape check shared by every wire adapter.
115
116    Accepts exactly the creation-tool payload shape: a JSON dict with a
117    top-level ``"event"`` dict whose ``event_id`` is a well-formed evt id.
118    Rejects (belt-and-braces — the tool-name allowlist already excludes read
119    tools): list-shaped payloads carrying ``"events"``/``"runs"`` lists,
120    error texts, truncated/torn JSON, outcome-only machine_check payloads,
121    and any non-dict shape.
122    """
123
124    try:
125        payload = json.loads(text)
126    except (json.JSONDecodeError, ValueError):
127        return None
128    if not isinstance(payload, dict):
129        return None
130    event = payload.get("event")
131    if not isinstance(event, dict):
132        return None
133    if any(isinstance(payload.get(key), list) for key in ("events", "runs")):
134        return None
135    event_id = event.get("event_id")
136    if not isinstance(event_id, str) or not EVIDENCED_EVENT_ID_RE.match(event_id):
137        return None
138    return event_id

63def test_discover_usage_sources_reports_found_and_pending_sources(tmp_path):
64    codex_home = _make_codex_source(tmp_path)
65    claude_home = _make_claude_source(tmp_path)
66    hermes_home = _make_hermes_source(tmp_path)
67    openclaw_home = tmp_path / "openclaw-home"
68    openclaw_home.mkdir()
69    (openclaw_home / "session.jsonl").write_text("{}", encoding="utf-8")
70
71    sources = {
72        source.client: source
73        for source in discover_usage_sources(
74            codex_home=codex_home,
75            claude_home=claude_home,
76            hermes_home=hermes_home,
77            openclaw_home=openclaw_home,
78            opencode_home=tmp_path / "missing-opencode",
79        )
80    }
81
82    assert sources["codex"].status == "found"
83    assert sources["codex"].session_count == 2
84    assert sources["codex"].importer == "agentacct usage import-local --client codex"
85    assert sources["claude-code"].status == "found"
86    assert sources["hermes"].status == "found"
87    assert sources["hermes"].cost_confidence == "client_reported"
88    assert sources["openclaw"].status == "found"
89    assert sources["openclaw"].usage_confidence == "unknown"
90    assert sources["openclaw"].importer == "agentacct usage import-local --client openclaw"
91    assert sources["opencode"].status == "missing"