@manyoars/oars 0.4.0 → 0.5.1

package/dist/sessions/extract.js

@@ -7,8 +7,8 @@ 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 { argClassOf, argFeaturesOf, argNamesOf, argValuesOf, changeKindOf, diffShapeOf, targetClassOf, templatesOf, variableOf } from './call-shape.js';
+import { CLOSED_ARG_VALUES, 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';
@@ -94,6 +94,23 @@ export const isErrorResult = (block, text) => {
     const exit = EXIT_RE.exec(text.trim());
     return exit !== null && exit[1] !== '0';
 };
+/** The first 32 hex digits of the SHA-256 of a text's exact UTF-8 bytes: plain, not keyed, so the same text matches across sessions and accounts, and a line ending or a trailing space is a difference. */
+const textDigest = (text) => createHash('sha256').update(text, 'utf8').digest('hex').slice(0, 32);
+/**
+ * The digests of an edit call's text, from the input: an Edit has one old and new pair, a MultiEdit one per edit in order, a Write a new digest only (its old text is not in the call, so no old digest is held, not the digest of an
+ * empty string). Any other tool, and an edit whose input holds no text for the side it needs, has none: a malformed entry of a MultiEdit is skipped.
+ */
+const editDigestsOf = (tool, input) => {
+    if (tool === 'Write') {
+        const content = str(input.content);
+        return content === undefined ? [] : [{ new: textDigest(content) }];
+    }
+    const edits = tool === 'MultiEdit' && Array.isArray(input.edits) ? input.edits.filter(isObj) : tool === 'Edit' ? [input] : [];
+    return edits.flatMap((edit) => {
+        const [old, replacement] = [str(edit.old_string), str(edit.new_string)];
+        return old === undefined || replacement === undefined ? [] : [{ old: textDigest(old), new: textDigest(replacement) }];
+    });
+};
 /** What an Edit, MultiEdit, or Write shows of a manifest: the names it adds and removes (an edit), or lists (a write). Undefined when it shows none. */
 const manifestOfInput = (file, tool, input, redact) => {
     if (tool === 'Write') {
@@ -222,6 +239,28 @@ const readUsage = (message) => {
         observed: reported.filter(([, value]) => value !== undefined).map(([field]) => field),
     };
 };
+/** The usage categories a line reported, as the fields of a `MessageUsage`; a category the source left out is not written. */
+const reportedUsage = (line) => {
+    const fields = {};
+    for (const field of USAGE_FIELDS)
+        if (line.observed.includes(field))
+            fields[field] = line.usage[field];
+    return fields;
+};
+const planWindowOf = (raw) => {
+    if (!isObj(raw))
+        return undefined;
+    const usedPercent = num(raw.usedPercent);
+    const windowMinutes = num(raw.windowMinutes);
+    return usedPercent === undefined ? undefined : { usedPercent, ...(windowMinutes === undefined ? {} : { windowMinutes }) };
+};
+/** The plan share a Codex line carries (`rateLimits`, written by `rolloutLines`), or undefined when it carries none. */
+const planOf = (line) => {
+    const limits = isObj(line.rateLimits) ? line.rateLimits : undefined;
+    const primary = planWindowOf(limits?.primary);
+    const secondary = planWindowOf(limits?.secondary);
+    return primary === undefined && secondary === undefined ? undefined : { ...(primary === undefined ? {} : { primary }), ...(secondary === undefined ? {} : { secondary }) };
+};
 const toSeconds = (timestamp) => {
     if (timestamp === undefined)
         return undefined;
@@ -289,7 +328,7 @@ const hasToolResult = (content) => Array.isArray(content) && content.some((block
 const hasImage = (content) => Array.isArray(content) && content.some((block) => isObj(block) && block.type === 'image');
 // The tags a local command (a slash command the harness ran itself) leaves as user lines. A model's answer to a command makes it a prompt, and that case never reaches
 // the run: a tag listed here that is still on a line there was not answered.
-const LOCAL_COMMAND_TAGS = new Set(['command-name', 'command-message', 'local-command-stdout', 'local-command-stderr', 'local-command-caveat']);
+export const LOCAL_COMMAND_TAGS = new Set(['command-name', 'command-message', 'local-command-stdout', 'local-command-stderr', 'local-command-caveat']);
 const firstTextBlock = (content) => {
     if (typeof content === 'string')
         return content;
@@ -545,22 +584,106 @@ const VERSIONED = /^(@?[^@:\s]+)@(?!\d+\.\d+\.\d+\.\d+$)(v?\d+(?:\.(?:\d+|x|\*))
 const redactCommand = (command, redact) => redact(command.replace(/[^\s"'`]+/g, (word) => word.replace(VERSIONED, `$1${VERSION_AT}$2`))).replaceAll(VERSION_AT, '@');
 const MASK = /^<(?:secret|email|org-domain)>/;
 const ONLY_MASKS = /^(?:<(?:secret|email|org-domain)>)+$/;
-const tokenize = (text) => {
+/** Where the single-quoted text that opens at `open` ends: the closing quote, or the end of the text. Bash's ANSI-C string (`$'it\'s'`) honors a backslash, so its `\'` is inside it; any other single-quoted text ends at the next `'`. */
+const singleQuotedEnd = (text, open, ansiC = true) => {
+    const ansi = ansiC && text.charAt(open - 1) === '$';
+    let end = open + 1;
+    while (end < text.length && text.charAt(end) !== "'")
+        end += ansi && text.charAt(end) === '\\' ? 2 : 1;
+    return Math.min(end, text.length);
+};
+/** What closes each opener that can hold quotes of its own inside a double-quoted piece: a command substitution (`$(`, a backtick) or a parameter expansion (`${x:-"a b"}`). */
+const CLOSERS = new Map([
+    ['$(', ')'],
+    ['${', '}'],
+    ['`', '`'],
+]);
+/**
+ * Where the substitution or expansion that began just before `from`, closed by `first`, ends: past its closing character, or -1 when it never closes (PowerShell's backtick is an escape, not an opener, and a torn command has no end).
+ * Whatever quoting it holds is its own: a quote inside it never ends the double-quoted piece that carries it, so a quote cannot move the reader's state. An explicit stack keeps a crafted command that nests without end from
+ * overflowing the call stack, and `budget` (characters left to scan across one read) keeps one that opens thousands of them from costing a scan to the end of the text each.
+ */
+const substitutionEnd = (text, from, first, budget, powershell) => {
+    const stack = [first];
+    let at = from;
+    // PowerShell's escape is the backtick, and a backslash is an ordinary character there.
+    const escape = powershell ? '`' : '\\';
+    // Inside a double-quoted piece or an expansion a single quote and a bare parenthesis are text; inside a substitution they quote and group.
+    while (at < text.length && stack.length > 0 && budget.left > 0) {
+        budget.left -= 1;
+        const char = text.charAt(at);
+        const top = stack.at(-1);
+        const opener = CLOSERS.get(char === '$' ? char + text.charAt(at + 1) : char);
+        at += 1;
+        if (char === escape)
+            at += 1;
+        else if (char === top)
+            stack.pop();
+        else if (opener !== undefined) {
+            stack.push(opener);
+            at += char === '$' ? 1 : 0;
+        }
+        else if (char === '"')
+            stack.push('"');
+        else if (char === "'" && (top === ')' || top === '`'))
+            at = singleQuotedEnd(text, at - 1, !powershell) + 1;
+        else if (char === '(' && (top === ')' || top === '`'))
+            stack.push(')');
+    }
+    return stack.length === 0 ? at : -1;
+};
+/** What an unquoted word holds before its first quote when it is an assignment or a joined long flag: `API_REGION=` and `--region=`, with whatever unquoted text follows the `=`. */
+const JOINED_PREFIX = /^(?:[A-Za-z_][A-Za-z0-9_]*|--[A-Za-z][A-Za-z0-9_-]*)=/;
+/**
+ * The command's opaque point: its first single quote, heredoc marker, typographic quote (U+2018 to U+201E), block comment opener (`<#`), or stop-parsing token (`--%`). An unexpanded `$name` can only come from literal text, and
+ * these are where literal text begins in either shell, so a word that starts before this point is read as the shell reads it, and every word at or after it is opaque: it holds no variable and no flag value, whatever the reader made
+ * of the quotes before it. The point does not depend on the dialect, since a harness may run a PowerShell command and not say so (Codex, a nested `pwsh -c`); a PowerShell form in a POSIX command is rare, and the point only sends less.
+ */
+const OPAQUE_POINT = /['‘-„]|<<|<#|--%/;
+/**
+ * `opaqueFrom` is where that point sits in `text` (-1 for none, 0 for a text that is opaque throughout, as a word an opaque word holds is); left out, it is the first point of the text. A substitution opened inside double quotes
+ * lowers it to where it opens, since its end is read by a scan that can close early: every word that starts after it is opaque, as is every word that starts after an unquoted backtick or an escaped double quote, which count only in a POSIX shell (PowerShell's backtick is its escape).
+ */
+const tokenize = (text, opaqueFrom, dialect = 'posix') => {
+    let opaque = opaqueFrom ?? text.search(OPAQUE_POINT);
     const tokens = [];
+    // PowerShell's escape is the backtick, a backslash is an ordinary character in and out of quotes, `$'` is no ANSI-C string, and a backtick opens no substitution.
+    const powershell = dialect === 'powershell';
+    const escape = powershell ? '`' : '\\';
     let word = '';
     let quoted = false;
+    // The word's raw source starts with an unquoted `NAME=` or `--flag=` before its first quote: the prefix is as written, whatever the quote makes of the rest.
+    let joined = false;
     let started = false;
     let redirected = false;
+    let at = 0;
+    // Where the word's raw source starts in `text`: a word that is exactly one variable reference carries that variable, and any other word carries none, whatever its quotes and `$` marks hold.
+    let start = -1;
+    const budget = { left: 16 * text.length + 1024 };
     const flush = () => {
         if (started && redirected)
             redirected = false;
         else if (started && !quoted && (word === '{' || word === '}'))
             tokens.push(word === '{' ? 'open' : 'close');
-        else if (started)
-            tokens.push({ text: word, quoted });
+        else if (started) {
+            const held = { text: word, quoted };
+            if (opaque >= 0 && start >= opaque)
+                held.opaque = true;
+            else {
+                const variable = variableOf(text.slice(start, at));
+                if (variable !== undefined)
+                    held.variable = variable;
+                // A single quote or a substitution after the `=` is an opaque point inside the word (the value is literal text there), so only a plain double-quoted value is read.
+                if (joined && (opaque < 0 || opaque >= at))
+                    held.joined = true;
+            }
+            tokens.push(held);
+        }
         word = '';
         quoted = false;
+        joined = false;
         started = false;
+        start = -1;
     };
     const op = (token) => {
         flush();
@@ -571,13 +694,17 @@ const tokenize = (text) => {
             return;
         tokens.push(token);
     };
-    let at = 0;
     while (at < text.length) {
         const char = text.charAt(at);
         const next = text.charAt(at + 1);
+        const here = at;
+        if ((char === "'" || char === '"') && !quoted && JOINED_PREFIX.test(word))
+            joined = true;
+        // An unquoted backtick opens a substitution whose end the reader does not scan for: an escaped quote inside it reads as a bare one, so every word that starts after it is opaque, as after a substitution inside double quotes.
+        if (!powershell && char === '`')
+            opaque = opaque < 0 ? at : Math.min(opaque, at);
         if (char === "'") {
-            const end = text.indexOf("'", at + 1);
-            const stop = end < 0 ? text.length : end;
+            const stop = singleQuotedEnd(text, at, !powershell);
             word += text.slice(at + 1, stop);
             quoted = true;
             started = true;
@@ -588,23 +715,49 @@ const tokenize = (text) => {
             started = true;
             at += 1;
             while (at < text.length && text.charAt(at) !== '"') {
-                if (text.charAt(at) === '\\' && text.charAt(at + 1) === '\n')
+                const inner = text.charAt(at);
+                const after = text.charAt(at + 1);
+                const opener = inner === '$' ? inner + after : inner;
+                const closer = powershell && inner === '`' ? undefined : CLOSERS.get(opener);
+                if (closer === ')' || closer === '`')
+                    opaque = opaque < 0 ? at : Math.min(opaque, at);
+                const end = closer === undefined ? -1 : substitutionEnd(text, at + opener.length, closer, budget, powershell);
+                if (inner === escape && (after === escape || after === '$' || after === '`')) {
+                    // A backslash pair is one escaped backslash, so the second never escapes the quote after it; an escaped dollar or backtick opens nothing.
+                    word += inner + after;
                     at += 2;
-                else if (text.charAt(at) === '\\' && text.charAt(at + 1) === '"') {
+                }
+                else if (inner === escape && after === '\n') {
+                    at += 2;
+                }
+                else if (inner === escape && after === '"') {
+                    // POSIX reads the escaped quote as data, but the same text under PowerShell (a Codex call is stored as `Bash` whatever shell ran it) ends the string there, so every word after it may be read with the quote state inverted.
+                    if (!powershell)
+                        opaque = opaque < 0 ? at : Math.min(opaque, at);
                     word += '"';
                     at += 2;
                 }
+                else if (end >= 0) {
+                    // A command substitution stays whole in this word: a quote inside it is its own, and never closes this piece. One that never closes is read as the text it is.
+                    word += text.slice(at, end);
+                    at = end;
+                }
                 else {
-                    word += text.charAt(at);
+                    word += inner;
                     at += 1;
                 }
             }
             at += 1;
         }
-        else if ((char === '\\' || char === '`') && next === '\n') {
+        else if (!powershell && char === '\\' && next === '\\') {
+            word += '\\\\';
+            started = true;
+            at += 2;
+        }
+        else if ((char === escape || char === '`') && next === '\n') {
             at += 2;
         }
-        else if (char === '\\' && next !== '' && /[\s&|;()<>'"]/.test(next)) {
+        else if (char === escape && next !== '' && (powershell || /[\s&|;()<>'"]/.test(next))) {
             word += next;
             started = true;
             at += 2;
@@ -668,6 +821,8 @@ const tokenize = (text) => {
             started = true;
             at += 1;
         }
+        if (started && start < 0)
+            start = here;
     }
     flush();
     return tokens;
@@ -701,7 +856,7 @@ const afterPrelude = (words) => {
         const word = words[at];
         if (word === undefined)
             return [];
-        if (word.quoted)
+        if (word.quoted && word.joined !== true)
             return words.slice(at);
         const name = programOf(word) ?? word.text;
         if (BLOCK_WORDS.has(word.text.toLowerCase()) || ASSIGNMENT.test(word.text))
@@ -749,7 +904,8 @@ const shellArgument = (program, args) => {
     const first = flag < 0 ? undefined : args[flag + 1];
     if (first === undefined)
         return null;
-    return JOINING_SHELLS.has(program) && !first.quoted ? args.slice(flag + 1) : tokenize(first.text);
+    // The argument's own text is read for its own first quote or marker, unless the word is opaque already: then nothing in it is read.
+    return JOINING_SHELLS.has(program) && !first.quoted ? args.slice(flag + 1) : tokenize(first.text, first.opaque === true ? 0 : undefined);
 };
 /** How many shells deep a command is read. Real commands nest two or three; the cap keeps a torn or hostile one from exhausting the stack. */
 const SHELL_DEPTH_MAX = 8;
@@ -769,10 +925,11 @@ const readCommands = (tokens, depth = 0) => {
     const owned = new Map();
     const close = () => {
         const real = afterPrelude(words);
+        const before = words.slice(0, words.length - real.length);
         words = [];
         const [head, ...args] = real;
         const program = head === undefined ? null : programOf(head);
-        if (program === null)
+        if (program === null || head === undefined)
             return;
         const previous = commands.at(-1);
         if (previous !== undefined)
@@ -791,7 +948,7 @@ const readCommands = (tokens, depth = 0) => {
         });
         owned.clear();
         pending = [];
-        commands.push({ program, args, read: true, link: 'end', hidden: false });
+        commands.push({ program, args, before, head, read: true, link: 'end', hidden: false });
     };
     for (const token of tokens) {
         if (typeof token === 'string') {
@@ -1085,17 +1242,73 @@ const isReadBack = (commands, from, scope) => {
     }
     return false;
 };
+const RESTORE_VALUE_FLAGS = new Set(['-s', '--source', '--pathspec-from-file']);
+const STAGED_FLAG = /^(?:--staged|-[a-zA-Z]*S[a-zA-Z]*)$/;
+const WORKTREE_FLAG = /^(?:--worktree|-[a-zA-Z]*W[a-zA-Z]*)$/;
+const PATCH_FLAG = /^(?:--patch|-[a-zA-Z]*p[a-zA-Z]*)$/;
+/** The words a `git restore` or `git checkout --` takes as paths to the working file. `git restore --staged` alone restores the index, and `--patch` restores part of a file, so neither names a whole file; `git checkout` with no `--` may name a branch. */
+const restoredBy = (git) => {
+    const words = git.args;
+    if (git.sub === 'checkout') {
+        const dashes = words.findIndex((word) => !word.quoted && word.text === '--');
+        // `git checkout --patch` takes part of a file, as `git restore --patch` does, so it names no whole file.
+        if (dashes < 0 || words.slice(0, dashes).some((word) => !word.quoted && PATCH_FLAG.test(word.text)))
+            return [];
+        return words.slice(dashes + 1).map((word) => word.text);
+    }
+    if (git.sub !== 'restore')
+        return [];
+    const paths = [];
+    let staged = false;
+    let worktree = false;
+    for (let at = 0; at < words.length; at += 1) {
+        const text = words[at]?.text ?? '';
+        if (text === '--')
+            return staged && !worktree ? [] : [...paths, ...words.slice(at + 1).map((word) => word.text)];
+        if (PATCH_FLAG.test(text))
+            return [];
+        if (RESTORE_VALUE_FLAGS.has(text))
+            at += 1;
+        else if (text.startsWith('-')) {
+            staged ||= STAGED_FLAG.test(text);
+            worktree ||= WORKTREE_FLAG.test(text);
+        }
+        else
+            paths.push(text);
+    }
+    return staged && !worktree ? [] : paths;
+};
+/**
+ * The paths the call's `git restore` and `git checkout --` commands name, for a command whose status the call reports and that runs in the call's folder: after a `cd`, or under a repository flag (`-C`), a relative path means another folder.
+ * A word that holds a variable is no path.
+ */
+const restoredPaths = (commands) => {
+    const folderAt = commands.findIndex((command) => CHANGES_FOLDER.has(command.program));
+    return (folderAt < 0 ? commands : commands.slice(0, folderAt)).flatMap((command) => {
+        const git = command.read ? gitCall(command) : null;
+        return git === null || git.scope !== '' ? [] : restoredBy(git).filter((path) => path !== '' && !path.includes('$'));
+    });
+};
 const commitPlanOf = (commands) => commands.flatMap((command, at) => {
     const git = gitCall(command);
     if (git === null || git.sub !== 'commit' || git.args.some((word) => !word.quoted && NOT_A_COMMIT.test(word.text)))
         return [];
     return [{ quiet: git.args.some((word) => !word.quoted && QUIET.test(word.text)), readBack: isReadBack(commands, at, git.scope) }];
 });
-/** Every simple command of a shell call, in order, after the bodies are dropped and the command is redacted. `oars gate` reads the same commands as capture. */
-export const shellCommands = (command, redact) => readCommands(tokenize(redactCommand(dropBodies(command.replace(/\r\n/g, '\n')), redact)));
+/** Every simple command of a shell call, in order, after the bodies are dropped and the command is redacted. Capture passes the dialect of the tool; `gate/checks.ts:524` and `projection.ts:95` call it with the POSIX default. */
+export const shellCommands = (command, redact, dialect = 'posix') => {
+    const whole = command.replace(/\r\n/g, '\n');
+    const kept = dropBodies(whole);
+    const text = redactCommand(kept, redact);
+    // The command's opaque point (`tokenize`) is read on the whole command. Dropping a body or redacting can remove it and leave a later one in its place, and the words between would read as before it: when the first point
+    // moved or a point is gone, the whole text is opaque.
+    const points = (held) => held.match(new RegExp(OPAQUE_POINT.source, 'g'))?.length ?? 0;
+    const moved = kept.search(OPAQUE_POINT) !== whole.search(OPAQUE_POINT) || points(text) !== points(kept);
+    return readCommands(tokenize(text, moved ? 0 : undefined, dialect));
+};
 /** A shell call's segments, pulls, and the commits it holds, from the command alone. The command is redacted before anything is kept. */
-export const readShell = (command, redact) => {
-    const commands = shellCommands(command, redact);
+export const readShell = (command, redact, dialect = 'posix') => {
+    const commands = shellCommands(command, redact, dialect);
     const kept = commands.slice(-SEGMENTS_PER_CALL_MAX);
     const pulls = new Map();
     for (const { program, args } of commands) {
@@ -1103,10 +1316,12 @@ export const readShell = (command, redact) => {
             pulls.set(JSON.stringify(pull), pull);
     }
     return {
+        words: commands.map(({ before, head, args }) => ({ before, head, args })),
         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), redact), read: held.read, run: runOf(held) })),
         pulls: [...pulls.values()],
         commitPlan: commitPlanOf(commands),
+        restores: restoredPaths(commands),
     };
 };
 const COMMIT_LINE = /^\[[^\]\n]* ([0-9a-f]{7,40})\]/gm;
@@ -1330,6 +1545,8 @@ export const captureSession = (input) => {
     const skeletonLines = [];
     const toolById = new Map();
     const callById = new Map();
+    // The last call of each tool in each prompt, so the next one states what changed. Its raw input is held only while this transcript is read.
+    const lastCall = new Map();
     // Packages named so far in this file, by package and version, so a call's `first` mark is true once per version.
     const seenPackages = new Set();
     // A Read of a manifest shows its names in the result, so the call waits here for it, by tool_use id.
@@ -1348,6 +1565,9 @@ export const captureSession = (input) => {
     const callsPerResponse = new Map();
     const outputPerResponse = new Map();
     const seenResponses = new Set();
+    /** The distinct messages that reported usage, by message key, and the tool-use ids each made (kept apart so a call on a line before the first usage line is still tied). */
+    const messageGroups = new Map();
+    const callsOfMessage = new Map();
     let promptFingerprint = null;
     let cur;
     // The setup, funnel, and trust shape. A subagent's run is the parent's, so it has no run of its own alone.
@@ -1482,6 +1702,13 @@ export const captureSession = (input) => {
                 session.userTurns += 1;
             }
         }
+        // A message is the unit usage belongs to: the same id on every content-block line is one message, and a replayed line is the same one again.
+        // Only Claude Code and Codex report per-message counts; another harness's totals are not a message's, and a synthetic line is the harness speaking.
+        const messageKey = (harness === 'claude-code' || harness === 'codex') && messageModel !== '<synthetic>' && type === 'assistant' && role === 'assistant' ? str(message.id) || str(o.requestId) || `line ${String(position)}` : undefined;
+        if (messageKey !== undefined && lineUsage !== undefined && !messageGroups.has(messageKey)) {
+            const plan = planOf(o);
+            messageGroups.set(messageKey, { id: str(message.id) || str(o.requestId) || null, calls: [], ...(side ? { side: true } : {}), ...reportedUsage(lineUsage), ...(plan === undefined ? {} : { plan }) });
+        }
         if (type === 'assistant' && role === 'assistant') {
             session.assistantTurns += 1;
             if (!side && lineUsage !== undefined && firstOfResponse) {
@@ -1619,7 +1846,7 @@ export const captureSession = (input) => {
                 else if (SHELL.has(name))
                     session.bashCmds += 1;
                 const aimed = targetOf(name, toolInput, lineCwd, salt, redact, lineRoot);
-                const shell = SHELL.has(name) || named.action === 'shell.exec' ? readShell(str(toolInput.command) ?? '', redact) : undefined;
+                const shell = SHELL.has(name) || named.action === 'shell.exec' ? readShell(str(toolInput.command) ?? '', redact, shellName === 'powershell' ? 'powershell' : 'posix') : undefined;
                 for (const held of shell?.steps ?? [])
                     framePrograms.add(held.identity.program);
                 drafts.push(draftsOf(actions, named, native, shell, aimed.target, toolInput, redact));
@@ -1634,6 +1861,22 @@ export const captureSession = (input) => {
                 // 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;
+                // Depth reads below the repository root, else the working folder, as the target's hash does; a relative value is taken from the working folder first.
+                const argFeatures = argFeaturesOf(native, toolInput, lineRoot ?? lineCwd, lineCwd);
+                const argValues = argValuesOf(native, toolInput, CLOSED_ARG_VALUES);
+                // A name is stored as the line's text is: masked at capture, so a credential-shaped folder or file name never reaches the store. The mask has no name shape, so the wire still drops it and counts it.
+                const names = argNamesOf(native, toolInput, lineRoot ?? lineCwd, lineCwd, shell?.words ?? [], CLOSED_ARG_VALUES, shell?.restores ?? []).map(({ kind, name }) => ({ kind, name: redact(name) }));
+                const digests = editDigestsOf(name, toolInput);
+                // A restored path is hashed as an edit's target is, so the two compare; the same call's folder and repository anchor a relative one.
+                const restores = [...new Set((shell?.restores ?? []).map((path) => hashPath(path, lineCwd, lineRoot, salt).hash))];
+                // A template keeps a program, a subcommand, and flags as written and every literal as a slot; its kept words are masked as a name is, and the wire gates each one again.
+                const templates = templatesOf(shell?.words ?? [], redact);
+                // An edit is stored as the shapes of its change from a closed list, read from the old and new text and never kept.
+                const diffShape = diffShapeOf(name, toolInput);
+                const compared = { input: toolInput, target: aimed.target, features: argFeatures, values: argValues };
+                const lastKey = `${String(cur?.index ?? null)}\n${String(side)}\n${stored}`;
+                const before = lastCall.get(lastKey);
+                lastCall.set(lastKey, compared);
                 const call = {
                     kind: 'tool',
                     cv: CAPTURE_VERSION,
@@ -1652,6 +1895,14 @@ export const captureSession = (input) => {
                     // 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),
+                    argFeatures,
+                    ...(argValues.length === 0 ? {} : { argValues }),
+                    ...(names.length === 0 ? {} : { names }),
+                    ...(digests.length === 0 ? {} : { digests }),
+                    ...(restores.length === 0 ? {} : { restores }),
+                    ...(templates.length === 0 ? {} : { templates }),
+                    ...(diffShape.length === 0 ? {} : { diffShape }),
+                    ...(before === undefined ? {} : { changeKind: changeKindOf(before, compared) }),
                     durationMs: null,
                     toolUseId: id ?? null,
                     harnessVersion: version ?? null,
@@ -1665,6 +1916,8 @@ export const captureSession = (input) => {
                     ...(manifest === undefined ? {} : { manifest }),
                 };
                 tools.push(call);
+                if (id !== undefined && messageKey !== undefined)
+                    callsOfMessage.set(messageKey, [...(callsOfMessage.get(messageKey) ?? []), id]);
                 if (id !== undefined)
                     callById.set(id, { call, at: lineSeconds, plan: shell?.commitPlan ?? [] });
             }
@@ -1718,7 +1971,7 @@ export const captureSession = (input) => {
     const kept = [...files].sort().slice(0, FILES_PER_SESSION_MAX);
     session.files = kept;
     session.fileHashes = [...new Set(kept.flatMap((path) => [...(fileHashes.get(path) ?? [])]))].sort();
-    session.repo = sessionRoot === null ? null : sha256(`${salt}\nrepo:${identityOf(sessionRoot)}`).slice(0, 16);
+    session.repo = sessionRoot === null ? null : sha256(`${input.repoSalt ?? salt}\nrepo:${identityOf(sessionRoot)}`).slice(0, 16);
     session.urls = [...urls].sort();
     session.searches = [...searches].sort();
     const repoFiles = input.repoFiles ?? repoFilesFromIndex;
@@ -1769,6 +2022,10 @@ export const captureSession = (input) => {
             frameId,
         }));
     }
+    for (const [key, group] of messageGroups)
+        group.calls = callsOfMessage.get(key) ?? [];
+    if (messageGroups.size > 0)
+        session.messageUsage = [...messageGroups.values()];
     // The strata: the file's evidence once, and each prompt's own `explore` from one pass over the calls. The size is the one the frame holds, so a re-capture that carries `repoSize` keeps `repoFiles` too.
     const packageNames = tools.flatMap((call) => [...(call.packages ?? []).map((pkg) => pkg.package), ...(call.manifest?.seen ?? []), ...(call.manifest?.added ?? [])]);
     const fileStrata = strataOf({ paths: framePaths, packages: packageNames, size });

package/dist/sessions/gemini.d.ts

@@ -23,6 +23,8 @@ export interface GeminiStore {
     transcript: (session: GeminiSession) => Promise<string>;
     /** Sessions skipped because their id is not a safe file name (it names a skeleton), counted so the skip is never silent. */
     rejected: number;
+    /** Files dropped as holding nothing that held a record of a shape the reader does not know (a renamed message type or content key). Read only by `sessions verify`; selection is unchanged. */
+    shapeMoved: number;
     /** Items that could not be inspected, reported once each and never fatal; the reason names no path. */
     unreadable: {
         file: string;

package/dist/sessions/gemini.js

@@ -474,6 +474,28 @@ const holdsNothing = (text, id) => {
         return false;
     }
 };
+/** The message types the CLI writes (chatRecordingService.ts): a prompt, a response, and the notices that carry no turn. */
+const KNOWN_MESSAGE_TYPES = new Set(['user', 'gemini', 'info', 'warning', 'error']);
+/** True when a prompt carries parts and none of them is a `text`, a `functionResponse`, or an `inlineData` or `fileData` (an image-only prompt): the parts' key moved. */
+const holdsUnreadParts = (message) => {
+    const parts = partsOf(message.content);
+    return message.type === 'user' && parts.length > 0 && !parts.some((part) => typeof part.text === 'string' || 'functionResponse' in part || 'inlineData' in part || 'fileData' in part);
+};
+/**
+ * True when a chat dropped as holding nothing held records in a shape the reader does not know, not a launch and quit. Four shapes: a folded message of a type outside the known ones,
+ * or a prompt or response with no `content`; a prompt whose parts carry no `text`, `functionResponse`, `inlineData`, or `fileData`; a line that is an object but not a head, `$set`, `$patch`, `$rewindTo`, or a
+ * message with a string `id` (`foldChat` discards it); and a legacy `.json` head with no `messages` list (a line-format head carries none).
+ */
+const holdsMovedShape = (text, file) => {
+    const whole = wholeObject(text);
+    if (whole !== undefined && extname(file) === '.json' && !Array.isArray(whole.messages))
+        return true;
+    const records = whole === undefined ? lineTexts(text).map(parse) : [whole];
+    const unplaced = records.some((record) => isObj(record) && str(record.sessionId) === undefined && str(record.id) === undefined && !isObj(record.$set) && !isObj(record.$patch) && typeof record.$rewindTo !== 'string');
+    if (unplaced)
+        return true;
+    return foldChat(text).messages.some((message) => typeof message.type !== 'string' || !KNOWN_MESSAGE_TYPES.has(message.type) || ((message.type === 'user' || message.type === 'gemini') && !('content' in message)) || holdsUnreadParts(message));
+};
 /** The project roots a runtime folder's registry knows (`projects.json`, config/projectRegistry.ts:15-22): its keys. A missing or torn registry names none. */
 const registered = async (runtime) => {
     const registry = parse(await readFile(join(runtime, 'projects.json'), 'utf8').catch(() => ''));
@@ -497,11 +519,12 @@ export const openGeminiStore = async (root) => {
     if (bases.length === 0) {
         if (unreadable.length === 0)
             return undefined;
-        return { sessions: [], transcript: () => Promise.reject(new Error('no sessions')), rejected: 0, unreadable };
+        return { sessions: [], transcript: () => Promise.reject(new Error('no sessions')), rejected: 0, shapeMoved: 0, unreadable };
     }
     // A file is a candidate under its session id.
     const found = new Map();
     let rejected = 0;
+    let shapeMoved = 0;
     const list = async (dir) => {
         try {
             return (await readdir(dir, { withFileTypes: true })).map((entry) => ({ name: entry.name, directory: entry.isDirectory() })).sort((a, b) => a.name.localeCompare(b.name));
@@ -530,8 +553,11 @@ export const openGeminiStore = async (root) => {
                 return;
             }
             // Every new chat appends a head (geminiChat.ts:453), so a launch and quit, or a /clear, leaves a file with nothing in it: no session, and not an unreadable one.
-            if (holdsNothing(text, named))
+            if (holdsNothing(text, named)) {
+                if (holdsMovedShape(text, file))
+                    shapeMoved += 1;
                 return;
+            }
             const session = { id, folder, file, size: info.size, mtimeMs: Math.floor(info.mtimeMs), parent };
             // A `.json` file migrated to `.jsonl` can leave both, with one name; the newer one is the session. Files of other names under one id are other chats (below).
             const key = `${id}/${name}`;
@@ -603,6 +629,7 @@ export const openGeminiStore = async (root) => {
     return {
         sessions,
         rejected,
+        shapeMoved,
         unreadable,
         transcript: async (session) => {
             const raw = await readFile(session.file, 'utf8');

package/dist/sessions/harness-files.d.ts

@@ -0,0 +1,27 @@
+import { type SessionsRuntime } from './store.js';
+export interface FileCounts {
+    /** Files the reader selected and opened: `yielded + unreadable`, always. */
+    seen: number;
+    /** Seen files that gave at least one record (a user or assistant turn). */
+    yielded: number;
+    /** Seen files the reader could not read, or that gave no record from a form it does not know. */
+    unreadable: number;
+}
+/** What the docs and the tests quote: where each kind of file goes, so `seen` is the sum of the outcomes. */
+export declare const FILE_COUNT_RULES: string;
+export type FileOutcome = 'yielded' | 'unreadable' | 'empty';
+/** `records` is undefined when the read itself failed; `headOnly` is the reader's word that a file with no turn holds only head records. */
+export declare const outcomeOf: (file: {
+    size: number;
+    records: number | undefined;
+    headOnly?: boolean;
+}) => FileOutcome;
+export declare const tally: (outcomes: readonly FileOutcome[]) => FileCounts;
+export interface HarnessFiles {
+    [harness: string]: FileCounts;
+}
+/**
+ * The counts for every harness the store reads that has files on this machine, and that the saved allowlist lets a deposit read. A harness with nothing
+ * to read has no entry. Read-only: it opens each store as the deposit does, reads each transcript, and writes nothing.
+ */
+export declare const harnessFileCounts: (runtime: SessionsRuntime) => Promise<HarnessFiles>;