@foldrun/core 2.4.0 → 2.6.0

package/dist/src/step-exec.js

@@ -7,18 +7,20 @@
 // assembles the system prompt and builds MCP servers, then hands this the
 // results. That is what lets the same function run somewhere the vault, the
 // library and the account do not exist.
+import { judgeVerdict, JUDGE_VERDICT_INSTRUCTION } from "./judge-verdict.js";
 import { runHook, runToolCallHooks, matchesTool, hookLine, resolveHooks } from "./hooks.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { CAPTURE_CAP } from "./store.js";
 import { costOf } from "./catalog.js";
 import { spawn } from "node:child_process";
 import { checkPaths, checkBash, isFilesystemTool, linkWorkspace, workspaceLinkEnv, resolveAgentPath, isWithin } from "./confine.js";
 import { DELEGATE_TOOLS, subagentGuard, toAgentDefinitions } from "./subagents.js";
 import { hostSafeEnv } from "./host-env.js";
 import { validateSchema, describeSchemaErrors, looksLikeSchema } from "./json-schema.js";
-import { CallCounter, limitKeysFor } from "./limits.js";
+import { CallCounter, callKeysFor } from "./limits.js";
 import { classifyCall, podAt, readPodEvents } from "./browser-pod.js";
 /** The four counts from one SDK usage object (snake_case, as the API
  *  reports it). The API counts fresh input apart from the cache's; here
@@ -50,6 +52,14 @@ export function verifyBudgetMs(timeoutSec, elapsedMs) {
 /** After an interrupt is asked for, how long the model loop gets to wind
  *  down on its own before the query is aborted outright. */
 export const INTERRUPT_GRACE_MS = 10_000;
+// The cap plus slack: the runner masks, then cuts to the cap (capture.ts), so
+// a secret on the edge is masked whole.
+const SEND_CAP = CAPTURE_CAP + 4096;
+function capped(text) {
+    if (text.length <= SEND_CAP)
+        return { text, chars: text.length, truncated: false };
+    return { text: text.slice(0, SEND_CAP), chars: text.length, truncated: true };
+}
 /** The tag on every event a failed check writes — `verify:`, `output: json`,
  *  a schema — headline and detail alike. The runner's no-retry rule for
  *  outward steps reads it (actedThenFailedCheck); reading the wording of the
@@ -228,6 +238,10 @@ async function executeStepInner(opts, runQuery) {
             ...(opts.effort ? { effort: opts.effort } : {}),
             systemPrompt: opts.systemPrompt,
             ...(opts.maxTurns ? { maxTurns: opts.maxTurns } : {}),
+            // The raw stream, only when model calls are recorded: an assistant
+            // message carries usage from the call's start (output a few tokens) and
+            // no stop reason; the call's message_delta has both (FOL-72).
+            ...(opts.capture ? { includePartialMessages: true } : {}),
             // Sub-agents: the SDK's own delegation. Every definition carries an
             // explicit tool list (an absent one inherits all of ours).
             ...(subagents ? { agents: toAgentDefinitions(subagents) } : {}),
@@ -313,7 +327,7 @@ async function executeStepInner(opts, runQuery) {
                                 // refused before it runs: the tool, and any paid API behind it,
                                 // never sees it.
                                 if (counter.active) {
-                                    const refusal = counter.take(limitKeysFor(hookInput.tool_name, hookInput.tool_input, opts.toolOwners));
+                                    const refusal = counter.take(callKeysFor(hookInput.tool_name, hookInput.tool_input, opts.toolOwners));
                                     if (refusal) {
                                         emit("info", `${refusal.message} (${hookInput.tool_name} refused)`, via ? { subagent: via } : undefined);
                                         return { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: refusal.message } };
@@ -330,7 +344,7 @@ async function executeStepInner(opts, runQuery) {
                                     for (const r of v.records)
                                         record(r, via);
                                     const refundCall = () => { if (counter.active)
-                                        counter.refund(limitKeysFor(hookInput.tool_name, hookInput.tool_input, opts.toolOwners)); };
+                                        counter.refund(callKeysFor(hookInput.tool_name, hookInput.tool_input, opts.toolOwners)); };
                                     if (v.decision === "deny") {
                                         refundCall();
                                         return { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: v.reason } };
@@ -407,7 +421,7 @@ async function executeStepInner(opts, runQuery) {
                 const fromGrantedServer = opts.mcpNames.some((n) => toolName.startsWith(`mcp__${n}__`));
                 // A call the hook counted and this refuses never ran: give it back.
                 const refund = () => { if (counter.active)
-                    counter.refund(limitKeysFor(toolName, input, opts.toolOwners)); };
+                    counter.refund(callKeysFor(toolName, input, opts.toolOwners)); };
                 if (!opts.allowed.includes(toolName) && !fromGrantedServer) {
                     refund();
                     return {
@@ -480,6 +494,29 @@ async function executeStepInner(opts, runQuery) {
     // ceiling and on the bill.
     const turns = new Map();
     let anonymousTurns = 0;
+    // Each model call as a span (FOL-54 step 4), keyed like `turns`: a turn's
+    // blocks arrive as several messages under one id, so it is updated in place
+    // and sent again; the runner keeps the latest by id.
+    const spans = new Map();
+    // From the raw stream: which call each agent is in (message_start), and each
+    // call's final output tokens and stop reason (message_delta).
+    const streaming = new Map();
+    let saidResponding = false;
+    const finals = new Map();
+    const withFinal = (span) => {
+        const f = finals.get(span.id);
+        return {
+            ...span,
+            ...(f?.output !== undefined ? { tokens: { ...span.tokens, output: f.output } } : {}),
+            // Without the stream (an older CLI), a call that used tools stopped to use them.
+            ...(f?.stop ? { stop: f.stop } : !span.stop && span.tools > 0 ? { stop: "tool_use" } : {}),
+        };
+    };
+    // When each agent's next request went out — the step's own, and each
+    // sub-agent's apart, so one's tool results do not restart another's clock.
+    const lastInputAt = new Map();
+    const sentAt = (via) => lastInputAt.get(via ?? "") ?? loopStartedAt;
+    let loopStartedAt = Date.now();
     const specByName = new Map((subagents ?? []).map((s) => [s.name, s]));
     const priceOf = (message) => {
         const parent = message.parent_tool_use_id;
@@ -560,13 +597,65 @@ async function executeStepInner(opts, runQuery) {
     };
     try {
         for await (const message of q) {
+            // The session is up: the first model call is timed from here, not from
+            // before the SDK and its MCP servers started.
+            if (message.type === "system" && message.subtype === "init")
+                loopStartedAt = Date.now();
+            if (message.type === "stream_event") {
+                const ev = message.event;
+                const agentKey = message.parent_tool_use_id ?? "";
+                if (ev?.type === "message_start" && ev.message?.id) {
+                    streaming.set(agentKey, ev.message.id);
+                    // The step's own first response has begun: its prompt is in the
+                    // cache now, so siblings held back to read it may start.
+                    if (!agentKey && !saidResponding) {
+                        saidResponding = true;
+                        emit("info", "", { responding: true });
+                    }
+                }
+                if (ev?.type === "message_delta") {
+                    const id = streaming.get(agentKey);
+                    if (id) {
+                        finals.set(id, {
+                            ...(typeof ev.usage?.output_tokens === "number" ? { output: ev.usage.output_tokens } : {}),
+                            ...(ev.delta?.stop_reason ? { stop: ev.delta.stop_reason } : {}),
+                        });
+                        const span = spans.get(id);
+                        if (span) {
+                            const final = withFinal(span);
+                            spans.set(id, final);
+                            emit("info", "", { turn: final });
+                        }
+                    }
+                }
+                continue;
+            }
             if (ended)
                 break;
             if (message.type === "assistant") {
                 const m = message.message;
                 const u = m.usage;
+                const turnKey = m.id ?? `turn-${anonymousTurns++}`;
                 if (u)
-                    turns.set(m.id ?? `turn-${anonymousTurns++}`, { u, price: priceOf(message) });
+                    turns.set(turnKey, { u, price: priceOf(message) });
+                if (opts.capture && u) {
+                    const t = usageFromSdk(u);
+                    const prior = spans.get(turnKey);
+                    const span = {
+                        id: turnKey,
+                        n: prior?.n ?? spans.size + 1,
+                        at: prior?.at ?? new Date().toISOString(),
+                        ms: prior?.ms ?? Date.now() - sentAt(subagentOf(message)),
+                        ...(m.model ? { model: m.model } : prior?.model ? { model: prior.model } : {}),
+                        ...(m.stop_reason ? { stop: m.stop_reason } : prior?.stop ? { stop: prior.stop } : {}),
+                        tokens: { input: t.inputTokens, output: t.outputTokens, cacheRead: t.cacheReadTokens, cacheWrite: t.cacheWriteTokens },
+                        tools: (prior?.tools ?? 0) + (m.content ?? []).filter((b) => b?.type === "tool_use").length,
+                        ...(subagentOf(message) ? { subagent: subagentOf(message) } : {}),
+                    };
+                    const final = withFinal(span);
+                    spans.set(turnKey, final);
+                    emit("info", "", { turn: final });
+                }
                 if (ceiling && u) {
                     spentUsd = turnsTotal();
                     if (spentUsd >= ceiling) {
@@ -590,6 +679,8 @@ async function executeStepInner(opts, runQuery) {
                             const input = block.input;
                             const to = String(input?.subagent_type ?? "subagent");
                             delegations.set(block.id, to);
+                            // That sub-agent's first model call is timed from its job going out.
+                            lastInputAt.set(to, Date.now());
                             // One line a person can read: who got the job, and what it was.
                             const job = String(input?.description ?? input?.prompt ?? "").replace(/\s+/g, " ").trim().slice(0, 160);
                             emit("info", `delegating to ${to}${job ? `: ${job}` : ""}`, { subagent: to });
@@ -597,7 +688,13 @@ async function executeStepInner(opts, runQuery) {
                         openCalls.set(block.id, { name: block.name, at: Date.now(), ...(via ? { subagent: via } : {}) });
                         if (pod)
                             ledger.set(block.id, classifyCall(block.name, block.input, pod));
-                        emit("tool", block.name, { call: block.id, ...(via ? { subagent: via } : {}) });
+                        const input = opts.capture === "full" ? capped(JSON.stringify(block.input ?? {})) : null;
+                        emit("tool", block.name, {
+                            call: block.id,
+                            ...(opts.capture ? { inCall: turnKey } : {}),
+                            ...(via ? { subagent: via } : {}),
+                            ...(input ? { io: { input: input.text, inputChars: input.chars, ...(input.truncated ? { truncated: true } : {}) } } : {}),
+                        });
                     }
                 }
             }
@@ -613,6 +710,7 @@ async function executeStepInner(opts, runQuery) {
                         if (!open)
                             continue;
                         openCalls.delete(block.tool_use_id);
+                        const output = opts.capture === "full" ? capped(toolResultText(block.content)) : null;
                         emit("tool", open.name, {
                             call: block.tool_use_id,
                             ms: Date.now() - open.at,
@@ -621,6 +719,7 @@ async function executeStepInner(opts, runQuery) {
                             bytes: toolResultText(block.content).length,
                             ...(block.is_error ? { err: true } : {}),
                             ...(open.subagent ? { subagent: open.subagent } : {}),
+                            ...(output ? { io: { output: output.text, outputChars: output.chars, ...(output.truncated ? { truncated: true } : {}) } } : {}),
                         });
                         // Why it failed, on the trail. The span above carried only `err`,
                         // so a refused call left the agent's own guess as the only account
@@ -633,6 +732,8 @@ async function executeStepInner(opts, runQuery) {
                         }
                         readPod(block.tool_use_id);
                     }
+                    // That agent's next model call is timed from here: the results went back.
+                    lastInputAt.set(subagentOf(message) ?? "", Date.now());
                 }
             }
             else if (message.type === "result") {
@@ -801,6 +902,8 @@ async function executeStepInner(opts, runQuery) {
                 data,
                 modelEnv: opts.env,
                 signal: halt.signal,
+                ...(opts.judgeModel ? { judgeModel: opts.judgeModel } : {}),
+                ...(opts.judgeEffort ? { judgeEffort: opts.judgeEffort } : {}),
             });
         }
         finally {
@@ -945,17 +1048,17 @@ export async function checkVerify(agentDir, verify, ctx) {
             // GOOD` on a reply that did (fix-desk, run-muwevg72-7mza): the joined
             // text opened with the narration before it.
             const reply = ctx.conclusion?.trim() ? ctx.conclusion : output;
-            const verdict = await judgeReply(value, reply, output, ctx.modelEnv ?? {}, ctx.signal);
-            const ok = /^\s*PASS\b/i.test(verdict);
-            return { ok, headline: ok ? "PASS" : "FAIL", detail: verdict.slice(0, 300) };
+            const said = await judgeReply(value, reply, output, ctx.modelEnv ?? {}, ctx.signal, ctx.judgeModel, ctx.judgeEffort);
+            const { passed: ok, detail } = judgeVerdict(said);
+            return { ok, headline: ok ? "PASS" : "FAIL", detail };
         }
     }
     return { ok: false, headline: `unknown check "${kind}"`, detail: "" };
 }
 /**
  * A toolless, fast-tier grading call: does the reply satisfy the sentence?
- * Same shape as the eval judge, and answered with one word first so the
- * verdict is a prefix test rather than a reading.
+ * Same shape as the eval judge: reasoning first, then the verdict alone on
+ * the last line (judge-verdict.ts says why).
  */
 export function judgePrompt(rubric, reply, work) {
     const shown = reply.slice(0, 20_000);
@@ -963,12 +1066,11 @@ export function judgePrompt(rubric, reply, work) {
         ? `Everything the step wrote while working, for context. "The reply" means only the reply block below, ` +
             `never this:\n<work>\n${work.slice(-20_000)}\n</work>\n\n`
         : "";
-    return (`You are grading a reply against one requirement. Answer with PASS or FAIL as the ` +
-        `first word, then one sentence of reason.\n\nRequirement: ${rubric}\n\n` +
+    return (`You are grading a reply against one requirement. ${JUDGE_VERDICT_INSTRUCTION}\n\nRequirement: ${rubric}\n\n` +
         context +
         `<reply>\n${shown}\n</reply>`);
 }
-async function judgeReply(rubric, reply, work, env, signal) {
+async function judgeReply(rubric, reply, work, env, signal, model = "haiku", effort) {
     const texts = [];
     const abortController = new AbortController();
     if (signal?.aborted)
@@ -978,7 +1080,8 @@ async function judgeReply(rubric, reply, work, env, signal) {
         const q = query({
             prompt: judgePrompt(rubric, reply, work),
             options: {
-                model: "haiku",
+                model,
+                ...(effort ? { effort } : {}),
                 systemPrompt: "You grade text against a stated requirement. Be strict and literal.",
                 tools: [],
                 settingSources: [],

package/dist/src/store.d.ts

@@ -3,6 +3,7 @@ import type { BrowserPodOutcome } from "./browser-pod.ts";
 import { singleWorkspace } from "./paths.ts";
 import type { TestEffect } from "./test-mode.ts";
 import type { OperatorEvent } from "./operator.ts";
+import { frontmatterErrorText } from "./matter.ts";
 /**
  * The frontmatter of one markdown file, as the runtime reads it. Exported
  * for the CLI: `foldrun probe` used to import gray-matter itself, which is
@@ -282,6 +283,12 @@ export interface ApiSpec {
 export interface AgentInfo {
     name: string;
     description: string;
+    /** `owner:` — the person accountable for this agent: its own, else the
+     *  workspace AGENTS.md's, else the account's. Null when none of the three
+     *  names one. */
+    owner: string | null;
+    /** Which of the three `owner` came from. */
+    ownerFrom: OwnerSource | null;
     model: string;
     /** The other half of model selection. listAgents has always returned it;
      *  the interface did not say so, so every consumer had to re-read the file
@@ -352,6 +359,10 @@ export interface AgentInfo {
     /** Tools this agent declares inline rather than in `tools:` — `apis:`,
      *  `scripts:` and `mcpServers:` names — which a limit may also name. */
     inlineTools: string[];
+    /** agent.md's frontmatter does not parse (bad YAML): the agent is listed
+     *  with defaults and this says why, rather than the listing throwing —
+     *  one broken file once took down every account's worker (20 Oct 2026). */
+    frontmatterError?: string;
 }
 export declare const MODEL_TIERS: Record<string, string>;
 export type Tier = keyof typeof MODEL_TIERS;
@@ -512,6 +523,9 @@ export interface FlowInfo {
      *  overlap) — a default that changed underfoot would surprise every flow
      *  that legitimately runs in parallel. */
     overlap: "skip" | "queue" | null;
+    /** `issues: auto-close`: a run that goes fine closes this flow's open
+     *  issues (FOL-72 step 7). Unset is `stay-open`: a person resolves them. */
+    issues?: "auto-close" | "stay-open";
     /** Where this flow's runs stand in the queue against everyone else's:
      *  "high" is claimed before the round-robin, "low" after it. Adds to the
      *  account's own priority; the account's cap still bounds how many run
@@ -606,6 +620,12 @@ export interface FlowInfo {
      *  and the trace. Read here so a documented, scaffolded field means
      *  something rather than sitting in every file unread. */
     description: string | null;
+    /** `owner:` — the person accountable for this flow: its own, else the
+     *  workspace AGENTS.md's, else the account's. parseFlow sees only the
+     *  file, so it fills the flow's own; listFlows and readFlow add the rest. */
+    owner: string | null;
+    /** Which of the three `owner` came from. */
+    ownerFrom: OwnerSource | null;
     /** Flow-level frontmatter values the parser could not read — a bad
      *  `overlap:`/`priority:`/`catchup:`/`on:`/`signature:`, or a step line
      *  whose `[[target]]` is malformed. Errors, the way a bad step option is,
@@ -621,6 +641,7 @@ export interface AgentAssets {
 }
 export declare function agentAssets(tenant: string, workspace: string, agent: string): AgentAssets;
 export declare function listAgents(tenant: string, workspace: string): AgentInfo[];
+export { frontmatterErrorText };
 /** The option keys a step actually has. An indented `word: rest` that is
  *  NOT one of these is a line of the instruction — "Warning: do not
  *  publish" is prose that happens to contain a colon, and it used to be
@@ -748,6 +769,14 @@ export declare const reorderFlowSteps: (raw: string, groups: number[][]) => stri
 export declare const addFlowStep: (raw: string, step: Parameters<typeof addFlowStepLF>[1]) => string;
 export declare const removeFlowStep: (raw: string, index: number) => string;
 export declare function listFlows(tenant: string, workspace: string): FlowInfo[];
+export type OwnerSource = "agent" | "flow" | "workspace" | "account";
+/** `owner:` down the cascade: the file's own, the workspace AGENTS.md's, the
+ *  account's. A blank or non-string value is no value. `own` is labelled
+ *  "agent" or "flow" by the caller's kind; here it is whichever is given. */
+export declare function resolveOwner(own: unknown, workspace?: unknown, account?: unknown, ownKind?: "agent" | "flow"): {
+    owner: string | null;
+    ownerFrom: OwnerSource | null;
+};
 /** One flow of a workspace by name, or null. The same read listFlows makes,
  *  named so callers that want a single flow — the approval rules, the
  *  runner's budget stamp — do not each re-implement the directory walk. */
@@ -922,6 +951,62 @@ export interface RunEvent {
         reason?: string;
         ms: number;
     };
+    /** Set on a tool event whose content was recorded (FOL-54 step 4): the
+     *  call's input, on the call; its output, on the completion. The content is
+     *  under runs/<run>/calls/<call>.json, secrets masked — readCapturedCall.
+     *  Absent when the workspace says `capture: metadata`, and before 19 Oct
+     *  2026. */
+    captured?: boolean;
+    /** On a tool call: the id of the model call that asked for it (a
+     *  ModelCall's `id`), so the trace can nest it. Since 19 Oct 2026. */
+    inCall?: string;
+}
+/** One model call in a step (FOL-54 step 4): what the model was sent back
+ *  for and what came of it. A step's turns, one by one, where the step
+ *  record had only their sum. */
+export interface ModelCall {
+    /** The provider's message id. */
+    id: string;
+    /** 1, 2, 3 … in the order they came back. */
+    n: number;
+    /** When the response arrived. */
+    at: string;
+    /** From the request going out (the step's start, or the last tool result
+     *  coming back) to the response arriving. */
+    ms: number;
+    model?: string;
+    /** Why the model stopped: end_turn, tool_use, max_tokens, … */
+    stop?: string;
+    /** All input (fresh + cache), as the step's own `tokens` counts it. */
+    tokens: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    /** How many tools it called in this turn. */
+    tools: number;
+    /** Set when a sub-agent (`subagents:`) made the call. */
+    subagent?: string;
+    /** Which attempt of the step made it, from the second on. */
+    attempt?: number;
+}
+/** The most of one tool input or output a run records (FOL-54 step 4). */
+export declare const CAPTURE_CAP: number;
+/** What a recorded tool call took and gave, secrets masked, each part capped. */
+export interface CapturedCall {
+    id: string;
+    tool: string;
+    input?: string;
+    output?: string;
+    /** The whole input's / output's length in characters, before masking and
+     *  the cap; `truncated` says whether the text was cut. */
+    inputChars?: number;
+    outputChars?: number;
+    /** Either part cut; and which. */
+    truncated?: boolean;
+    inputCut?: boolean;
+    outputCut?: boolean;
 }
 /** A question an agent asked a person while its step ran (tools: [ask]). */
 export interface StepQuestion {
@@ -935,12 +1020,18 @@ export interface StepQuestion {
     /** true when the wait ran out with no answer. */
     unanswered?: boolean;
 }
-/** A message a person sent into a running step, and when the agent got it. */
+/** A message a person sent into a running step, and when the agent got it —
+ *  or, with `from`, one a colleague in the same parallel group sent it
+ *  (tools: [peers]); with `to`, one this step sent its colleagues. */
 export interface StepMessage {
     text: string;
     by?: string | null;
     at: string;
     deliveredAt: string;
+    /** The sibling agent that sent it (`by` is `peer:<agent>` then). */
+    from?: string;
+    /** The sibling agents this step sent it to. */
+    to?: string[];
 }
 /** One attempt of a step — see StepRecord.tries. */
 export interface StepAttempt {
@@ -975,8 +1066,16 @@ export interface StepAttempt {
  *  attempt reported the figure — an in-process step rents no sandbox, and
  *  billing reads null as zero, not as "unknown, charge something". */
 export declare function sumAttempts(tries: StepAttempt[]): Pick<StepAttempt, "costUsd" | "tokens" | "computeSecs" | "turns">;
-export { type TokenUsage, tokensOf, sumTokens, cacheHitRate, measuredHitRate, runTokens } from "./tokens.ts";
-import { type TokenUsage } from "./tokens.ts";
+export { type TokenUsage, type PromptLayerRecord, tokensOf, sumTokens, cacheHitRate, measuredHitRate, runTokens, promptLayersChanged, promptCacheNote } from "./tokens.ts";
+import { type TokenUsage, type PromptLayerRecord } from "./tokens.ts";
+/** The marker rescueStep puts in a rescue's instruction; how a rescue record
+ *  written before `rescueOf` existed is still recognised. */
+export declare const RESCUE_MARKER = "<rescue>\nYou are taking this step over:";
+/** Is this record an on-fail rescue rather than a step of the flow? */
+export declare function isRescueRecord(step: {
+    rescueOf?: string;
+    instruction?: string | null;
+}): boolean;
 export interface StepRecord {
     agent: string;
     instruction: string;
@@ -1060,6 +1159,9 @@ export interface StepRecord {
      *  records from before this existed; readers fall back to the events. */
     startedAt?: string;
     finishedAt?: string;
+    /** Every model call the step made, in order (FOL-54 step 4). Absent before
+     *  19 Oct 2026. */
+    calls?: ModelCall[];
     /** Why a step was skipped, shown in the trace. */
     skipReason?: string;
     /** Evaluator loop, carried from the flow — see FlowStep. `loopRemaining`
@@ -1133,6 +1235,13 @@ export interface StepRecord {
      *  actually executed in. Carried steps provide context and are never
      *  billed again — the original run's ledger line already paid for them. */
     carriedFrom?: string;
+    /** Set on an on-fail rescue record (runner.ts rescueStep): the agent of the
+     *  failed step it took over. A rescue is not a step of the flow: a resumed
+     *  drive must not launch it as one of its group, and a re-run must not
+     *  copy it as work (21 Oct 2026: one rerun carried 77 fixers as pending
+     *  steps). Records written before this field are recognised by their
+     *  instruction's `<rescue>` block instead — see isRescueRecord. */
+    rescueOf?: string;
     /**
      * Sandbox seconds this step rented, and how many of them were cold start.
      * Set only on the isolated path — an in-process step rents nothing, so
@@ -1170,6 +1279,11 @@ export interface StepRecord {
      *  what says where a step's input tokens went. Absent before 18 Oct 2026. */
     turns?: number | null;
     systemPromptChars?: number;
+    /** The system prompt's layers — name, length and hash of each, stable
+     *  ones first, the ones that change between runs marked. Two steps of
+     *  one agent compared layer by layer say why the model's cache missed
+     *  (prompt-layers.ts). Absent before 20 Oct 2026. */
+    promptLayers?: PromptLayerRecord[];
     /** Why the model's last turn ended (end_turn, max_tokens, tool_use…), as
      *  the SDK's closing result says. */
     stopReason?: string | null;
@@ -1237,6 +1351,21 @@ export interface RunRecord {
      *  the agents decided was worth remembering, listed so a person can review
      *  the lesson without diffing the folder. */
     memoryWrites?: string[];
+    /** The workspace's deployed commit when the run was created — which
+     *  version of the files it ran (FOL-54 step 4). Absent for a workspace
+     *  never deployed, and before 19 Oct 2026. */
+    revision?: string | null;
+    /** When a worker first picked the run up: startedAt is when it was
+     *  created, so the gap is its time in the queue. */
+    drivenAt?: string | null;
+    /** A re-run's source (FOL-72 step 6): which run, the 1-based step it
+     *  started from, and the instruction it was given there when a person
+     *  edited it for this re-run alone. */
+    rerunOf?: {
+        run: string;
+        step: number;
+        instruction?: string;
+    };
     /** Who asked for this run, when a person did: their email address. A
      *  schedule, a webhook and a chained flow have no one, and leave it unset.
      *  Kept so a gate can refuse the one approval nobody should be able to
@@ -1259,6 +1388,11 @@ export interface RunRecord {
     approvalLinksUsed?: string[];
     steps: StepRecord[];
 }
+/** Merge one part (the input, on the call; the output, on its completion)
+ *  into the call's file. */
+export declare function writeCapturedCall(workspaceRoot: string, runId: string, part: CapturedCall): void;
+/** One recorded call of a run, or null (not recorded, or not a call). */
+export declare function readCapturedCall(tenant: string, workspace: string, runId: string, callId: string): CapturedCall | null;
 export declare function runFilePath(tenant: string, workspace: string, runId: string): string;
 /**
  * Erase a run from history: its record and the outputs archived under its
@@ -1346,6 +1480,11 @@ export interface RunSummaryStep {
     instruction?: string;
     /** When a parked step last spoke — the moment the banner sorts by. */
     waitingSince?: string;
+    /** For search (FOL-72 step 9): the tools it called, how many of its calls
+     *  errored, and its model. Absent on rows written before 19 Oct 2026. */
+    tools?: string[];
+    toolErrors?: number;
+    model?: string;
     startedAt?: string;
     finishedAt?: string;
 }
@@ -1363,6 +1502,8 @@ export interface RunSummary {
     tags?: string[];
     startedBy?: string | null;
     parkedAt?: string | null;
+    /** The revision it ran (RunRecord.revision), for issues' "since". */
+    revision?: string | null;
     /** A step is parked for a person — what the approvals banner counts. */
     awaitingApproval: boolean;
     steps: RunSummaryStep[];