@manyoars/oars 0.3.0 → 0.4.0

package/dist/sessions/derive.js

@@ -3,7 +3,7 @@
 // version-2 extractor line for line (error_signatures.py, prompt_graphs.py, cost_per_class.py), and the recovery episodes match
 // recovery_episodes.py, so the numbers measured before the split reproduce after it.
 import { captureSession, classify, compress, cut, EDITS, EXPLORE, ACT, normalize, SHELL, shortName } from './extract.js';
-import { INTERRUPT_MARKER, REJECTED_RE } from './session-shape.js';
+import { DECLINED_RE, INTERRUPT_MARKER, REJECTED_RE } from './session-shape.js';
 import { ERROR_EXAMPLE_CHARS, EXTRACTOR_VERSION, } from './schema.js';
 const byPosition = (a, b) => a.n - b.n;
 /** The `<tool> | <normalized line>` key; the line was redacted at capture, and normalize can expose a shape the first pass missed. */
@@ -109,9 +109,15 @@ const stoppedOf = (errors, nextHead) => {
         return 'rejected';
     return nextHead?.startsWith(INTERRUPT_MARKER) === true ? 'interrupt' : null;
 };
-/** The prompts whose edit a later prompt repeated. One walk in call order: a commit settles every path edited so far, so it empties the map. */
-const redonePrompts = (calls) => {
+/** A decline in the fixed text Codex or Gemini CLI writes (`DECLINED_RE`). It is read for `intervention` only: `stopped` stays as the books and the gold arms read it. */
+const declinedIn = (errors) => errors.some((error) => DECLINED_RE.test(error.line));
+/**
+ * The prompts whose edit a later prompt repeated, and of those the ones the very next prompt repeated (`immediate`, the `redo` bucket of `intervention`). One walk in call order: a commit settles every path
+ * edited so far, so it empties the map. `nextOf` gives a prompt's next record.
+ */
+const redonePrompts = (calls, nextOf) => {
     const redone = new Set();
+    const immediate = new Set();
     const lastEditor = new Map();
     for (const call of calls) {
         if (commitsIn(call) > 0)
@@ -120,10 +126,59 @@ const redonePrompts = (calls) => {
             const earlier = lastEditor.get(call.target);
             if (earlier !== undefined && earlier !== call.prompt && call.prompt - earlier <= REDO_WINDOW)
                 redone.add(earlier);
+            if (earlier !== undefined && nextOf.get(earlier) === call.prompt)
+                immediate.add(earlier);
             lastEditor.set(call.target, call.prompt);
         }
     }
-    return redone;
+    return { redone, immediate };
+};
+/**
+ * A segment that undoes work in git: a revert that names a commit (a bare `git revert` is `--abort`, `--continue`, or `--quit`, whose flag the segment drops), a restore, or a bare checkout
+ * (the segment drops a path, a flag, and a word with a slash or quotes, so `git checkout -- <path>` and `git checkout feature/x` are the same bare word pair; `isGitUndo` narrows it by the step's flags).
+ */
+const GIT_UNDO = /^git (?:revert .|restore(?: |$))|^git checkout(?: \.)?$/;
+const BARE_CHECKOUT = /^git checkout$/;
+/** Flags of a `git checkout` that move to or create a branch, or leave one with a literal `-`: none of them undoes work. `<literal>` is also what the step makes of any flag off the public list (`--theirs`, `--patch`), so those read as no undo too: a limit, pinned in `intervention.test.ts`. */
+const CHECKOUT_MOVES = new Set(['<literal>', '-b', '-B', '--orphan', '--detach']);
+/** A prompt that begins by asking for the undo, in English: `revert that`, `please undo`, `rollback`. */
+const ASKS_UNDO = /^(?:please )?(?:revert|undo|roll ?back)\b/i;
+/** The capture version that keeps a `git checkout` step's `target` class. */
+const TARGET_CLASS_CAPTURE = 23;
+/** Whether the segment at index `at` is a checkout that moves to a branch: the step with the same `seg` holds the flags that the segment drops (the stored step no longer holds `run`). */
+const movesBranch = (tool, at) => {
+    const steps = tool.steps?.filter(({ seg }) => seg === at).map(({ identity }) => identity).filter((identity) => identity !== null && 'program' in identity) ?? [];
+    // From CAPTURE 23 the step names the class of what the checkout acts on: a proved path is an undo whatever the flags, and an unproved word is never one. Before it, only the flags tell.
+    if (Number(tool.cv) >= TARGET_CLASS_CAPTURE) {
+        if (steps.some((identity) => identity.target === 'path'))
+            return false;
+        if (steps.some((identity) => identity.target === 'word'))
+            return true;
+    }
+    return steps.some((identity) => identity.flags.some((flag) => CHECKOUT_MOVES.has(flag)));
+};
+/** A clean shell call that undid work in git. `git reset --hard` is read from the step, since a segment keeps no flag. */
+const isGitUndo = (tool) => SHELL.has(tool.tool) &&
+    tool.status === 'ok' &&
+    (tool.segments?.some(({ run }, at) => GIT_UNDO.test(run) && !(BARE_CHECKOUT.test(run) && movesBranch(tool, at))) === true ||
+        tool.steps?.some(({ identity }) => identity !== null && 'program' in identity && identity.program === 'git' && identity.sub === 'reset' && identity.flags.includes('--hard')) === true);
+/**
+ * What the next prompt `next` did to the work of a prompt (docs/sessions-store.md, "Prompt intervention"). First match: the last prompt or the marker's own record is `unknown`; then a stop (`stopped` set) is `user-stop`; then `revert`, `redo`,
+ * `after-error`; then `unknown` again when the next prompt ran a shell call captured before `segments`, which could have been an undo; else `none`.
+ */
+const interventionOf = (prompt, stopped, next, settled, nextCalls, immediate) => {
+    if (next === undefined || prompt.head.startsWith(INTERRUPT_MARKER))
+        return 'unknown';
+    // A stop is read before the others: a rejected call is settled as an error, so `after-error` would otherwise claim every rejection.
+    if (stopped)
+        return 'user-stop';
+    if (settled.some(isEdit) && (nextCalls.some(isGitUndo) || ASKS_UNDO.test(next.head.trimStart())))
+        return 'revert';
+    if (immediate)
+        return 'redo';
+    if (settled.at(-1)?.status === 'error')
+        return 'after-error';
+    return nextCalls.some((tool) => SHELL.has(tool.tool) && tool.segments === undefined) ? 'unknown' : 'none';
 };
 /** The version-2 prompt and error records of one transcript, with the outcome signals. */
 export const deriveSession = (capture, redact) => {
@@ -136,13 +191,21 @@ export const deriveSession = (capture, redact) => {
     const stopsOf = groupBy(firstCopies(capture.errorLines), (error) => error.prompt);
     const calls = firstCopies(tools);
     const settledOf = groupBy(calls, (tool) => tool.prompt);
-    const redone = redonePrompts(calls);
+    const nextOf = new Map();
+    for (let at = 1; at < capture.prompts.length; at++) {
+        const before = capture.prompts[at - 1];
+        const after = capture.prompts[at];
+        if (before !== undefined && after !== undefined)
+            nextOf.set(before.index, after.index);
+    }
+    const { redone, immediate } = redonePrompts(calls, nextOf);
     const prompts = capture.prompts.map((prompt, position) => {
         const mine = toolsOf.get(prompt.index) ?? [];
         const main = mine.filter((tool) => !tool.side);
         const settled = settledOf.get(prompt.index) ?? [];
         const sequence = main.map((tool) => shortName(tool.tool));
         const errors = errorsOf.get(prompt.index) ?? [];
+        const stopped = stoppedOf(stopsOf.get(prompt.index) ?? [], capture.prompts[position + 1]?.head);
         // The two main-line calls after the prompt's first main-line error (version 2 re-armed on each error and kept the first two).
         const first = errors[0];
         const recovery = first === undefined ? [] : main.filter((tool) => tool.n >= first.after).slice(0, 2).map((tool) => shortName(tool.tool));
@@ -171,6 +234,8 @@ export const deriveSession = (capture, redact) => {
             efforts: prompt.efforts,
             skills: prompt.skills,
             usage: prompt.usage,
+            ...(prompt.usageObserved === undefined ? {} : { usageObserved: prompt.usageObserved }),
+            ...(prompt.usageResponses === undefined ? {} : { usageResponses: prompt.usageResponses }),
             recovery,
             explore: sequence.filter((tool) => EXPLORE.has(tool)).length,
             strata: prompt.strata,
@@ -178,9 +243,10 @@ export const deriveSession = (capture, redact) => {
             bigrams,
             contextFingerprint: prompt.promptFingerprint,
             verify: verifyOf(settled),
-            stopped: stoppedOf(stopsOf.get(prompt.index) ?? [], capture.prompts[position + 1]?.head),
+            stopped,
             commits: settled.reduce((sum, tool) => sum + commitsIn(tool), 0),
             redo: redone.has(prompt.index),
+            intervention: interventionOf(prompt, stopped !== null || declinedIn(stopsOf.get(prompt.index) ?? []), capture.prompts[position + 1], settled, settledOf.get(capture.prompts[position + 1]?.index ?? -1) ?? [], immediate.has(prompt.index)),
             ...(prompt.frame === undefined ? {} : { frame: prompt.frame }),
         };
     });

package/dist/sessions/exclusion.d.ts

@@ -22,6 +22,12 @@ export interface Verdict {
         source: Source;
     }[];
 }
+/** The transcript files of one session, the main one first, one per path under the project folder (the harness's copy before oars' raw archive's): what a raw copy is built from, after the gate has cleared them. */
+export declare const transcriptFilesOf: (runtime: SessionsRuntime, project: string, session: string) => Promise<{
+    key: string;
+    path: string;
+    main: boolean;
+}[]>;
 /**
  * When the newest file of a session was last written, in epoch milliseconds, over the same files the gate scans (the main transcript, its subagents, and oars' raw copies), or 0 when it has none.
  * A transcript that kept growing since the last capture is newer here than in the store, so the deposit command reads it to tell a session still in progress from one that has ended.

package/dist/sessions/exclusion.js

@@ -154,6 +154,14 @@ const filesOf = async (runtime, project, session) => {
     const second = await filesIn(raw, 'raw', project, session, files);
     return { files, unreadable: unreadable || first || second };
 };
+/** The transcript files of one session, the main one first, one per path under the project folder (the harness's copy before oars' raw archive's): what a raw copy is built from, after the gate has cleared them. */
+export const transcriptFilesOf = async (runtime, project, session) => {
+    const seen = new Map();
+    for (const { key, path, main } of (await filesOf(runtime, project, session)).files)
+        if (!seen.has(key))
+            seen.set(key, { key, path, main });
+    return [...seen.values()].sort((a, b) => (a.main === b.main ? (a.key < b.key ? -1 : 1) : a.main ? -1 : 1));
+};
 /** Whether any line of the file holds a term. Streamed, so a large transcript is never held whole. */
 const holdsTerm = async (path, terms) => {
     const stream = createReadStream(path, { encoding: 'utf8' });

package/dist/sessions/extract.d.ts

@@ -110,6 +110,7 @@ export declare const pathKey: (path: string, cwd: string | undefined, root: stri
 export declare const hashPath: (path: string, cwd: string | undefined, root: string | null, salt: string) => {
     hash: string;
     base: TargetBase;
+    key: string;
 };
 /**
  * A shell call's program and subcommand from its first line (`git push`, `just build`, `npm`), as recovery_episodes.py's
@@ -144,7 +145,7 @@ export interface PlannedCommit {
 }
 export interface ShellRead {
     segments: ShellSegment[];
-    /** The same commands as `segments`, in public names only, with the redacted text they compare by. */
+    /** The same commands as `segments`, in public names, apart from a pull's package name, which is kept as it is after redaction, with the redacted text they compare by. */
     steps: ShellStepRead[];
     pulls: ToolPull[];
     commitPlan: PlannedCommit[];
@@ -167,10 +168,11 @@ export declare const commitsRead: (plan: readonly PlannedCommit[], result: strin
 export declare const storedToolName: (name: string, redact: Redactor) => string;
 /** An MCP call's full server name, which `shortName` cuts for the tool sequence, redacted because a harness takes it from the operator's config. */
 export declare const pullsOfTool: (name: string, redact: Redactor) => ToolPull[];
-/** The `target` of a tool call (see {@link ToolObservation.target}). */
+/** The `target` of a tool call (see {@link ToolObservation.target}). A path target also returns the `key` it was hashed on, read for its class and then dropped, never stored. */
 export declare const targetOf: (tool: string, input: Obj, cwd: string | undefined, salt: string, redact: Redactor, root?: string | null) => {
     target: string | null;
     base: TargetBase | null;
+    key?: string;
 };
 /** The `n` capture gives each call of a transcript, by tool-use id, the first copy of a repeated id winning; a subagent's steps name their parent by it without capturing the parent again. */
 export declare const callPositions: (text: string) => Map<string, number>;

package/dist/sessions/extract.js

@@ -7,12 +7,13 @@ import { posix } from 'node:path';
 import { ACTION_TABLES, actionOf, shellOf } from './actions.js';
 import { exploreCount, strataOf } from './strata.js';
 import { closedFrame, frameIdOf, repoFilesFromIndex, repoSizeOf, stackOf, utcDay } from './frame.js';
+import { argClassOf, targetClassOf } from './call-shape.js';
 import { LITERAL } from './public-vocabulary.js';
 import { linkSteps } from './graph.js';
 import { callIdentity, shellIdentity, UNREAD_SHELL } from './identity.js';
 import { manifestDelta, manifestFileOf, manifestNames, packagesOf } from './package-resolve.js';
-import { createShape, INTERRUPT_MARKER } from './session-shape.js';
-import { CAPTURE_VERSION, ERROR_LINE_CHARS, FILES_PER_SESSION_MAX, HTTP_STATUSES, PROMPT_HEAD_CHARS, SIGNATURE_CHARS, } from './schema.js';
+import { createShape, DECLINED_RE, INTERRUPT_MARKER } from './session-shape.js';
+import { CAPTURE_VERSION, ERROR_LINE_CHARS, FILES_PER_SESSION_MAX, HTTP_STATUSES, PROMPT_HEAD_CHARS, SIGNATURE_CHARS, USAGE_FIELDS, } from './schema.js';
 export const isObj = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const str = (value) => (typeof value === 'string' ? value : undefined);
 const num = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : undefined);
@@ -108,7 +109,8 @@ const EXIT_CODE_RE = /^Exit code:? (-?\d+)/;
 const HARNESS_ERROR_PATTERNS = [
     [/^\[Request interrupted by user/, 'interrupted'],
     // Claude Code's text, then the refusal sentences Codex (`rejected by user`, written by its adapter and by events.rs:456) and Gemini (an abort `User cancelled tool execution`; a confirmation-prompt denial `Reason: User denied execution.`, `User cancelled operation`, or `Operation cancelled by user`) write.
-    [/The user doesn't want to proceed with this tool use|The tool use was rejected|^(?:exec command|patch) rejected by user\s*$|^\[Operation Cancelled\] (?:Reason: )?(?:User (?:cancelled|denied)|Operation cancelled by user)/, 'user-rejected'],
+    // The Codex and Gemini alternatives are `DECLINED_RE`'s own source, so the error code and the `user-stop` bucket read one pattern.
+    [new RegExp(`The user doesn't want to proceed with this tool use|The tool use was rejected|${DECLINED_RE.source}`), 'user-rejected'],
     [/Permission to use [^\n]* has been denied/, 'permission-denied'],
     [/InputValidationError/, 'input-validation'],
     [/<tool_use_error>/, 'tool-use-error'],
@@ -191,6 +193,17 @@ const addUsage = (total, line) => {
     total.output += line.output;
     total.thinking += line.thinking;
 };
+const emptyCoverage = () => ({ observed: new Set(), responses: 0 });
+const addCoverage = (coverage, line) => {
+    coverage.responses += 1;
+    for (const field of line.observed)
+        coverage.observed.add(field);
+};
+/** The record fields for a total: the observed categories in the fixed order, and the responses that reported. */
+const coverageFields = (coverage) => ({
+    usageObserved: USAGE_FIELDS.filter((field) => coverage.observed.has(field)),
+    usageResponses: coverage.responses,
+});
 /** cost_per_class.py: only numeric fields count; thinking comes from `output_tokens_details`. */
 const readUsage = (message) => {
     const raw = message.usage;
@@ -198,15 +211,15 @@ const readUsage = (message) => {
         return undefined;
     const details = isObj(raw.output_tokens_details) ? raw.output_tokens_details : {};
     const thinking = num(details.thinking_tokens);
+    const input = num(raw.input_tokens);
+    const cacheWrite = num(raw.cache_creation_input_tokens);
+    const cacheRead = num(raw.cache_read_input_tokens);
+    const output = num(raw.output_tokens);
+    const reported = [['input', input], ['cacheWrite', cacheWrite], ['cacheRead', cacheRead], ['output', output], ['thinking', thinking]];
     return {
-        usage: {
-            input: num(raw.input_tokens) ?? 0,
-            cacheWrite: num(raw.cache_creation_input_tokens) ?? 0,
-            cacheRead: num(raw.cache_read_input_tokens) ?? 0,
-            output: num(raw.output_tokens) ?? 0,
-            thinking: thinking ?? 0,
-        },
+        usage: { input: input ?? 0, cacheWrite: cacheWrite ?? 0, cacheRead: cacheRead ?? 0, output: output ?? 0, thinking: thinking ?? 0 },
         hasThinking: thinking !== undefined,
+        observed: reported.filter(([, value]) => value !== undefined).map(([field]) => field),
     };
 };
 const toSeconds = (timestamp) => {
@@ -409,7 +422,7 @@ export const pathKey = (path, cwd, root) => {
 /** The per-account salted hash of a file path (16 hex characters, class A). */
 export const hashPath = (path, cwd, root, salt) => {
     const { key, base } = pathKey(path, cwd, root);
-    return { hash: sha256(`${salt}\n${key}`).slice(0, 16), base };
+    return { hash: sha256(`${salt}\n${key}`).slice(0, 16), base, key };
 };
 /** A leading `cd <dir> &&` or `cd <dir>;` hop: the target is the command that ran after it. */
 const CD_HOP = /^\s*(?:cd|Set-Location|pushd)\s+\S+\s*(?:&&|;)\s*/;
@@ -1091,7 +1104,7 @@ export const readShell = (command, redact) => {
     }
     return {
         segments: kept.map((held) => ({ run: runOf(held), read: held.read })),
-        steps: kept.map((held) => ({ identity: shellIdentity(held.program, held.args, pullsOfCommand(held.program, held.args).filter(present)), read: held.read, run: runOf(held) })),
+        steps: kept.map((held) => ({ identity: shellIdentity(held.program, held.args, pullsOfCommand(held.program, held.args).filter(present), redact), read: held.read, run: runOf(held) })),
         pulls: [...pulls.values()],
         commitPlan: commitPlanOf(commands),
     };
@@ -1196,7 +1209,7 @@ export const pullsOfTool = (name, redact) => {
     return pull === null ? [] : [pull];
 };
 /** A call's steps: one per command of a shell call, else one. */
-const draftsOf = (table, named, native, shell, target, input) => {
+const draftsOf = (table, named, native, shell, target, input, redact) => {
     const { action } = named;
     if (action === 'shell.exec') {
         const read = shell?.steps ?? [];
@@ -1206,15 +1219,15 @@ const draftsOf = (table, named, native, shell, target, input) => {
     }
     const url = str(input.url);
     const skill = str(input.skill);
-    return [{ action, ...callIdentity(table, action, native, named.native, { skill, url }), read: true, rawKey: `${native}\n${target ?? url ?? skill ?? ''}` }];
+    return [{ action, ...callIdentity(table, action, native, named.native, { skill, url, redact }), read: true, rawKey: `${native}\n${target ?? url ?? skill ?? ''}` }];
 };
-/** The `target` of a tool call (see {@link ToolObservation.target}). */
+/** The `target` of a tool call (see {@link ToolObservation.target}). A path target also returns the `key` it was hashed on, read for its class and then dropped, never stored. */
 export const targetOf = (tool, input, cwd, salt, redact, root = null) => {
     for (const key of PATH_KEYS) {
         const value = str(input[key]);
         if (value !== undefined && value !== '') {
-            const { hash, base } = hashPath(value, cwd, root, salt);
-            return { target: hash, base };
+            const { hash, base, key: hashedKey } = hashPath(value, cwd, root, salt);
+            return { target: hash, base, key: hashedKey };
         }
     }
     if (!SHELL.has(tool))
@@ -1302,6 +1315,7 @@ export const captureSession = (input) => {
         costUsd: null,
         usage: emptyUsage(),
     };
+    const sessionCoverage = emptyCoverage();
     const versions = new Set();
     const branches = new Set();
     const files = new Set();
@@ -1359,6 +1373,7 @@ export const captureSession = (input) => {
             efforts: [...cur.efforts].sort(),
             skills: [...cur.skills].sort(),
             usage: cur.usage,
+            ...coverageFields(cur.coverage),
             promptFingerprint,
         });
         promptFrames.push({ version: cur.version, model: majorityOrNull(cur.models) ?? majorityOrNull(cur.messageModels), effort: majorityOrNull(cur.effortCounts), ts: cur.ts });
@@ -1469,8 +1484,10 @@ export const captureSession = (input) => {
         }
         if (type === 'assistant' && role === 'assistant') {
             session.assistantTurns += 1;
-            if (!side && lineUsage !== undefined && firstOfResponse)
+            if (!side && lineUsage !== undefined && firstOfResponse) {
                 addUsage(session.usage, lineUsage.usage);
+                addCoverage(sessionCoverage, lineUsage);
+            }
         }
         // prompt_graphs.py and cost_per_class.py: a prompt is a main-line user line with text and no tool result. They also dropped any leading "<", which lost
         // every turn a command or a skill opened; that is now `promptOpening`'s call. A line from any other harness keeps the old rule.
@@ -1481,8 +1498,8 @@ export const captureSession = (input) => {
         if (type === 'user' && role === 'user' && !side && !hasToolResult(content)) {
             const leading = LEADING_TAG.exec(firstTextBlock(content).trimStart())?.[1];
             harnessLine = o.isMeta === true || (leading !== undefined && LOCAL_COMMAND_TAGS.has(leading));
-            // `promptOpening` is Claude Code's alone: a prompt from any other harness that starts with `<` gets no opening below, yet it is still the operator typing.
-            operatorTurn = o.isMeta !== true && (leading === 'bash-input' || hasImage(content) || (harness !== 'claude-code' && firstTextBlock(content).startsWith('<')));
+            // `promptOpening` is Claude Code's alone: a prompt from any other harness that starts with `<` gets no opening below, yet it is still the operator typing, except the output of a `!` command, which is the harness's own line (an agent turn, as under Claude Code).
+            operatorTurn = o.isMeta !== true && (leading === 'bash-input' || hasImage(content) || (harness !== 'claude-code' && leading !== 'bash-stdout' && leading !== 'bash-stderr' && firstTextBlock(content).startsWith('<')));
         }
         if (type === 'user' && role === 'user' && o.isMeta !== true && !side) {
             const text = firstTextBlock(content);
@@ -1510,6 +1527,7 @@ export const captureSession = (input) => {
                     efforts: new Set(),
                     skills: new Set(),
                     usage: emptyUsage(),
+                    coverage: emptyCoverage(),
                     turns: 0,
                     version: version !== undefined && version !== '' ? version : undefined,
                     effortCounts: new Map(),
@@ -1536,8 +1554,10 @@ export const captureSession = (input) => {
                         cur.models.set(requested, (cur.models.get(requested) ?? 0) + 1);
                     if (realMessageModel !== undefined)
                         bump(cur.messageModels, realMessageModel);
-                    if (lineUsage !== undefined && firstOfResponse)
+                    if (lineUsage !== undefined && firstOfResponse) {
                         addUsage(cur.usage, lineUsage.usage);
+                        addCoverage(cur.coverage, lineUsage);
+                    }
                 }
             }
             // prompt_graphs.py reads efforts and skills from every line.
@@ -1602,7 +1622,7 @@ export const captureSession = (input) => {
                 const shell = SHELL.has(name) || named.action === 'shell.exec' ? readShell(str(toolInput.command) ?? '', redact) : undefined;
                 for (const held of shell?.steps ?? [])
                     framePrograms.add(held.identity.program);
-                drafts.push(draftsOf(actions, named, native, shell, aimed.target, toolInput));
+                drafts.push(draftsOf(actions, named, native, shell, aimed.target, toolInput, redact));
                 responseOfCall.push(response);
                 callsPerResponse.set(response, (callsPerResponse.get(response) ?? 0) + 1);
                 const manifestFile = PATH_TOOLS.has(name) && filePath !== undefined ? manifestFileOf(filePath) : null;
@@ -1611,6 +1631,9 @@ export const captureSession = (input) => {
                     manifestReads.set(id, manifestFile);
                 const pulls = shell?.pulls ?? pullsOfTool(name, redact);
                 const packages = packagesOf(pulls, seenPackages);
+                // Who made the call, from its own line: the model is not the prompt's majority, and a line inside a skill's run names the skill (the first line after the run does not).
+                const callModel = requested !== undefined && requested !== '' ? requested : realMessageModel;
+                const callSkill = truthy(o.attributionSkill) ? String(o.attributionSkill) : undefined;
                 const call = {
                     kind: 'tool',
                     cv: CAPTURE_VERSION,
@@ -1626,9 +1649,14 @@ export const captureSession = (input) => {
                     target: aimed.target,
                     targetBase: aimed.base,
                     keys: Object.keys(toolInput).sort(),
+                    // The class reads the key the target is hashed on (relative to the repository or the cwd), never the absolute path: the folders above a repository say nothing about the file.
+                    targetClass: targetClassOf(aimed.key, aimed.base),
+                    argClass: argClassOf(toolInput),
                     durationMs: null,
                     toolUseId: id ?? null,
                     harnessVersion: version ?? null,
+                    ...(callModel === undefined ? {} : { model: callModel }),
+                    ...(callSkill === undefined ? {} : { skill: callSkill }),
                     side,
                     prompt: cur?.index ?? null,
                     ...(shell === undefined ? {} : { segments: shell.segments }),
@@ -1684,7 +1712,7 @@ export const captureSession = (input) => {
         }
     }
     finish();
-    Object.assign(session, shape.finish());
+    Object.assign(session, shape.finish(), coverageFields(sessionCoverage));
     session.versions = [...versions].sort();
     session.branches = [...branches].sort();
     const kept = [...files].sort().slice(0, FILES_PER_SESSION_MAX);
@@ -1724,14 +1752,18 @@ export const captureSession = (input) => {
         const response = responseOfCall[position];
         const output = response === undefined ? undefined : outputPerResponse.get(response);
         const tokens = response === undefined || output === undefined || output === 0 ? null : Math.round(output / (callsPerResponse.get(response) ?? 1));
-        call.steps = (drafts[position] ?? []).map((draft, seg) => ({
+        const draftsOfCall = drafts[position] ?? [];
+        // A failed call of several read commands (`a && b`) says that the call failed, not which command did: the result carries one exit, so no segment is `error` on that evidence and the failure stays on the call.
+        const chainFailed = call.status === 'error' && draftsOfCall.filter((draft) => draft.read).length > 1;
+        const allocated = tokens !== null && response !== undefined && (callsPerResponse.get(response) ?? 1) > 1;
+        call.steps = draftsOfCall.map((draft, seg) => ({
             n: call.n,
             seg,
             action: draft.action,
             native: draft.native,
             identity: draft.identity,
-            status: draft.read ? call.status : 'none',
-            cost: seg === 0 ? { tokens, durationMs: call.durationMs } : { tokens: null, durationMs: null },
+            status: draft.read && !chainFailed ? call.status : 'none',
+            cost: seg === 0 ? { tokens, durationMs: call.durationMs, ...(allocated ? { allocated: true } : {}) } : { tokens: null, durationMs: null },
             parent: origin?.spawnedAt ?? null,
             edges: [],
             frameId,

package/dist/sessions/hook-calls.js

@@ -3,7 +3,7 @@ import { appendFile, mkdir, readFile } from 'node:fs/promises';
 import { paths } from './store.js';
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const eventOf = (value) => {
-    if (value === 'session-start' || value === 'pre-tool' || value === 'post-tool' || value === 'stop' || value === 'nightly')
+    if (value === 'session-start' || value === 'prompt' || value === 'pre-tool' || value === 'post-tool' || value === 'stop' || value === 'nightly')
         return value;
     return undefined;
 };

package/dist/sessions/hook-index.d.ts

@@ -1,4 +1,6 @@
 import type { Read } from './read.js';
+import type { Position, RecoveryEdges } from './recall-next.js';
+import type { NextByFrame } from './recall-frames.js';
 import { type RecallRead } from './recall-reads.js';
 import { type Store } from './store.js';
 /** A signature is "recurring" once it has been seen in this many sessions. */
@@ -33,8 +35,19 @@ export interface HookIndex {
     fit?: {
         [readId: string]: RecallRead;
     };
+    /**
+     * The local pool's recovery edges, by the asker's frame key (`frameKeyOf`: harness and version bucket) and then `action/errorCode`. Every key is kept, one under `RECOVERY_FLOOR` too,
+     * so `PostToolUseFailure` can tell a cell too thin to serve (silent) from no cell (the signature line may answer). An index a version before this wrote has none.
+     */
+    recoveryByFrame?: {
+        [frame: string]: RecoveryEdges;
+    };
+    /** The local pool's split positions (t782's rule) by the asker's frame key, most observed first. */
+    positionsByFrame?: {
+        [frame: string]: Position[];
+    };
 }
-export declare const buildIndex: (store: Store, redactDomains: readonly string[], at: string, reads?: readonly Read[]) => HookIndex;
+export declare const buildIndex: (store: Store, redactDomains: readonly string[], at: string, reads?: readonly Read[], next?: NextByFrame) => HookIndex;
 export declare const indexPath: (storeDir: string) => string;
 /** The index as written, or undefined when there is none (or it is torn): a hook then says nothing. */
 export declare const readIndex: (storeDir: string) => Promise<HookIndex | undefined>;

package/dist/sessions/hook-index.js

@@ -4,7 +4,7 @@
 import { readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { resolveReads } from './recall-pool.js';
-import { aboveBaseRate, fitReads, toolShapeId } from './recall-reads.js';
+import { aboveBaseRate, fitReads, PUSH_FLOORS, toolShapeId } from './recall-reads.js';
 import { expandHome } from './allow.js';
 import { slugOf } from './store.js';
 const INDEX_FILE = 'hook-index.json';
@@ -33,7 +33,7 @@ const repositoryOf = (projects) => {
         return bases.find((candidate) => base === candidate || base.startsWith(`${candidate}-`)) ?? base;
     };
 };
-export const buildIndex = (store, redactDomains, at, reads = []) => {
+export const buildIndex = (store, redactDomains, at, reads = [], next) => {
     const projectOf = new Map(store.sessions.map((session) => [session.session, session.project]));
     // The latest 300 of each repository, not of the whole store: another repository's deposits must not move this one's ranking.
     const family = repositoryOf([...new Set(store.sessions.map((session) => session.project))]);
@@ -87,7 +87,14 @@ export const buildIndex = (store, redactDomains, at, reads = []) => {
         if (rows.length > 0)
             projects[project] = rows;
     }
-    return { at, redactDomains: [...redactDomains], projects, signatures, fit: Object.fromEntries(resolveReads(aboveBaseRate(store, fitReads(store)), reads).map((read) => [toolShapeId(read.tool, read.keys), read])) };
+    return {
+        at,
+        redactDomains: [...redactDomains],
+        projects,
+        signatures,
+        fit: Object.fromEntries(resolveReads(aboveBaseRate(store, fitReads(store, PUSH_FLOORS)), reads).map((read) => [toolShapeId(read.tool, read.keys), read])),
+        ...(next === undefined ? {} : { recoveryByFrame: next.recovery, positionsByFrame: next.positions }),
+    };
 };
 export const indexPath = (storeDir) => join(storeDir, INDEX_FILE);
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);

package/dist/sessions/hooks.d.ts

@@ -1,13 +1,17 @@
+import { type Emit } from '../telemetry/emit.js';
 import type { HookCall } from './schema.js';
 import { type SessionsRuntime } from './store.js';
+import type { NightlyTelemetry } from '../telemetry/health.js';
 export type HookEvent = HookCall['event'];
 export declare const HOOK_EVENTS: readonly HookEvent[];
 /** The runtime a hook process runs with. Only `nightly` reads the non-Claude stores (a saved `--allow cursor` or `--allow codex`); the Stop path stays free of it. */
 export declare const hookRuntime: (event: HookEvent, env: {
     [name: string]: string | undefined;
 }, platform: NodeJS.Platform, home: string, io: Pick<SessionsRuntime, "stdin" | "stdout">) => SessionsRuntime;
+/** What the nightly run records with, and nothing for any other hook: the telemetry folder sits beside the session store under the config directory, so `oars telemetry` and the nightly run read and write the same one. The version is read only for the nightly run, so the per-tool hooks never touch the manifest. */
+export declare const nightlyTelemetry: (event: HookEvent, env: NodeJS.ProcessEnv, platform: NodeJS.Platform, home: string, version: () => string, now: () => number) => NightlyTelemetry | undefined;
 /**
  * Runs one hook. It never fails or blocks the session it runs in: whatever happens, it resolves (the process exits 0), and the
  * hook-call line records the outcome, with the failure's first line when there was one, so the record is evidence, not a claim.
  */
-export declare const runHook: (event: HookEvent, stdin: string, runtime: SessionsRuntime, now: () => number) => Promise<string | undefined>;
+export declare const runHook: (event: HookEvent, stdin: string, runtime: SessionsRuntime, now: () => number, telemetry?: NightlyTelemetry, emit?: Emit) => Promise<string | undefined>;