@birdie_moblie/open_spec 2.1.7

package/dist/usage/analyze.js

@@ -0,0 +1,212 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { sha256 } from '../shared/hash.js';
+import { AppError } from '../shared/errors.js';
+import { parseUsageStream, sumTokens, object } from './parse.js';
+import { mergeClaudeStreams } from './claude.js';
+export { sumTokens } from './parse.js';
+export function analyzeUsage(options) {
+    if (!options.sessions.length)
+        throw new AppError('usage_sessions_required', '至少指定一个会话日志');
+    const hashes = new Set();
+    const streams = [];
+    for (const input of [...new Set(options.sessions.map((input) => path.resolve(input)))].sort()) {
+        const file = path.resolve(input);
+        const text = readFileSync(file, 'utf8');
+        const hash = sha256(text);
+        if (hashes.has(hash))
+            continue;
+        hashes.add(hash);
+        streams.push(parseUsageStream(file, text));
+    }
+    const groups = new Map();
+    for (const stream of streams) {
+        const key = `${stream.provider}:${stream.threadId}`;
+        groups.set(key, [...(groups.get(key) ?? []), stream]);
+    }
+    const issues = streams.flatMap((stream) => stream.issues);
+    const slices = [];
+    const sessions = [];
+    const claude = mergeClaudeStreams(streams.filter((stream) => stream.provider === 'claude'), issues);
+    for (const group of groups.values()) {
+        const rank = (stream) => stream.source === 'rollout' ? 2 : 1;
+        group.sort((a, b) => rank(b) - rank(a) || sumTokens(b.slices.map((slice) => slice.tokens)).input - sumTokens(a.slices.map((slice) => slice.tokens)).input || a.file.localeCompare(b.file));
+        const selected = group[0];
+        if (selected.source === 'exec' && group.length > 1)
+            issues.push({ code: 'multiple_exec_exports_require_rollout', severity: 'incomplete', file: selected.file, threadId: selected.threadId });
+        let selectedSlices = [...selected.slices];
+        if (selected.provider === 'claude') {
+            selectedSlices = claude.slices.filter((slice) => slice.threadId === selected.threadId);
+        }
+        else {
+            for (const other of group.slice(1)) {
+                const chosen = sumTokens(selectedSlices.map((slice) => slice.tokens));
+                const reported = sumTokens(other.slices.map((slice) => slice.tokens));
+                if (reported.input > chosen.input || reported.output > chosen.output) {
+                    issues.push({ code: 'conflicting_usage_exports', severity: 'incomplete', file: other.file, threadId: selected.threadId });
+                    // Preserve every observed token, even when the missing interval cannot be attributed.
+                    const input = Math.max(0, reported.input - chosen.input);
+                    const output = Math.max(0, reported.output - chosen.output);
+                    selectedSlices.push({ key: `${selected.threadId}:unattributed-gap:${other.file}`, threadId: selected.threadId,
+                        model: null, effort: null, workerId: null, stepId: null, timestamp: null, file: other.file, line: 1,
+                        tokens: { input, output, total: input + output, cachedInput: null, cacheWriteInput: null, reasoningOutput: null } });
+                }
+                if (other.source === 'rollout' && selected.source === 'rollout' && reported.input !== chosen.input)
+                    issues.push({ code: 'partial_rollout_exports', severity: 'incomplete', file: other.file, threadId: selected.threadId });
+            }
+        }
+        const tools = selected.provider === 'claude' ? claude.tools.get(selected.threadId) ?? new Set() : selected.tools;
+        const spawns = selected.provider === 'claude' ? claude.spawns.get(selected.threadId) ?? new Set() : selected.spawns;
+        if (selected.source === 'exec' && selected.collabObserved)
+            issues.push({ code: 'exec_collaboration_requires_rollout', severity: 'incomplete', file: selected.file, threadId: selected.threadId });
+        slices.push(...selectedSlices);
+        const elapsed = selected.startedAt && selected.endedAt ? Date.parse(selected.endedAt) - Date.parse(selected.startedAt) : NaN;
+        sessions.push({ threadId: selected.threadId, parentThreadId: selected.parentThreadId, provider: selected.provider, source: selected.source,
+            files: group.map((stream) => stream.file), models: [...new Set(selectedSlices.map((slice) => slice.model).filter((value) => value !== null))],
+            efforts: [...new Set(selectedSlices.map((slice) => slice.effort).filter((value) => value !== null))],
+            tokens: sumTokens(selectedSlices.map((slice) => slice.tokens)), usageObservations: selectedSlices.length, toolCalls: tools.size,
+            apiCalls: selected.provider === 'claude' ? selectedSlices.length : selected.apiCalls,
+            spawnCalls: spawns.size, epochs: selected.epochs, startedAt: selected.startedAt, endedAt: selected.endedAt,
+            elapsedMs: Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : null });
+    }
+    for (const session of sessions) {
+        const children = sessions.filter((child) => child.parentThreadId === session.threadId);
+        if (session.spawnCalls > children.length)
+            issues.push({ code: 'missing_child_usage', severity: 'incomplete', file: session.files[0], threadId: session.threadId });
+        if (session.parentThreadId && !sessions.some((parent) => parent.threadId === session.parentThreadId))
+            issues.push({ code: 'missing_parent_usage', severity: 'incomplete', file: session.files[0], threadId: session.threadId });
+    }
+    for (const slice of slices)
+        slice.attribution = slice.stepId === 'compaction' ? 'request_id' : slice.stepId ? 'log_hint' : 'unattributed';
+    if (options.events)
+        applyEventAttribution(slices, options.events, issues);
+    for (const slice of slices) {
+        if (options.expectedModel && slice.model !== options.expectedModel)
+            issues.push({ code: 'model_not_verified', severity: 'incomplete', file: slice.file, line: slice.line, threadId: slice.threadId });
+        if (options.expectedEffort && slice.effort !== options.expectedEffort)
+            issues.push({ code: 'effort_not_verified', severity: 'incomplete', file: slice.file, line: slice.line, threadId: slice.threadId });
+    }
+    if (!slices.length)
+        issues.push({ code: 'no_usage', severity: 'incomplete', file: options.sessions[0] });
+    const byStage = new Map();
+    for (const slice of slices) {
+        const key = slice.stepId ?? 'unattributed';
+        byStage.set(key, [...(byStage.get(key) ?? []), slice]);
+    }
+    const configurationIssues = new Set(['model_not_verified', 'effort_not_verified']);
+    const tokenComplete = !issues.some((issue) => issue.severity === 'incomplete' && !configurationIssues.has(issue.code));
+    const modelsKnown = slices.length > 0 && slices.every((slice) => slice.model !== null);
+    const effortsKnown = slices.length > 0 && slices.every((slice) => slice.effort !== null);
+    const cost = calculateCost(options, sessions, slices);
+    cost.complete &&= tokenComplete;
+    return { version: 1, changeName: options.changeName, totals: sumTokens(slices.map((slice) => slice.tokens)), sessions, slices,
+        byStage: [...byStage].map(([stepId, rows]) => ({ stepId, tokens: sumTokens(rows.map((slice) => slice.tokens)), observations: rows.length })),
+        coverage: { tokenComplete, modelsKnown, effortsKnown, comparisonEligible: tokenComplete && modelsKnown && effortsKnown && !issues.some((issue) => configurationIssues.has(issue.code)), issues }, cost,
+        counts: { sessions: sessions.length, usageObservations: slices.length, toolCalls: sessions.reduce((total, session) => total + session.toolCalls, 0),
+            apiCalls: sessions.length > 0 && sessions.every((session) => session.apiCalls !== null) ? sessions.reduce((sum, session) => sum + session.apiCalls, 0) : null } };
+}
+function applyEventAttribution(slices, file, issues) {
+    const events = [];
+    for (const [index, line] of readFileSync(file, 'utf8').split('\n').entries()) {
+        if (!line.trim())
+            continue;
+        try {
+            const event = object(JSON.parse(line));
+            const time = Date.parse(String(event.at ?? event.timestamp));
+            if (Number.isFinite(time))
+                events.push({ time, type: String(event.type), payload: object(event.payload) });
+        }
+        catch {
+            issues.push({ code: 'malformed_events', severity: 'warning', file, line: index + 1 });
+        }
+    }
+    events.sort((a, b) => a.time - b.time);
+    const knownWorkers = new Map();
+    const windows = [];
+    let stepId = null;
+    let workerId = null;
+    for (const event of events) {
+        const p = event.payload;
+        const id = typeof p.workerId === 'string' ? p.workerId : null;
+        if (event.type === 'sources.updated') {
+            stepId = 'collect';
+            workerId = null;
+        }
+        else if (event.type === 'worker.created' && id && typeof p.stepId === 'string') {
+            knownWorkers.set(id, p.stepId);
+            workerId = id;
+            stepId = p.stepId;
+        }
+        else if (event.type === 'worker.blocked' && id === workerId)
+            stepId = 'blocked';
+        else if (event.type === 'worker.answered' && id === workerId)
+            stepId = `${knownWorkers.get(id) ?? 'worker'}-resume`;
+        else if (event.type === 'worker.accepted' || event.type === 'worker.cancelled' || event.type === 'sources.collected' || event.type === 'gate.approved') {
+            stepId = p.node === 'gate_a' ? 'gate-a-report' : null;
+            workerId = null;
+        }
+        else
+            continue;
+        windows.push({ time: event.time, stepId, workerId });
+    }
+    for (const slice of slices) {
+        if (slice.stepId === 'compaction') {
+            slice.attribution = 'request_id';
+            continue;
+        }
+        if (!slice.timestamp)
+            continue;
+        const window = windows.filter((event) => event.time <= Date.parse(slice.timestamp)).at(-1);
+        if (!window)
+            continue;
+        slice.workerId = window.workerId;
+        slice.stepId = window.stepId;
+        slice.attribution = window.stepId ? 'event_window' : 'unattributed';
+    }
+}
+function calculateCost(options, sessions, slices) {
+    if (options.billing) {
+        const charges = options.billing.charges;
+        if (!options.billing.source || !Array.isArray(charges) || charges.some((charge) => !charge.threadId || !Number.isFinite(charge.usd) || charge.usd < 0)
+            || new Set(charges.map((charge) => charge.threadId)).size !== charges.length)
+            throw new AppError('invalid_billing', '账单需来源、唯一 threadId 与非负美元金额');
+        const complete = sessions.length > 0 && sessions.every((session) => charges.some((charge) => charge.threadId === session.threadId));
+        return { kind: 'actual', usd: charges.filter((charge) => sessions.some((session) => session.threadId === charge.threadId)).reduce((sum, charge) => sum + charge.usd, 0), source: options.billing.source, complete };
+    }
+    if (options.rates) {
+        if (!options.rates.source || !options.rates.models)
+            throw new AppError('invalid_rates', '费率必须注明来源并提供 models');
+        let usd = 0;
+        let complete = slices.length > 0;
+        for (const slice of slices) {
+            const rate = slice.model ? options.rates.models[slice.model] : undefined;
+            const tokens = slice.tokens;
+            if (!rate || tokens.cachedInput === null || tokens.cacheWriteInput === null || (tokens.cacheWriteInput > 0 && rate.cacheWriteInputPerMillion === undefined)) {
+                complete = false;
+                continue;
+            }
+            const values = [rate.inputPerMillion, rate.cachedInputPerMillion, rate.outputPerMillion, ...(rate.cacheWriteInputPerMillion === undefined ? [] : [rate.cacheWriteInputPerMillion])];
+            if (values.some((value) => typeof value !== 'number' || !Number.isFinite(value) || value < 0))
+                throw new AppError('invalid_rates', '费率必须为非负有限数');
+            const uncached = tokens.input - tokens.cachedInput - tokens.cacheWriteInput;
+            if (uncached < 0) {
+                complete = false;
+                continue;
+            }
+            usd += (uncached * rate.inputPerMillion + tokens.cachedInput * rate.cachedInputPerMillion + tokens.cacheWriteInput * (rate.cacheWriteInputPerMillion ?? 0) + tokens.output * rate.outputPerMillion) / 1_000_000;
+        }
+        return { kind: 'estimated', usd, source: options.rates.source, complete };
+    }
+    return { kind: 'unavailable', usd: null, source: null, complete: false };
+}
+export function renderUsageMarkdown(report) {
+    const show = (value) => value === null ? 'unknown' : value.toLocaleString('en-US');
+    return [`# Usage: ${report.changeName}`, '', `输入 ${show(report.totals.input)}；输出 ${show(report.totals.output)}；合计 ${show(report.totals.total)}。`,
+        `缓存输入 ${show(report.totals.cachedInput)}、缓存写入 ${show(report.totals.cacheWriteInput)}、推理输出 ${show(report.totals.reasoningOutput)} 是明细，不再叠加。`,
+        `计量完整：${report.coverage.tokenComplete}；可比较：${report.coverage.comparisonEligible}；费用：${report.cost.kind}${report.cost.usd === null ? '' : ` USD ${report.cost.usd}`}（完整：${report.cost.complete}）。`, '',
+        '| 阶段 | 输入 | 输出 | 用量观测数 |', '|---|---:|---:|---:|',
+        ...report.byStage.map((stage) => `| ${stage.stepId} | ${show(stage.tokens.input)} | ${show(stage.tokens.output)} | ${stage.observations} |`), '',
+        '未归属用量保留在 unattributed；用量观测数不等于已核验的 API 请求次数。实际费用仅来自显式提供的账单记录，费率估算不代表账单。', '',
+        ...report.coverage.issues.map((issue) => `- ${issue.severity}: ${issue.code} (${issue.file}${issue.line ? `:${issue.line}` : ''})`), ''].join('\n');
+}
+//# sourceMappingURL=analyze.js.map

package/dist/usage/claude.d.ts

@@ -0,0 +1,9 @@
+import { type UsageStream } from './parse.js';
+import type { UsageIssue, UsageSlice } from './types.js';
+/** Forked Claude logs can contain parent messages, including the Agent call itself. */
+export declare function mergeClaudeStreams(streams: UsageStream[], issues: UsageIssue[]): {
+    slices: UsageSlice[];
+    tools: Map<string, Set<string>>;
+    spawns: Map<string, Set<string>>;
+};
+//# sourceMappingURL=claude.d.ts.map

package/dist/usage/claude.js

@@ -0,0 +1,59 @@
+import { mergeClaudeTokens } from './parse.js';
+/** Forked Claude logs can contain parent messages, including the Agent call itself. */
+export function mergeClaudeStreams(streams, issues) {
+    const parents = new Map(streams.map((stream) => [stream.threadId, stream.parentThreadId]));
+    const ancestorOf = (ancestor, descendant) => {
+        const visited = new Set();
+        let current = descendant;
+        while (current && !visited.has(current)) {
+            if (current === ancestor)
+                return true;
+            visited.add(current);
+            current = parents.get(current) ?? null;
+        }
+        return false;
+    };
+    const owner = (ids, file) => {
+        const candidates = [...new Set(ids)].sort();
+        const root = candidates.find((candidate) => candidates.every((id) => ancestorOf(candidate, id)));
+        if (root)
+            return root;
+        // Preserve the observed amount once, but do not claim proven attribution.
+        issues.push({ code: 'claude_ownership_ambiguous', severity: 'incomplete', file });
+        return candidates[0];
+    };
+    const messages = new Map();
+    for (const stream of streams)
+        for (const slice of stream.slices) {
+            messages.set(slice.key, [...(messages.get(slice.key) ?? []), slice]);
+        }
+    const slices = [];
+    const owners = new Map();
+    for (const [id, occurrences] of messages) {
+        const threadId = owner(occurrences.map((slice) => slice.threadId), occurrences[0].file);
+        owners.set(id, threadId);
+        const first = occurrences.find((slice) => slice.threadId === threadId);
+        const ambiguous = !occurrences.every((slice) => ancestorOf(threadId, slice.threadId));
+        slices.push({ ...first, ...(ambiguous ? { workerId: null, stepId: null } : {}),
+            tokens: occurrences.slice(1).reduce((tokens, slice) => mergeClaudeTokens(tokens, slice.tokens), occurrences[0].tokens) });
+    }
+    const calls = new Map();
+    for (const stream of streams)
+        for (const id of stream.tools)
+            calls.set(id, [...(calls.get(id) ?? []), stream]);
+    const tools = new Map();
+    const spawns = new Map();
+    for (const [id, occurrences] of calls) {
+        const threadId = owner(occurrences.map((stream) => owners.get(stream.toolMessages.get(id) ?? '') ?? stream.threadId), occurrences[0].file);
+        const owned = tools.get(threadId) ?? new Set();
+        owned.add(id);
+        tools.set(threadId, owned);
+        if (occurrences.some((stream) => stream.spawns.has(id))) {
+            const spawned = spawns.get(threadId) ?? new Set();
+            spawned.add(id);
+            spawns.set(threadId, spawned);
+        }
+    }
+    return { slices, tools, spawns };
+}
+//# sourceMappingURL=claude.js.map

package/dist/usage/collect.d.ts

@@ -0,0 +1,11 @@
+/** Discover only metadata headers; read full logs only after establishing lineage. */
+export declare function discoverCodexSessions(roots: string[], threadIds: string[]): {
+    files: string[];
+    missingThreadIds: string[];
+    errors: {
+        file: string;
+        code: string;
+    }[];
+};
+export declare function execThreadIds(file: string): string[];
+//# sourceMappingURL=collect.d.ts.map

package/dist/usage/collect.js

@@ -0,0 +1,71 @@
+import { closeSync, existsSync, openSync, readSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { object, string } from './parse.js';
+/** Discover only metadata headers; read full logs only after establishing lineage. */
+export function discoverCodexSessions(roots, threadIds) {
+    const candidates = [];
+    const errors = [];
+    const visit = (dir) => {
+        if (!existsSync(dir))
+            return;
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const file = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                visit(file);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+                continue;
+            const fd = openSync(file, 'r');
+            const buffer = Buffer.alloc(65536);
+            let header = '';
+            try {
+                header = buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0)).toString('utf8').split('\n')[0];
+            }
+            finally {
+                closeSync(fd);
+            }
+            try {
+                const row = object(JSON.parse(header));
+                if (row.type !== 'session_meta')
+                    continue;
+                const payload = object(row.payload);
+                const id = string(payload.id);
+                if (!id)
+                    continue;
+                const subagent = object(object(payload.source).subagent);
+                candidates.push({ id, parent: string(object(subagent.thread_spawn).parent_thread_id) ?? string(object(subagent.spawn).parent_thread_id), file });
+            }
+            catch {
+                errors.push({ file, code: 'unreadable_session_header' });
+            }
+        }
+    };
+    for (const root of roots)
+        visit(path.resolve(root));
+    const included = new Set(threadIds);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const item of candidates)
+            if (item.parent && included.has(item.parent) && !included.has(item.id)) {
+                included.add(item.id);
+                changed = true;
+            }
+    }
+    return { files: [...new Set(candidates.filter((item) => included.has(item.id)).map((item) => item.file))],
+        missingThreadIds: threadIds.filter((id) => !candidates.some((item) => item.id === id)), errors };
+}
+export function execThreadIds(file) {
+    const ids = new Set();
+    for (const line of readFileSync(file, 'utf8').split('\n')) {
+        try {
+            const row = object(JSON.parse(line));
+            if (row.type === 'thread.started' && typeof row.thread_id === 'string')
+                ids.add(row.thread_id);
+        }
+        catch { /* Analyzer retains malformed evidence. */ }
+    }
+    return [...ids];
+}
+//# sourceMappingURL=collect.js.map

package/dist/usage/doctor.d.ts

@@ -0,0 +1,72 @@
+export declare function costCapabilities(cwd: string, explicit?: string[]): {
+    names: string[];
+    gaps: string[];
+};
+export declare function costDoctor(options: {
+    host: 'codex' | 'claude';
+    sessions?: string[];
+    evidence?: string;
+    model?: string;
+    effort?: string;
+    capabilities?: string[];
+    cwd: string;
+}): {
+    ok: boolean;
+    readOnly: boolean;
+    host: "claude" | "codex";
+    version: string | null;
+    capabilities: {
+        name: string;
+        installed: boolean;
+        version: string | null;
+        enabled: boolean | null;
+        probe: string;
+        evidenceIntact: boolean;
+        evidence: string[];
+    }[];
+    isolation: {
+        verified: boolean;
+        accounting: string;
+        parentThreadId: string | undefined;
+        childThreadId: string | undefined;
+        evidence: string[];
+        reason: string | null;
+    } | {
+        verified: boolean;
+        accounting: string;
+        reason: string;
+    };
+    usage: {
+        totals: import("./types.js").Tokens;
+        coverage: {
+            tokenComplete: boolean;
+            modelsKnown: boolean;
+            effortsKnown: boolean;
+            comparisonEligible: boolean;
+            issues: import("./types.js").UsageIssue[];
+        };
+        sessions: import("./types.js").SessionUsage[];
+        cacheHitRate: number | null;
+        cost: {
+            kind: "actual" | "estimated" | "unavailable";
+            usd: number | null;
+            source: string | null;
+            complete: boolean;
+        };
+    } | null;
+    gaps: string[];
+    note: string;
+};
+export declare function inspectIsolation(probe: {
+    parent: string;
+    child: string;
+    parentOnlyMarker: string;
+}): {
+    verified: boolean;
+    accounting: string;
+    parentThreadId: string | undefined;
+    childThreadId: string | undefined;
+    evidence: string[];
+    reason: string | null;
+};
+//# sourceMappingURL=doctor.d.ts.map

package/dist/usage/doctor.js

@@ -0,0 +1,121 @@
+import { findProjectRoot, loadConfig } from '../config/load.js';
+import { resolveAdapterEntry, resolveHookEntry } from '../marketplace/adapters.js';
+import { AppError } from '../shared/errors.js';
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+import { execFile } from '../shared/exec.js';
+import { sha256 } from '../shared/hash.js';
+import { analyzeUsage } from './analyze.js';
+import { object, string } from './parse.js';
+const EvidenceSchema = z.object({
+    capabilities: z.array(z.object({ name: z.string(), status: z.enum(['passed', 'failed', 'blocked']),
+        files: z.array(z.object({ path: z.string(), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict()).min(1),
+    }).strict()).default([]),
+    requiredCapabilities: z.array(z.string().min(1)).optional(),
+    isolation: z.object({ parent: z.string(), child: z.string(), parentOnlyMarker: z.string().min(16) }).strict().optional(),
+}).strict();
+export function costCapabilities(cwd, explicit = []) {
+    const names = new Set(['openspec', ...explicit]);
+    const gaps = [];
+    let root;
+    try {
+        root = findProjectRoot(cwd);
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === 'project_uninitialized')
+            return { names: [...names], gaps };
+        throw error;
+    }
+    const config = loadConfig(root);
+    for (const plugin of config.plugins ?? [])
+        names.add(plugin.name);
+    for (const hook of config.hooks ?? []) {
+        if (!hook.use)
+            continue;
+        try {
+            const resolved = hook.stage === 'collect' || hook.operation === 'preview' ? resolveAdapterEntry(root, hook.use) : resolveHookEntry(root, hook.use);
+            names.add(resolved.identity.name);
+        }
+        catch (error) {
+            gaps.push(`hook:${hook.id}:${error instanceof AppError ? error.code : 'invalid'}`);
+        }
+    }
+    return { names: [...names], gaps };
+}
+export function costDoctor(options) {
+    // No installation, configuration updates, authentication, or model calls.
+    const version = execFile(options.host, ['--version'], { cwd: options.cwd, timeoutMs: 10_000 });
+    const listing = execFile(options.host, options.host === 'codex' ? ['plugin', 'list', '--json'] : ['plugin', 'list', '--json'], { cwd: options.cwd, timeoutMs: 10_000 });
+    let inventory = [];
+    try {
+        const value = JSON.parse(listing.stdout);
+        const rows = Array.isArray(value) ? value : object(value).installed;
+        inventory = (Array.isArray(rows) ? rows : []).map((entry) => {
+            const row = object(entry);
+            return {
+                name: string(row.name) ?? String(row.id ?? row.pluginId ?? '').split('@')[0], version: string(row.version),
+                enabled: typeof row.enabled === 'boolean' ? row.enabled : null,
+            };
+        });
+    }
+    catch { /* Missing or incompatible native inventory is a diagnostic gap. */ }
+    const evidence = options.evidence ? EvidenceSchema.parse(JSON.parse(readFileSync(options.evidence, 'utf8'))) : { capabilities: [] };
+    const requirements = costCapabilities(options.cwd, [...(options.capabilities ?? []), ...(evidence.requiredCapabilities ?? [])]);
+    const capabilities = requirements.names.map((name) => {
+        const installed = inventory.find((entry) => entry.name === name);
+        const probe = evidence.capabilities.find((entry) => entry.name === name);
+        const evidenceIntact = Boolean(probe && probe.files.every((file) => {
+            try {
+                return sha256(readFileSync(file.path)) === file.sha256;
+            }
+            catch {
+                return false;
+            }
+        }));
+        return { name, installed: Boolean(installed), version: installed?.version ?? null, enabled: installed?.enabled ?? null,
+            probe: probe?.status ?? 'missing', evidenceIntact, evidence: probe?.files.map((file) => file.path) ?? [] };
+    });
+    const usage = options.sessions?.length ? analyzeUsage({ changeName: 'doctor', sessions: options.sessions, expectedModel: options.model, expectedEffort: options.effort }) : null;
+    const isolation = evidence.isolation && options.host === 'codex' ? inspectIsolation(evidence.isolation) : { verified: false, accounting: 'unknown', reason: 'probe_missing' };
+    const gaps = [
+        ...requirements.gaps,
+        ...(!version.ok ? ['host_cli_unavailable'] : []),
+        ...(!listing.ok ? ['plugin_inventory_unavailable'] : []),
+        ...capabilities.filter((item) => !item.installed || item.enabled === false || item.probe !== 'passed' || !item.evidenceIntact).map((item) => `capability:${item.name}`),
+        ...(!usage?.coverage.comparisonEligible ? ['usage_or_model_unverified'] : []),
+        ...(!isolation.verified ? ['isolation_or_child_accounting_unverified'] : []),
+    ];
+    return { ok: gaps.length === 0, readOnly: true, host: options.host, version: version.ok ? version.stdout.trim() : null,
+        capabilities, isolation, usage: usage ? { totals: usage.totals, coverage: usage.coverage, sessions: usage.sessions,
+            cacheHitRate: usage.totals.cachedInput === null || usage.totals.input === 0 ? null : usage.totals.cachedInput / usage.totals.input, cost: usage.cost } : null,
+        gaps, note: '插件清单只证明注册；probe 状态来自指定实测记录并校验文件摘要。诊断不执行新探针，也不修改配置。' };
+}
+export function inspectIsolation(probe) {
+    const parent = readFileSync(probe.parent, 'utf8');
+    const child = readFileSync(probe.child, 'utf8');
+    const report = analyzeUsage({ changeName: 'isolation-probe', sessions: [probe.parent, probe.child] });
+    const rows = parent.split('\n').filter(Boolean).map((line) => object(JSON.parse(line)));
+    const calls = rows.filter((row) => row.type === 'response_item').map((row) => object(row.payload));
+    const noHistory = calls.some((call) => {
+        if (!String(call.name).endsWith('spawn_agent'))
+            return false;
+        try {
+            return object(JSON.parse(String(call.arguments))).fork_turns === 'none';
+        }
+        catch {
+            return false;
+        }
+    });
+    const parentSession = report.sessions.find((session) => session.files.includes(probe.parent));
+    const childSession = report.sessions.find((session) => session.files.includes(probe.child));
+    // Per-response records must sum to each thread's snapshots, with no shared
+    // response IDs. This checks exclusive accounting instead of trusting a label.
+    const requestIds = report.slices.map((slice) => slice.key);
+    const exclusive = report.sessions.every((session) => session.apiCalls !== null)
+        && new Set(requestIds).size === requestIds.length && report.coverage.tokenComplete;
+    const verified = noHistory && parent.includes(probe.parentOnlyMarker) && !child.includes(probe.parentOnlyMarker)
+        && childSession?.parentThreadId === parentSession?.threadId && Boolean(parentSession && childSession) && exclusive;
+    return { verified, accounting: exclusive ? 'exclusive-per-thread' : 'unknown', parentThreadId: parentSession?.threadId,
+        childThreadId: childSession?.threadId, evidence: [probe.parent, probe.child], reason: verified ? null : 'probe_not_conclusive' };
+}
+//# sourceMappingURL=doctor.js.map

package/dist/usage/parse.d.ts

@@ -0,0 +1,28 @@
+import type { Tokens, UsageIssue, UsageSlice, SessionUsage } from './types.js';
+type Obj = Record<string, unknown>;
+export interface UsageStream {
+    threadId: string;
+    parentThreadId: string | null;
+    provider: 'codex' | 'claude';
+    source: SessionUsage['source'];
+    file: string;
+    slices: UsageSlice[];
+    issues: UsageIssue[];
+    tools: Set<string>;
+    spawns: Set<string>;
+    epochs: number;
+    startedAt: string | null;
+    endedAt: string | null;
+    collabObserved: boolean;
+    apiCalls: number | null;
+    toolMessages: Map<string, string>;
+}
+export declare const object: (value: unknown) => Obj;
+export declare const string: (value: unknown) => string | null;
+export declare const number: (value: unknown) => number | null;
+export declare const zeroTokens: () => Tokens;
+export declare function sumTokens(values: Tokens[]): Tokens;
+export declare function mergeClaudeTokens(a: Tokens, b: Tokens): Tokens;
+export declare function parseUsageStream(file: string, text: string): UsageStream;
+export {};
+//# sourceMappingURL=parse.d.ts.map