@manyoars/oars 0.4.1 → 0.5.2

package/dist/sessions/public-vocabulary.js

@@ -258,6 +258,20 @@ export const HARNESS_TOOLS = new Map(Object.entries({
 export const HARNESS_AGENT_TYPES = new Map(Object.entries({
     'claude-code': 'general-purpose Explore Plan statusline-setup output-style-setup claude-code-guide',
 }).map(([harness, types]) => [harness, words(types)]));
+/**
+ * The closed values of a public tool's arguments, by tool and key: a string value on this list goes on the wire as itself (`argValues`), one off it goes nowhere. A boolean of any key is closed already and needs no row.
+ * The subagent types are the built-ins (`HARNESS_AGENT_TYPES`), so a custom agent's name is off the list.
+ */
+const BUILT_IN_AGENTS = [...(HARNESS_AGENT_TYPES.get('claude-code') ?? new Set())].join(' ');
+const CLOSED_ROWS = {
+    Agent: { subagent_type: BUILT_IN_AGENTS, model: 'sonnet opus haiku inherit' },
+    Grep: { output_mode: 'content files_with_matches count' },
+    NotebookEdit: { cell_type: 'code markdown', edit_mode: 'replace insert delete' },
+    Task: { subagent_type: BUILT_IN_AGENTS, model: 'sonnet opus haiku inherit' },
+};
+export const CLOSED_ARG_VALUES = new Map(Object.entries(CLOSED_ROWS).map(([tool, keys]) => [tool, new Map(Object.entries(keys).map(([key, values]) => [key, words(values)]))]));
+/** The keys of `CLOSED_ROWS` whose list is not exhaustive: a custom agent's name or a full model id is off it and has no `enum` cell, so the key's on-list values do not sum to the calls that send it. */
+export const OPEN_LIST_KEYS = words('subagent_type model');
 /** What a subagent type pools as when it is not a built-in: a custom agent's name is private. */
 export const CUSTOM_AGENT = 'custom';
 /** A subagent type as it pools: a built-in of a harness as itself, anything else as `custom`. */
@@ -293,3 +307,5 @@ export const TOOL_INPUT_KEYS = new Map(Object.entries({
     WebSearch: 'query allowed_domains blocked_domains',
     Write: 'file_path content',
 }).map(([tool, keys]) => [tool, words(keys)]));
+/** Every key name a public tool's pinned list holds: a value feature or closed value keyed on one of these names nothing private, so the pool serves its cell at the clear floor. */
+export const PUBLIC_INPUT_KEYS = new Set([...TOOL_INPUT_KEYS.values()].flatMap((keys) => [...keys]));

package/dist/sessions/read-call-shape.js

@@ -1,15 +1,21 @@
 // Call shape (the fit family's other method): one tool and its input key names, over the floors a shape needs before a hook may push it. A shape is what a pre-tool hook can
-// compute from the call it is about to run, so this read is what a push cites. A failure is not in a cell by shape, so its evidence is the failed one-step cells of the
-// tool's action on the days the shape failed. Same confounders as `read-fit.ts`: a failure is not a misfit, and prompt class is not adjusted for.
-import { shapeMotif } from './motif.js';
+// compute from the call it is about to run, so this read is what a push cites. Its evidence is the shape cells that count the action's calls by those key names (`shape:<action>/keys/<names>`, a week
+// cell per version bucket, `shapeClass`), in the weeks the shape failed. Same confounders as `read-fit.ts`: a failure is not a misfit, and prompt class is not adjusted for. A bundle holds no store, so the
+// pool serves the same cells as `fit-shape` (`deriveFitShape`), by every facet of shape and not this one tool's.
+import { lastDayOfCell, parseShapeClass, UNKNOWN } from './cells.js';
+import { OPEN_GATE, wireKeys } from './pool-wire.js';
 import { CALL_SHAPE_METHOD } from './read.js';
 import { actionOfShape, fitReads, toolShapeId } from './recall-reads.js';
 import { body, atGrain, rate, wilson } from './read-support.js';
 export const deriveCallShape = ({ pool, store }) => fitReads(store).flatMap((read) => {
     const action = actionOfShape(read.tool, read.harnesses);
-    const motifId = shapeMotif([{ action, identity: null }]).motifId;
-    const within = (day) => read.firstDay !== null && read.lastDay !== null && day >= read.firstDay && day <= read.lastDay;
-    const cells = atGrain(pool, 'day').filter((cell) => cell.motifId === motifId && cell.failed > 0 && within(cell.day));
+    // The cell names the keys as the wire sends them (`projectedStore`); a record captured before steps was never projected, so its raw names are the other spelling.
+    const names = new Set([wireKeys(read.keys, read.tool, OPEN_GATE).keys.join(','), read.keys.join(',')]);
+    const within = (cell) => read.firstDay !== null && read.lastDay !== null && cell.day <= read.lastDay && lastDayOfCell(cell) >= read.firstDay;
+    const cells = atGrain(pool, 'week').filter((cell) => {
+        const shape = cell.day === UNKNOWN ? null : parseShapeClass(pool.motifs.get(cell.motifId)?.cls ?? '');
+        return shape !== null && shape.action === action && shape.facet === 'keys' && names.has(shape.value) && cell.failed > 0 && within(cell);
+    });
     // A shape whose failures are in no cell has nothing to cite, so it is not a read: its answers keep their stand-in.
     if (cells.length === 0)
         return [];

package/dist/sessions/read-fit.d.ts

@@ -5,3 +5,8 @@ export declare const deriveFit: DeriveFamily;
  * this read is its own, and a read of the version cells does not see these cells (`atGrain`). A shell the frame does not name reads as `unknown`, as a missing model does.
  */
 export declare const deriveFitEnvironment: DeriveFamily;
+/**
+ * Fit by call shape: how often calls of an action fail when they hold one facet of shape (a target class, an argument class, a count of unsent key names, a set of key names, or a value feature, closed value, or change kind of a sent key), by harness version bucket, from the
+ * shape cells (`shapeClass`). A cell counts each call once per facet it holds, so the facets of one action are never summed into one rate. Same confounders as the reads above, and a facet is not the failure's cause.
+ */
+export declare const deriveFitShape: DeriveFamily;

package/dist/sessions/read-fit.js

@@ -1,8 +1,8 @@
 // Fit (rank 2): how often a tool fails on this frame, by harness version bucket and model. Effort is not in a cell (rule 3), so it is not a slice. Confounders it does not remove: a failure is not a
 // misfit, red tests can be the method, effort, and prompt class is not adjusted for.
-import { bucketFields, environmentFieldsOf } from './cells.js';
+import { bucketFields, environmentFieldsOf, parseShapeClass } from './cells.js';
 import { motifName } from './motif.js';
-import { body, environmentCells, groupBy, rate, settled, total, unitCells, wilson } from './read-support.js';
+import { atGrain, body, environmentCells, groupBy, rate, settled, total, unitCells, wilson } from './read-support.js';
 export const deriveFit = ({ pool }) => [...groupBy(unitCells(pool, 'week'), ({ cell }) => `${cell.motifId}/${cell.frameBucket}`).values()].flatMap((group) => {
     const [first] = group;
     const cells = group.map(({ cell }) => cell);
@@ -39,3 +39,24 @@ export const deriveFitEnvironment = ({ pool }) => [...groupBy(environmentCells(p
         }),
     ];
 });
+/**
+ * Fit by call shape: how often calls of an action fail when they hold one facet of shape (a target class, an argument class, a count of unsent key names, a set of key names, or a value feature, closed value, or change kind of a sent key), by harness version bucket, from the
+ * shape cells (`shapeClass`). A cell counts each call once per facet it holds, so the facets of one action are never summed into one rate. Same confounders as the reads above, and a facet is not the failure's cause.
+ */
+export const deriveFitShape = ({ pool }) => [...groupBy(atGrain(pool, 'week'), (cell) => `${cell.motifId}/${cell.frameBucket}`).values()].flatMap((group) => {
+    const [first] = group;
+    const shape = first === undefined ? null : parseShapeClass(pool.motifs.get(first.motifId)?.cls ?? '');
+    const n = total(group, settled);
+    if (first === undefined || shape === null || n === 0)
+        return [];
+    const failed = total(group, (cell) => cell.failed);
+    const { harness, harnessBucket } = bucketFields(first.frameBucket);
+    return [
+        body('fit', group, {
+            slice: { action: shape.action, facet: shape.facet, value: shape.value, harness, harnessBucket },
+            value: { failureRate: rate(failed, n), failed, ok: n - failed },
+            n,
+            interval: wilson(failed, n),
+        }),
+    ];
+});

package/dist/sessions/read-interaction.js

@@ -1,6 +1,6 @@
 // Interaction (spec Section 6, order 2): a tool fails more on one tier than another, beyond how those two tiers differ on every other tool. The difference of differences is
 // what makes it an interaction: a tier that fails more on everything has a main effect, usually the harder work it is given. The axis is the tier assigned, not a model version
-// (ruling mrd5591-08: one version per model on this store), and comparisons hold the version bucket constant. Effort is not in a cell (rule 3), so nothing here holds it. Confounders it does not remove: task assignment by
+// (ruling owner-08: one version per model on this store), and comparisons hold the version bucket constant. Effort is not in a cell (rule 3), so nothing here holds it. Confounders it does not remove: task assignment by
 // tier, which is the operator's own choice and the largest of them, effort, prompt class, and a failure not being a misfit.
 import { UNKNOWN } from './cells.js';
 import { candidateOf, differenceOf, estimateOf, screen, TRIALS_FLOOR } from './read-order.js';

package/dist/sessions/read-lead-lag.js

@@ -1,5 +1,5 @@
 // Lead-lag (spec Section 6, order 3), the labeled experiment: does a tool's failure rate moving come before its share moving? Chosen over a model release moving tool choice
-// because each model has one version here with no release date (ruling mrd5591-08), and two version boundaries are too few to cut in time, while consecutive days over many tools
+// because each model has one version here with no release date (ruling owner-08), and two version boundaries are too few to cut in time, while consecutive days over many tools
 // can be cut. A search over pairs of tools was rejected: it manufactures the false patterns Section 6 warns about, and this is one question asked once.
 //
 // A pair shares no day between its sides. A failure move ending on day d is paired with the share move from d+1 to d+2, not d to d+1: a burst of failing calls on d lifts both the

package/dist/sessions/read-readable.js

@@ -1,4 +1,4 @@
-// What this store cannot read, stated rather than forced (ruling mrd5591-08). A family that finds nothing has made no claim about why, so a reader of an empty family could take
+// What this store cannot read, stated rather than forced (ruling owner-08). A family that finds nothing has made no claim about why, so a reader of an empty family could take
 // "no reads" for "nothing moved". These rows separate the two: a question the store cannot ask from one it asked and got no answer to.
 import { interactionCandidates } from './read-interaction.js';
 import { leadLagPairs, PAIRS_FLOOR } from './read-lead-lag.js';

package/dist/sessions/read.d.ts

@@ -69,7 +69,7 @@ export interface Read {
     interval: ReadInterval | null;
     asOf: ReadAsOf;
     basis: ReadBasis;
-    /** The floor this read cleared (its family's, which is the public floor unless `floors.families` names the family): every cell it counts had at least this many clusters. Stated by a pool that serves the read, and absent from a read computed on one operator's own store, which applies no public floor. */
+    /** The lowest floor among the cells it cites, each cell's being the floor of its class in the read's family (`cellFloor`): every cell it counts had at least this many clusters. Stated by a pool that serves the read, and absent from a read computed on one operator's own store, which applies no public floor. */
     floor?: number;
 }
 /** A read before its inputs are checked and its ID and order are computed. */

package/dist/sessions/recall-consequence.d.ts

@@ -31,9 +31,9 @@ export interface RecallCountRow {
     sessions: number;
     /** The size of what was injected, or for a held recall would have been. */
     tokens: number;
-    /** Recalls with a consequence window, and of those how many followed. */
+    /** Recalls with a consequence window, and of those how many have a call whose action name is one the recall carried. */
     windows: number;
-    followed: number;
+    nameMatched: number;
     windowCalls: number;
     /** Null when no window in the row measured any tokens. */
     windowTokens: number | null;

package/dist/sessions/recall-consequence.js

@@ -3,6 +3,7 @@
 // shown recall touches the graph, because a held one reached nobody: it adds no `recall.*` step and exposes no cell.
 import { motifsOf, stepsOfCall } from './motif.js';
 import { bucketOf, floorOf } from './pool-wire.js';
+import { reversionsOf } from './reversion.js';
 import { harnessOf } from './schema.js';
 /** A consequence window ends at the prompt's end or after this many calls (spec Section 2.7). */
 export const WINDOW_CALLS = 20;
@@ -35,14 +36,16 @@ const positionOf = (line, at) => {
     const next = line.findIndex((tool) => tool.ts !== null && tool.ts > at);
     return next < 0 ? line.length : next;
 };
-const outcomeOf = (prompt) => ({
+/** The values the prompt first showed, and beside them, never in place of them, the nearest later revert of a commit the prompt made (null when none is tied). */
+const outcomeOf = (prompt, reverted) => ({
     errors: prompt?.errors ?? null,
     verify: prompt?.verify ?? null,
     stopped: prompt?.stopped ?? null,
     commits: prompt?.commits ?? null,
     redo: prompt?.redo ?? null,
+    reverted: prompt === undefined ? null : reverted,
 });
-const consequenceOf = (recall, session, line, position, harness, prompts) => {
+const consequenceOf = (recall, session, line, position, harness, prompts, reverted) => {
     const prompt = (line[position - 1] ?? line[position])?.prompt ?? null;
     const calls = [];
     let end = 'session';
@@ -64,9 +67,10 @@ const consequenceOf = (recall, session, line, position, harness, prompts) => {
         window: { from: position, to: position + calls.length, calls: calls.length, end },
         // Shape level only: it is the ID that joins across accounts, and named windows would multiply a row that exists per recall.
         motifs: [...new Set(motifsOf(steps).flatMap(({ motif }) => (motif.level === 'shape' ? [motif.motifId] : [])))],
-        followed: steps.some((step) => names.has(step.action)),
+        // The action name is the whole basis: a call of the shown action that failed, or did something else with it, still matches. The record holds no stronger evidence yet, so none is implied.
+        nameMatched: steps.some((step) => names.has(step.action)),
         cost: { tokens: measured.length === 0 ? null : measured.reduce((sum, tokens) => sum + tokens, 0), durationMs: steps.reduce((sum, step) => sum + step.durationMs, 0) },
-        outcome: outcomeOf(prompts.get(promptKey(session, prompt))),
+        outcome: outcomeOf(prompts.get(promptKey(session, prompt)), reverted(session, prompt)),
     };
 };
 /** Fills `n` and `consequence`. A recall with no session, or from a session this store does not hold, has nothing to read and comes back as it was. */
@@ -74,13 +78,14 @@ export const deriveConsequences = (store, recalls) => {
     const lines = mainLines(store);
     const prompts = new Map(store.prompts.map((prompt) => [promptKey(prompt.session, prompt.index), prompt]));
     const sessions = new Map(store.sessions.map((session) => [session.session, session]));
+    const reverted = reversionsOf(store);
     return recalls.map((recall) => {
         const session = recall.sid === null ? undefined : sessions.get(recall.sid);
         if (session === undefined)
             return recall;
         const line = lines.get(session.session) ?? [];
         const position = positionOf(line, recall.at);
-        return { ...recall, n: position, consequence: consequenceOf(recall, session.session, line, position, harnessOf(session), prompts) };
+        return { ...recall, n: position, consequence: consequenceOf(recall, session.session, line, position, harnessOf(session), prompts, reverted) };
     });
 };
 export const NO_RECALLS = {
@@ -150,7 +155,7 @@ export const recallCounts = (recalls, day) => {
         if (day !== undefined && !recall.at.startsWith(day))
             continue;
         const key = [recall.mode, recall.arm, recall.answer.kind].join(' ');
-        const held = rows.get(key) ?? { row: { mode: recall.mode, arm: recall.arm, kind: recall.answer.kind, recalls: 0, sessions: 0, tokens: 0, windows: 0, followed: 0, windowCalls: 0, windowTokens: null, overlapped: 0 }, sessions: new Set() };
+        const held = rows.get(key) ?? { row: { mode: recall.mode, arm: recall.arm, kind: recall.answer.kind, recalls: 0, sessions: 0, tokens: 0, windows: 0, nameMatched: 0, windowCalls: 0, windowTokens: null, overlapped: 0 }, sessions: new Set() };
         rows.set(key, held);
         const { row, sessions } = held;
         row.recalls += 1;
@@ -162,8 +167,8 @@ export const recallCounts = (recalls, day) => {
         if (consequence === undefined)
             continue;
         row.windows += 1;
-        if (consequence.followed)
-            row.followed += 1;
+        if (consequence.nameMatched)
+            row.nameMatched += 1;
         row.windowCalls += consequence.window.calls;
         if (consequence.cost.tokens !== null)
             row.windowTokens = (row.windowTokens ?? 0) + consequence.cost.tokens;
@@ -175,5 +180,5 @@ export const recallCounts = (recalls, day) => {
 export const formatRecallCounts = (rows) => rows.length === 0
     ? 'No recalls in that span.'
     : rows
-        .map((row) => `${row.mode} ${row.arm} ${row.kind} | ${String(row.recalls)} recalls, ${String(row.sessions)} sessions, ${String(row.tokens)} tokens | ${String(row.windows)} windows, ${String(row.followed)} followed, ${String(row.windowCalls)} calls, ${row.windowTokens === null ? 'window tokens unmeasured' : `${String(row.windowTokens)} window tokens`}, ${String(row.overlapped)} overlapped`)
+        .map((row) => `${row.mode} ${row.arm} ${row.kind} | ${String(row.recalls)} recalls, ${String(row.sessions)} sessions, ${String(row.tokens)} tokens | ${String(row.windows)} windows, ${String(row.nameMatched)} name-matched, ${String(row.windowCalls)} calls, ${row.windowTokens === null ? 'window tokens unmeasured' : `${String(row.windowTokens)} window tokens`}, ${String(row.overlapped)} overlapped`)
         .join('\n');

package/dist/sessions/recall-object.d.ts

@@ -1,3 +1,4 @@
+import type { Reversion } from './reversion.js';
 import type { Frame } from './schema.js';
 export declare const recallsPath: (storeDir: string) => string;
 /** The share of pushes held back (spec Section 8, open parameter). */
@@ -38,7 +39,7 @@ export interface RecallAnswer {
     bytes?: number;
     /** What the asker saw, or for a held recall would have seen. It holds structured fields only (`recall-render.ts`). */
     rendered: string;
-    /** The closed names a follow can match: canonical actions, in the order shown. */
+    /** The closed names a name match can find: canonical actions, in the order shown. */
     names: string[];
 }
 export type DeltaAxis = 'same' | 'differs' | 'unknown';
@@ -79,6 +80,11 @@ export interface RecallOutcome {
     stopped: string | null;
     commits: number | null;
     redo: boolean | null;
+    /**
+     * Where the nearest later clean `git revert <sha>` of a commit this prompt made ran, beside the values above and never in place of them. The sha is the whole tie, so null says none was found, not that
+     * none happened: an edit undone any other way, or a commit with no sha, is not read.
+     */
+    reverted: Reversion | null;
 }
 /** Derived from the capture records, never captured live. */
 export interface RecallConsequence {
@@ -90,7 +96,8 @@ export interface RecallConsequence {
         end: 'prompt' | 'calls' | 'session';
     };
     motifs: string[];
-    followed: boolean;
+    /** Whether an action name the recall carried appears among the window's actions. A match on the name alone: it does not say the call took the advice, was the same use of that action, or went well. */
+    nameMatched: boolean;
     /** `tokens` is null when no call in the window measured any: an older capture has no step costs, and zero would read as a free window. */
     cost: {
         tokens: number | null;

package/dist/sessions/receipt.d.ts

@@ -0,0 +1,8 @@
+import { type RecallQuery } from './query.js';
+import type { Store } from './store.js';
+export declare const RECEIPT_FOOTER = "from my local oars record, manyoars.com";
+export declare const RECEIPT_MISS = "No earlier session in the local record hit this error, so there is no receipt.";
+/** ISO 8601 week of a timestamp, as `2026-W45`; the week holds the Thursday, which fixes the year. */
+export declare const isoWeek: (ts: string) => string | undefined;
+/** The receipt for the best-matching signature of an error text, or null when no earlier session hit it. */
+export declare const receiptOf: (store: Store, query: RecallQuery, now: number, redactDomains?: readonly string[], names?: readonly string[]) => string | null;

package/dist/sessions/receipt.js

@@ -0,0 +1,78 @@
+// `oars sessions recall --error <text> --receipt`: a fenced Markdown block a person pastes into an issue on the failing tool. It states the tool and
+// harness by listed name, the error's normalized signature, how many earlier sessions hit it and in which weeks, and what those sessions did next. It
+// reads the same match recall does and the same redactor, so nothing here is a second path to a stored string.
+import { ACTION_TABLES } from './actions.js';
+import { redactTranscript } from './redact.js';
+import { recall } from './query.js';
+import { LITERAL } from './public-vocabulary.js';
+import { closedName } from './recall-render.js';
+import { harnessOf } from './schema.js';
+export const RECEIPT_FOOTER = 'from my local oars record, manyoars.com';
+export const RECEIPT_MISS = 'No earlier session in the local record hit this error, so there is no receipt.';
+const OTHER = 'other';
+const SIGNATURE_LIMIT = 120;
+const NEXT_SHOWN = 3;
+const MCP_WORD = /mcp__[A-Za-z0-9_-]+/g;
+const DAY_MS = 86_400_000;
+/** A tool as a person may name it in an issue: a listed name as it stands, anything else `other`. */
+const listedTool = (name) => {
+    const listed = closedName(name);
+    return listed === LITERAL ? OTHER : listed;
+};
+const listedHarness = (name) => (Object.hasOwn(ACTION_TABLES, name) ? name : OTHER);
+/** ISO 8601 week of a timestamp, as `2026-W45`; the week holds the Thursday, which fixes the year. */
+export const isoWeek = (ts) => {
+    const at = Date.parse(ts);
+    if (Number.isNaN(at))
+        return undefined;
+    const day = new Date(Math.floor(at / DAY_MS) * DAY_MS);
+    const weekday = day.getUTCDay() === 0 ? 7 : day.getUTCDay();
+    const thursday = new Date(day.getTime() + (4 - weekday) * DAY_MS);
+    const jan1 = Date.UTC(thursday.getUTCFullYear(), 0, 1);
+    const week = Math.floor((thursday.getTime() - jan1) / DAY_MS / 7) + 1;
+    return `${String(thursday.getUTCFullYear())}-W${String(week).padStart(2, '0')}`;
+};
+const times = (count) => `${String(count)} ${count === 1 ? 'time' : 'times'}`;
+/** The receipt for the best-matching signature of an error text, or null when no earlier session hit it. */
+export const receiptOf = (store, query, now, redactDomains = [], names = []) => {
+    const [top] = recall(store, query, now, 1, redactDomains).matches;
+    if (top === undefined)
+        return null;
+    const rows = store.errors.filter((error) => error.sig === top.sig);
+    const sessionIds = new Set(rows.map((error) => error.session));
+    const harnesses = [...new Set(store.sessions.filter((session) => sessionIds.has(session.session)).map((session) => listedHarness(harnessOf(session))))].sort();
+    const weeks = [...new Set(rows.flatMap((error) => { const week = error.ts === null ? undefined : isoWeek(error.ts); return week === undefined ? [] : [week]; }))].sort().reverse();
+    // Listed tool names folded together: two unlisted tools are both `other`, once.
+    const next = new Map();
+    for (const { tool, count } of top.followedBy)
+        next.set(listedTool(tool), (next.get(listedTool(tool)) ?? 0) + count);
+    const followed = [...next.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, NEXT_SHOWN).map(([tool, count]) => `${tool} x${String(count)}`);
+    // The key is `<tool> | <text>`; the tool is stated by its listed name. The text first loses the literals the store records for the matched sessions
+    // (branches, project slugs; the transcript rules have no rule for either), then runs through the transcript rules (home paths, encoded folder slugs,
+    // local names, secrets), and only the redacted result is cut. Every unlisted `mcp__` word becomes `other`, with backticks out so the fence holds.
+    const recorded = store.sessions.filter((entry) => sessionIds.has(entry.session));
+    const labels = new Map();
+    for (const entry of recorded) {
+        for (const branch of entry.branches)
+            labels.set(branch, '<branch>');
+        labels.set(entry.project, '<project>');
+    }
+    // A literal goes only where it stands as a whole token, so a branch named `main` leaves `domain` and `./main.js` alone.
+    const literals = [...labels.entries()].filter(([literal]) => literal.length > 0).sort((a, b) => b[0].length - a[0].length || a[0].localeCompare(b[0]));
+    const scrubbed = literals.reduce((text, [literal, label]) => text.replace(new RegExp(`(?<![A-Za-z0-9_-])${literal.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![A-Za-z0-9_-])`, 'g'), label), top.sig.slice(top.sig.indexOf(' | ') + 3));
+    const text = redactTranscript(scrubbed, redactDomains, names).text.slice(0, SIGNATURE_LIMIT).replace(MCP_WORD, (word) => listedTool(word)).replaceAll('`', "'");
+    return [
+        '```markdown',
+        '**Error receipt**',
+        '',
+        `- Tool: ${listedTool(top.tool)}`,
+        `- Harness: ${harnesses.join(', ') || OTHER}`,
+        `- Error: \`${text}\``,
+        `- Earlier sessions that hit it: ${String(top.sessions)} (${times(top.count)})`,
+        `- Weeks: ${weeks.join(', ') || 'unknown'}`,
+        `- What they did next: ${followed.join(', ') || 'nothing recorded'}; an edit followed ${times(top.editFollowed)}`,
+        '',
+        RECEIPT_FOOTER,
+        '```',
+    ].join('\n');
+};

package/dist/sessions/recovery-calls.d.ts

@@ -9,7 +9,7 @@ export type Followed = Pick<ToolObservation, 'side' | 'prompt'> & {
 };
 /** How many following calls a failed call lists. */
 export declare const RECOVERY_CALLS = 5;
-/** What followed one failed call: the actions of the next calls, and whether any of them wrote a file. */
+/** What followed one failed call: the actions of the next calls, and whether any of them wrote a file without failing. A write that came back as an error stays in `next` and does not set `editFollowed`. */
 export interface RecoveryCalls {
     next: CanonicalAction[];
     editFollowed: boolean;
@@ -17,5 +17,6 @@ export interface RecoveryCalls {
 /**
  * What followed the call at `at` of a transcript's calls in the order they ran: null for a call that did not fail. The calls that followed are the later ones of the same prompt and the same run (a
  * subagent's call is not what the main run did next), up to 5. The scan ends at the first later call of that run that belongs to another prompt.
+ * `failedEditsCount` is the rule of the wire formats before 6, where any later edit counted whether or not its own result was an error; the ingest checks a batch of those formats with it, so a client already released is not refused for a failed edit.
  */
-export declare const recoveryCallsOf: (calls: readonly Followed[], at: number) => RecoveryCalls | null;
+export declare const recoveryCallsOf: (calls: readonly Followed[], at: number, failedEditsCount?: boolean) => RecoveryCalls | null;

package/dist/sessions/recovery-calls.js

@@ -7,19 +7,25 @@ const actionOf = ({ steps }) => steps?.[0]?.action ?? 'other';
 /**
  * What followed the call at `at` of a transcript's calls in the order they ran: null for a call that did not fail. The calls that followed are the later ones of the same prompt and the same run (a
  * subagent's call is not what the main run did next), up to 5. The scan ends at the first later call of that run that belongs to another prompt.
+ * `failedEditsCount` is the rule of the wire formats before 6, where any later edit counted whether or not its own result was an error; the ingest checks a batch of those formats with it, so a client already released is not refused for a failed edit.
  */
-export const recoveryCallsOf = (calls, at) => {
+export const recoveryCallsOf = (calls, at, failedEditsCount = false) => {
     const failed = calls[at];
     if (failed === undefined || failed.status !== 'error')
         return null;
     const next = [];
+    let editFollowed = false;
     for (let index = at + 1; index < calls.length && next.length < RECOVERY_CALLS; index += 1) {
         const call = calls[index];
         if (call === undefined || call.side !== failed.side)
             continue;
         if (call.prompt !== failed.prompt)
             break;
-        next.push(actionOf(call));
+        const action = actionOf(call);
+        next.push(action);
+        // An edit whose own result is an error wrote nothing, so it is not an edit that followed. A call with no recorded result is not known to have failed, and still counts.
+        if (WRITES.has(action) && (failedEditsCount || call.status !== 'error'))
+            editFollowed = true;
     }
-    return { next, editFollowed: next.some((action) => WRITES.has(action)) };
+    return { next, editFollowed };
 };

package/dist/sessions/redact.d.ts

@@ -8,10 +8,19 @@ export declare const makeRedactor: (domains?: readonly string[]) => Redactor;
 export declare const placeholders: (text: string) => number;
 /** The names this machine's person goes by in a transcript: the account's and the home folder's. A name under three characters would mask ordinary words, so it is left to the path rules. */
 export declare const localNames: (home?: string, account?: () => string) => string[];
+/** What only a sample pack asks of the raw-copy rules (t1111). */
+export interface PackRules {
+    /** The accounts the operator's repositories live under (a GitHub user or organization): masked as `<owner>` where one stands as a path segment or after a `:` of a remote. */
+    handles?: readonly string[];
+    /** Rewrites a tool use id (`toolu_...`, `srvtoolu_...`) to the value the pack keys it to, so a call and its result still pair; without it the entropy rule masks each as `<secret>`. */
+    toolId?: (id: string) => string;
+    /** Keeps a public host the session itself fetched or searched (the URL or `allowed_domains` of a WebFetch or WebSearch input) in the clear in that call's result. */
+    fetchedHosts?: boolean;
+}
 /** A whole transcript body redacted for upload, and how many values were masked (placeholders added, a count and nothing else). `names` are the local usernames to mask wherever they stand as a whole word. */
-export declare const redactTranscript: (body: string, domains?: readonly string[], names?: readonly string[]) => {
+export declare const redactTranscript: (body: string, domains?: readonly string[], names?: readonly string[], injectedKey?: string, pack?: PackRules) => {
     text: string;
     masked: number;
 };
 /** The version of the rules above, stated to the pool with every raw part; a change to any rule of `redactTranscript` raises it. */
-export declare const REDACTION_VERSION = "1";
+export declare const REDACTION_VERSION = "4";