@agentwhy/cli 0.0.0-dev

package/dist/adapter/claude-code/events/transcript-scan.js

@@ -0,0 +1,179 @@
+import { isJsonObject } from '../../../shared/json.js';
+import { isKnownDenialKind, RULE_REFUSED_READ, RULE_REFUSED_READ_KIND } from '../contract/denials.js';
+import { AGENT_TOOL, HANDBACK_TOOL, FIELDS, TEXT_BLOCK_TYPE, THINKING_BLOCK_TYPE, TOOL_RESULT_BLOCK_TYPE } from '../contract/fields.js';
+import { ASSISTANT_LINE_TYPE, USER_LINE_TYPE } from '../contract/line-types.js';
+import { toolResultReferences } from '../contract/layout.js';
+import { LAUNCH_NOTICE, notificationsIn } from '../contract/task-notifications.js';
+import { GREP_TOOL, profileOf } from '../contract/tools.js';
+import { contentBlocks, toolUseBlocks, wordsWithoutResult } from '../probe/transcript-line.js';
+export function callsIn(record) {
+    return toolUseBlocks(record).flatMap((block) => {
+        const id = block[FIELDS.blockId];
+        const toolName = block[FIELDS.toolName];
+        if (typeof id !== 'string' || typeof toolName !== 'string')
+            return [];
+        const raw = block[FIELDS.toolInput];
+        const input = isJsonObject(raw) ? raw : {};
+        const { profile, known } = profileOf(toolName);
+        return [
+            {
+                id,
+                toolName,
+                input,
+                ...addressedIn(input, profile),
+                ...(profile.writes === undefined ? {} : { written: writtenIn(input, profile) }),
+                resultShape: profile.result,
+                toolKnown: known,
+                ...(printsMatchesIn(toolName, input) ? { printsMatches: true } : {}),
+            },
+        ];
+    });
+}
+/** Whether a call's own input asks for the lines it matched, as the contract names the one tool that can. */
+function printsMatchesIn(toolName, input) {
+    return toolName === GREP_TOOL.name && input[GREP_TOOL.outputModeKey] === GREP_TOOL.contentMode;
+}
+/**
+ * Where this tool states its target, split by how it must be read. For a tool the contract does not know,
+ * everything it was given is treated as a path: the noisiest reading, and a visible one.
+ */
+function addressedIn(input, profile) {
+    if (profile.searchWholeInput)
+        return { targets: stringsOf(input), commands: [] };
+    return {
+        targets: profile.pathKeys.flatMap((key) => stringsOf(input[key])),
+        commands: profile.commandKeys.flatMap((key) => stringsOf(input[key])),
+    };
+}
+/** What a call that writes a file puts into it: every string it was given, except its path and the text it takes out. */
+function writtenIn(input, profile) {
+    const skipped = new Set([...profile.pathKeys, ...(profile.writes?.removedTextKeys ?? [])]);
+    return Object.entries(input).flatMap(([key, value]) => (skipped.has(key) ? [] : stringsOf(value)));
+}
+function stringsOf(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(stringsOf);
+    if (value !== null && typeof value === 'object')
+        return Object.values(value).flatMap(stringsOf);
+    return [];
+}
+/** Where each kind of the agent's own words is written: the block that holds it, and the field inside it. */
+const MESSAGE_BLOCKS = [
+    { type: TEXT_BLOCK_TYPE, field: FIELDS.blockText, kind: 'said' },
+    { type: THINKING_BLOCK_TYPE, field: FIELDS.blockThinking, kind: 'reasoning' },
+];
+/**
+ * What the agent wrote on this line, block by block and in the order written (`specs/2026-09-15-what-came-back.md` R1,
+ * `specs/2026-09-15-why-this-call.md` R1, R4). Only an assistant line: a user line carries text blocks as well, and they are
+ * someone else's words.
+ */
+export function messagesIn(record) {
+    if (record[FIELDS.lineType] !== ASSISTANT_LINE_TYPE)
+        return [];
+    return contentBlocks(record).flatMap((block) => {
+        const written = MESSAGE_BLOCKS.find((kind) => block[FIELDS.blockType] === kind.type);
+        if (written === undefined)
+            return [];
+        const text = block[written.field];
+        // An empty block is kept, not dropped: in the measured session every reasoning block is empty, and a
+        // report that said "nothing" of them would confuse what an agent did not write with what the record did not
+        // keep. What counts as words is decided above the adapter.
+        return typeof text === 'string' ? [{ kind: written.kind, text }] : [];
+    });
+}
+/**
+ * The reports delivered on this line (`specs/2026-09-15-where-the-value-went.md` R1): notifications that name a call,
+ * on a user line holding no tool result. Whether the call is a delegation is the core's join. A notification naming
+ * no call delivers nothing to anything, so it is left out here; the doctor counts it.
+ */
+export function deliveriesIn(record) {
+    if (record[FIELDS.lineType] !== USER_LINE_TYPE)
+        return [];
+    const words = wordsWithoutResult(record);
+    if (words === undefined)
+        return [];
+    return notificationsIn(words).flatMap(({ callId, text }) => (callId === undefined ? [] : [{ callId, text }]));
+}
+export function isDelegation(call) {
+    return call.toolName === AGENT_TOOL.name;
+}
+/**
+ * The report a subagent hands back through a call rather than a message (D9). The words only - which delegation
+ * they answer is not in the call, and is the join the caller makes from the transcript the call sits on.
+ */
+export function handbackIn(call) {
+    if (call.toolName !== HANDBACK_TOOL.name)
+        return undefined;
+    const words = call.input[HANDBACK_TOOL.reportInputKey];
+    return typeof words === 'string' ? words : undefined;
+}
+/** The instruction a delegation carried. Raw content: what the report exists to quote, once M3 can redact it. */
+export function delegationTextIn(call) {
+    const prompt = call.input[AGENT_TOOL.promptInputKey];
+    const description = call.input[AGENT_TOOL.descriptionInputKey];
+    return {
+        ...(typeof prompt === 'string' ? { prompt } : {}),
+        ...(typeof description === 'string' ? { description } : {}),
+    };
+}
+export function resultsIn(record) {
+    const payload = record[FIELDS.toolUseResult];
+    const denialValue = record[FIELDS.denialKind];
+    const denial = typeof denialValue === 'string'
+        ? { kind: denialValue, recognised: isKnownDenialKind(denialValue) }
+        : undefined;
+    const blocks = contentBlocks(record).filter((block) => block[FIELDS.blockType] === TOOL_RESULT_BLOCK_TYPE);
+    // The marker sits on the record, not on a block, so it names a call only while the record holds exactly one.
+    const attributable = blocks.length === 1;
+    // The payload sits on the record as well, so a launch notice is attributed on the same terms as a denial.
+    const launched = isJsonObject(payload) && payload[LAUNCH_NOTICE.statusField] === LAUNCH_NOTICE.launchedStatus;
+    const results = blocks.flatMap((block) => {
+        const callId = block[FIELDS.resultCallId];
+        if (typeof callId !== 'string')
+            return [];
+        const content = textOf(block[FIELDS.blockContent]) ?? textOf(payload);
+        // A refusal the tool says in words sits on its own block, so it names its call however many the record holds.
+        const refusedByRule = block[FIELDS.resultIsError] === true && content?.includes(RULE_REFUSED_READ) === true;
+        return [
+            {
+                callId,
+                ...(content === undefined ? {} : { content }),
+                ...(denial !== undefined && attributable
+                    ? { denial }
+                    : refusedByRule
+                        ? { denial: { kind: RULE_REFUSED_READ_KIND, recognised: true } }
+                        : {}),
+                ...(launched && attributable ? { launchNotice: true } : {}),
+                spilledFiles: spilledFilesIn(block[FIELDS.blockContent], payload),
+            },
+        ];
+    });
+    return { results, denialUnattributed: denial !== undefined && !attributable };
+}
+/**
+ * A result may be a string or a structure; either way the model holds what was written, never a summary. A list of
+ * text blocks is read as its words (`specs/2026-09-15-what-came-back.md` R1b): all 15 delegating results of the measured session
+ * take that form, and held encoded, a line break inside one was an escape - a report was then never found in its own
+ * result, and its length was the length of the encoding. Any other structure is kept encoded, as before.
+ */
+function textOf(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) && value.length > 0 && value.every(isTextBlock)) {
+        return value.map((block) => block[FIELDS.blockText]).join('\n');
+    }
+    return JSON.stringify(value);
+}
+function isTextBlock(value) {
+    return isJsonObject(value) && value[FIELDS.blockType] === TEXT_BLOCK_TYPE && typeof value[FIELDS.blockText] === 'string';
+}
+function spilledFilesIn(...positions) {
+    return positions.flatMap((position) => {
+        const text = textOf(position);
+        return text === undefined ? [] : toolResultReferences(text);
+    });
+}

package/dist/adapter/claude-code/hooks/hook-output.js

@@ -0,0 +1,42 @@
+import { HOOK_OUTPUT, TERMINAL } from '../contract/hooks.js';
+/** C0 and C1 control characters, and DEL: any of them in the words would take the sequence outside the allowlist. */
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/g;
+/**
+ * A hook's stdout carrying a terminal notification with these words, or nothing for no words
+ * (`specs/2026-09-16-when-an-agent-finishes.md` R15). Control characters are replaced before the words go in, since
+ * Claude Code ignores the field whole when the sequence leaves the allowlist; `;` is kept out of the title, where
+ * OSC 777 reads it as the end of the title.
+ */
+export function terminalNotice(title, text) {
+    if (text === '')
+        return '';
+    const body = text.replace(CONTROL, ' ');
+    const heading = title.replace(CONTROL, ' ').replaceAll(';', ' ');
+    const { osc, bel, notify, notifyWithTitle } = TERMINAL;
+    const sequence = `${osc}${notify};${heading}: ${body}${bel}${osc}${notifyWithTitle};${heading};${body}${bel}`;
+    return JSON.stringify({ [HOOK_OUTPUT.terminalSequence]: sequence });
+}
+/**
+ * A hook's stdout carrying a `systemMessage` with these words, or nothing for no words
+ * (`specs/2026-09-16-a-notice-in-the-conversation.md` R4). Only `Stop` shows it — B6a measured it rendered under the
+ * assistant's reply as `Stop says: …`, and B4d and B4f measured `SubagentStop` discarding it — so the event that
+ * returns this is decided by the caller. Control characters go, as they do in a terminal sequence.
+ */
+export function chatNotice(text) {
+    return text === '' ? '' : JSON.stringify({ [HOOK_OUTPUT.systemMessage]: text.replace(CONTROL, ' ') });
+}
+/**
+ * A hook's stdout keeping the turn from ending, so that the session's own agent says the finding itself
+ * (`specs/2026-09-21-the-agent-tells-you.md` R9, R11). The exit code stays 0: this is the JSON form of the same
+ * control, and exit 2 is what R2 of `a-notice-in-the-conversation` forbids for good.
+ *
+ * The line goes out beside it, because B9b measured both shown and R11 keeps it: the line is agentwhy's own
+ * record of what it found, in words the agent's message cannot soften.
+ */
+export function blockNotice(reason, text) {
+    return JSON.stringify({
+        [HOOK_OUTPUT.decision]: HOOK_OUTPUT.block,
+        [HOOK_OUTPUT.reason]: reason.replace(CONTROL, ' '),
+        ...(text === '' ? {} : { [HOOK_OUTPUT.systemMessage]: text.replace(CONTROL, ' ') }),
+    });
+}

package/dist/adapter/claude-code/hooks/pre-tool-use-input.js

@@ -0,0 +1,23 @@
+import { PRE_TOOL_USE } from '../contract/hooks.js';
+import { isJsonObject, parseJsonObject } from '../../../shared/json.js';
+/**
+ * Reads the text a `PreToolUse` hook was given. A call to any tool but the shell is `another-tool`: a hook installed
+ * without a matcher sees every call, and those are not this command's to judge, so they pass without a word. Never
+ * throws. The working directory is carried when the input has one.
+ */
+export function parsePreToolUseInput(text) {
+    const input = parseJsonObject(text);
+    if (input === undefined)
+        return { unusable: 'not-json' };
+    const { fields } = PRE_TOOL_USE;
+    if (input[fields.event] !== PRE_TOOL_USE.event)
+        return { unusable: 'another-event' };
+    if (input[fields.toolName] !== PRE_TOOL_USE.shellTool)
+        return { anotherTool: true };
+    const toolInput = input[fields.toolInput];
+    const command = isJsonObject(toolInput) ? toolInput[fields.command] : undefined;
+    if (typeof command !== 'string')
+        return { unusable: 'field-missing' };
+    const cwd = input[fields.cwd];
+    return typeof cwd === 'string' && cwd !== '' ? { command, cwd } : { command };
+}

package/dist/adapter/claude-code/hooks/stop-input.js

@@ -0,0 +1,25 @@
+import { STOP, SUBAGENT_STOP } from '../contract/hooks.js';
+import { parseJsonObject } from '../../../shared/json.js';
+export function parseStopInput(text) {
+    const input = parseJsonObject(text);
+    if (input === undefined)
+        return { unusable: 'not-json' };
+    const { fields } = STOP;
+    if (input[fields.event] !== STOP.event)
+        return { unusable: 'another-event' };
+    const sessionId = input[fields.sessionId];
+    if (typeof sessionId !== 'string' || sessionId === '')
+        return { unusable: 'field-missing' };
+    const transcriptPath = input[SUBAGENT_STOP.fields.transcriptPath];
+    const lastMessage = input[SUBAGENT_STOP.fields.lastMessage];
+    return {
+        turn: {
+            sessionId,
+            // Anything but `true` is read as "not inside one": a flag this version cannot read must never be the reason
+            // a person is told nothing, and the block it guards is refused by the store's own record as well.
+            active: input[fields.active] === true,
+            ...(typeof transcriptPath === 'string' && transcriptPath !== '' ? { transcriptPath } : {}),
+            ...(typeof lastMessage === 'string' ? { lastMessage } : {}),
+        },
+    };
+}

package/dist/adapter/claude-code/hooks/subagent-stop-input.js

@@ -0,0 +1,26 @@
+import { SUBAGENT_STOP } from '../contract/hooks.js';
+import { parseJsonObject } from '../../../shared/json.js';
+/** Reads the text a hook was given on standard input. Never throws: an input it cannot use is a named answer. */
+export function parseSubagentStopInput(text) {
+    const input = parseJsonObject(text);
+    if (input === undefined)
+        return { unusable: 'not-json' };
+    const { fields } = SUBAGENT_STOP;
+    if (input[fields.event] !== SUBAGENT_STOP.event)
+        return { unusable: 'another-event' };
+    const transcriptPath = input[fields.transcriptPath];
+    const agentId = input[fields.agentId];
+    if (typeof transcriptPath !== 'string' || transcriptPath === '' || typeof agentId !== 'string' || agentId === '') {
+        return { unusable: 'field-missing' };
+    }
+    const lastMessage = input[fields.lastMessage];
+    const sessionId = input[fields.sessionId];
+    return {
+        agent: {
+            transcriptPath,
+            agentId,
+            ...(typeof lastMessage === 'string' ? { lastMessage } : {}),
+            ...(typeof sessionId === 'string' && sessionId !== '' ? { sessionId } : {}),
+        },
+    };
+}

package/dist/adapter/claude-code/policy/deny-rules.js

@@ -0,0 +1,46 @@
+import { isJsonObject, parseJsonObject } from '../../../shared/json.js';
+/**
+ * Reads protected paths out of a Claude Code settings file's deny list.
+ *
+ * The limit is the point of test A7: a deny rule names **a tool and a route**, not a resource. `Read(./.env*)`
+ * carries a path and can be read as one; `Bash(cat:*.env*)` is a command pattern and is not a path at all.
+ * Pretending to understand the second would hand the reader a policy the tool never applied, so those entries
+ * are counted as ignored and the report says how many.
+ */
+const FILE_RULE = /^(Read|Edit|Write|NotebookEdit)\(([^)]+)\)$/;
+/** The path a deny rule names, when the rule is one about files at all. `Bash(cat:*)` names none (test A7). */
+export function fileRulePathOf(entry) {
+    return FILE_RULE.exec(entry.trim())?.[2];
+}
+const DENY_KEYS = { permissions: 'permissions', deny: 'deny' };
+export function readDenyRules(text) {
+    const settings = parseJsonObject(text);
+    const permissions = settings?.[DENY_KEYS.permissions];
+    const deny = isJsonObject(permissions) ? permissions[DENY_KEYS.deny] : undefined;
+    if (!Array.isArray(deny))
+        return undefined;
+    const entries = deny.filter((entry) => typeof entry === 'string');
+    const patterns = entries.flatMap((entry) => {
+        const match = FILE_RULE.exec(entry);
+        const path = match?.[2];
+        return path === undefined ? [] : [toPattern(path)];
+    });
+    return { patterns: [...new Set(patterns)], used: patterns.length, ignored: deny.length - patterns.length };
+}
+/**
+ * A deny rule is written relative to a project or a home directory, while a transcript records the path the
+ * tool was given, often absolute. Anchoring at any depth keeps the two comparable. It **broadens** the match,
+ * which errs toward reporting a call rather than passing over it - the safe direction here.
+ */
+export function toPattern(path) {
+    const relative = path.replace(/^\.\//, '').replace(/^~\//, '');
+    return relative.startsWith('**/') || relative.startsWith('/') ? relative : `**/${relative}`;
+}
+export function policyFromDenyRules(rules, path) {
+    return {
+        level: 'no-read',
+        protected: rules.patterns.map((pattern) => ({ pattern })),
+        allowed: [],
+        origin: { kind: 'settings', path, used: rules.used, ignored: rules.ignored },
+    };
+}

package/dist/adapter/claude-code/probe/claude-code-probe.js

@@ -0,0 +1,86 @@
+import { FileAccessError } from '../../../ports/file-access-error.js';
+import { toLabel } from '../../../shared/label.js';
+import { CONTRACT_VERSION, VERIFIED_AGAINST } from '../contract/version.js';
+import { MetaTally } from './meta-tally.js';
+import { SessionTally } from './session-tally.js';
+import { TranscriptTally } from './transcript-tally.js';
+export class ClaudeCodeProbe {
+    #files;
+    constructor(files) {
+        this.#files = files;
+    }
+    async probe(session) {
+        const tally = new SessionTally();
+        const main = new TranscriptTally(tally.collectors);
+        const subagents = new TranscriptTally(tally.collectors);
+        if (session.mainTranscript.present)
+            await this.#readTranscript(session.mainTranscript.path, main);
+        for (const source of session.subagents) {
+            if (source.transcript.present)
+                await this.#readTranscript(source.transcript.path, subagents);
+        }
+        const meta = await this.#readMeta(session.subagents);
+        return {
+            schemaVersion: 4,
+            contractVersion: CONTRACT_VERSION,
+            verifiedAgainst: VERIFIED_AGAINST.claudeCode,
+            sessionId: toLabel(session.sessionId),
+            sources: sourcesOf(session),
+            toolVersions: tally.toolVersions(),
+            workingDirectories: tally.workingDirectories(),
+            main: main.toStats(),
+            subagents: subagents.toStats(),
+            meta,
+            agentToolInputKeys: tally.agentToolInputKeys(),
+            denials: tally.denials(),
+            toolResultReferences: tally.toolResultReferences(session.toolResultFiles),
+            taskNotifications: tally.taskNotifications(),
+        };
+    }
+    async #readTranscript(path, tally) {
+        tally.recordFile();
+        try {
+            for await (const raw of this.#files.readLines(path))
+                tally.recordLine(raw);
+        }
+        catch (error) {
+            if (!(error instanceof FileAccessError))
+                throw error;
+            tally.recordUnreadableFile();
+        }
+    }
+    async #readMeta(sources) {
+        const tally = new MetaTally();
+        for (const source of sources) {
+            if (!source.meta.present)
+                continue;
+            try {
+                tally.recordFile(await this.#files.readText(source.meta.path));
+            }
+            catch (error) {
+                if (!(error instanceof FileAccessError))
+                    throw error;
+                tally.recordUnreadableFile();
+            }
+        }
+        return tally.toStats();
+    }
+}
+function sourcesOf(session) {
+    return {
+        mainTranscript: state(session.mainTranscript),
+        subagentsDirectory: state(session.subagentsDir),
+        toolResultsDirectory: state(session.toolResultsDir),
+        subagentFiles: {
+            total: session.subagents.length,
+            withTranscript: session.subagents.filter((source) => source.transcript.present).length,
+            withMeta: session.subagents.filter((source) => source.meta.present).length,
+            incompletePairs: session.subagents.filter((source) => source.transcript.present !== source.meta.present).length,
+        },
+        toolResultFiles: session.toolResultFiles.length,
+        unrecognisedEntries: session.unrecognised.length,
+    };
+}
+function state(presence) {
+    return presence.present ? 'present' : presence.reason;
+}

package/dist/adapter/claude-code/probe/collectors/agent-tool-input-key-collector.js

@@ -0,0 +1,24 @@
+import { Counter } from '../../../../shared/counter.js';
+import { isJsonObject } from '../../../../shared/json.js';
+import { toLabel } from '../../../../shared/label.js';
+import { AGENT_TOOL, FIELDS } from '../../contract/fields.js';
+import { toolUseBlocks } from '../transcript-line.js';
+export class AgentToolInputKeyCollector {
+    #keys = new Counter();
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        for (const block of toolUseBlocks(json)) {
+            if (block[FIELDS.toolName] !== AGENT_TOOL.name)
+                continue;
+            const input = block[FIELDS.toolInput];
+            if (isJsonObject(input)) {
+                for (const key of Object.keys(input))
+                    this.#keys.add(toLabel(key));
+            }
+        }
+    }
+    counts() {
+        return this.#keys.toCounts();
+    }
+}

package/dist/adapter/claude-code/probe/collectors/denial-kind-collector.js

@@ -0,0 +1,20 @@
+import { byString } from '../../../../shared/compare.js';
+import { Counter } from '../../../../shared/counter.js';
+import { toLabel } from '../../../../shared/label.js';
+import { isKnownDenialKind } from '../../contract/denials.js';
+import { FIELDS } from '../../contract/fields.js';
+export class DenialKindCollector {
+    #kinds = new Counter();
+    #unknownKinds = new Set();
+    collect({ json }) {
+        if (json === undefined || !(FIELDS.denialKind in json))
+            return;
+        const kind = json[FIELDS.denialKind];
+        this.#kinds.add(toLabel(kind));
+        if (!isKnownDenialKind(kind))
+            this.#unknownKinds.add(toLabel(kind));
+    }
+    stats() {
+        return { byKind: this.#kinds.toCounts(), unknownKinds: [...this.#unknownKinds].sort(byString) };
+    }
+}

package/dist/adapter/claude-code/probe/collectors/denied-call-collector.js

@@ -0,0 +1,11 @@
+import { FIELDS } from '../../contract/fields.js';
+export class DeniedCallCollector {
+    #deniedCalls = 0;
+    collect({ json }) {
+        if (json !== undefined && FIELDS.denialKind in json)
+            this.#deniedCalls += 1;
+    }
+    deniedCalls() {
+        return this.#deniedCalls;
+    }
+}

package/dist/adapter/claude-code/probe/collectors/identifier-collector.js

@@ -0,0 +1,19 @@
+import { identifierMatches } from '../../contract/identifiers.js';
+export class IdentifierCollector {
+    #toolUseIds = new Set();
+    #uuids = new Set();
+    // Reads the raw text, so the identifiers on an unparsable line still count.
+    collect({ raw }) {
+        const identifiers = identifierMatches(raw);
+        for (const id of identifiers.toolUseIds)
+            this.#toolUseIds.add(id);
+        for (const id of identifiers.uuids)
+            this.#uuids.add(id);
+    }
+    uniqueToolUseIds() {
+        return this.#toolUseIds.size;
+    }
+    uniqueUuids() {
+        return this.#uuids.size;
+    }
+}

package/dist/adapter/claude-code/probe/collectors/line-collector.js

@@ -0,0 +1 @@
+export {};

package/dist/adapter/claude-code/probe/collectors/line-type-collector.js

@@ -0,0 +1,29 @@
+import { byString } from '../../../../shared/compare.js';
+import { Counter } from '../../../../shared/counter.js';
+import { toLabel } from '../../../../shared/label.js';
+import { FIELDS } from '../../contract/fields.js';
+import { SYSTEM_LINE_TYPE, classifyLineType } from '../../contract/line-types.js';
+export class LineTypeCollector {
+    #lineTypes = new Counter();
+    #unknownLineTypes = new Set();
+    #systemSubtypes = new Counter();
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        const type = json[FIELDS.lineType];
+        this.#lineTypes.add(toLabel(type));
+        if (classifyLineType(type) === 'unknown')
+            this.#unknownLineTypes.add(toLabel(type));
+        if (type === SYSTEM_LINE_TYPE)
+            this.#systemSubtypes.add(toLabel(json[FIELDS.systemSubtype]));
+    }
+    lineTypes() {
+        return this.#lineTypes.toCounts();
+    }
+    unknownLineTypes() {
+        return [...this.#unknownLineTypes].sort(byString);
+    }
+    systemSubtypes() {
+        return this.#systemSubtypes.toCounts();
+    }
+}

package/dist/adapter/claude-code/probe/collectors/sidechain-collector.js

@@ -0,0 +1,20 @@
+import { FIELDS } from '../../contract/fields.js';
+export class SidechainCollector {
+    #sidechain = { true: 0, false: 0, absent: 0, invalid: 0 };
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        const value = json[FIELDS.sidechain];
+        if (value === true)
+            this.#sidechain.true += 1;
+        else if (value === false)
+            this.#sidechain.false += 1;
+        else if (value === undefined)
+            this.#sidechain.absent += 1;
+        else
+            this.#sidechain.invalid += 1;
+    }
+    stats() {
+        return { ...this.#sidechain };
+    }
+}

package/dist/adapter/claude-code/probe/collectors/task-notification-collector.js

@@ -0,0 +1,51 @@
+import { AGENT_TOOL, FIELDS } from '../../contract/fields.js';
+import { USER_LINE_TYPE } from '../../contract/line-types.js';
+import { notificationsIn } from '../../contract/task-notifications.js';
+import { toolUseBlocks, wordsWithoutResult } from '../transcript-line.js';
+/**
+ * Notifications delivered on a user line, by what they name (`specs/2026-09-15-where-the-value-went.md` R4): a
+ * delegating call, another call, a call no transcript of the session holds, or nothing. Only the first is read as a
+ * report, so the rest are counted here rather than lost. Fed every transcript, because a notification and the call it
+ * names need not sit in the same one.
+ */
+export class TaskNotificationCollector {
+    #calls = new Set();
+    #delegatingCalls = new Set();
+    #named = [];
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        for (const block of toolUseBlocks(json)) {
+            const id = block[FIELDS.blockId];
+            if (typeof id !== 'string')
+                continue;
+            this.#calls.add(id);
+            if (block[FIELDS.toolName] === AGENT_TOOL.name)
+                this.#delegatingCalls.add(id);
+        }
+        if (json[FIELDS.lineType] !== USER_LINE_TYPE)
+            return;
+        const words = wordsWithoutResult(json);
+        if (words === undefined)
+            return;
+        for (const { callId } of notificationsIn(words))
+            this.#named.push(callId);
+    }
+    stats() {
+        let namingADelegation = 0;
+        let namingAnotherCall = 0;
+        let namingNoCall = 0;
+        let withoutCallId = 0;
+        for (const callId of this.#named) {
+            if (callId === undefined)
+                withoutCallId += 1;
+            else if (this.#delegatingCalls.has(callId))
+                namingADelegation += 1;
+            else if (this.#calls.has(callId))
+                namingAnotherCall += 1;
+            else
+                namingNoCall += 1;
+        }
+        return { delivered: this.#named.length, namingADelegation, namingAnotherCall, namingNoCall, withoutCallId };
+    }
+}

package/dist/adapter/claude-code/probe/collectors/tool-result-reference-collector.js

@@ -0,0 +1,31 @@
+import { FIELDS, TOOL_RESULT_BLOCK_TYPE } from '../../contract/fields.js';
+import { toolResultReferences } from '../../contract/layout.js';
+import { contentBlocks } from '../transcript-line.js';
+export class ToolResultReferenceCollector {
+    #referenced = new Set();
+    // Only result positions count. A tool-results path in a prompt, in assistant text or in a tool input is a
+    // mention, not a spill reference, and counting it would report a missing spilled result that never existed
+    // (lesson L009).
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        const results = [json[FIELDS.toolUseResult]];
+        for (const block of contentBlocks(json)) {
+            if (block[FIELDS.blockType] === TOOL_RESULT_BLOCK_TYPE)
+                results.push(block[FIELDS.blockContent]);
+        }
+        for (const result of results) {
+            if (result === undefined)
+                continue;
+            const text = typeof result === 'string' ? result : JSON.stringify(result);
+            for (const name of toolResultReferences(text))
+                this.#referenced.add(name);
+        }
+    }
+    // Counts only: a file name captured from a transcript is free text and must not reach the output (lesson L009).
+    stats(availableFiles) {
+        const available = new Set(availableFiles);
+        const referenced = [...this.#referenced];
+        return { referenced: referenced.length, missing: referenced.filter((name) => !available.has(name)).length };
+    }
+}