toolroll 0.9.36 → 0.9.38

package/dist/scout.js

@@ -20,7 +20,8 @@ import { auditOf } from "./provider.js";
 import { currentClaim, heartbeat } from "./claim.js";
 import { heartbeat as runnerHeartbeat } from "./runner.js";
 import { parseDecision } from "./decision.js";
-import { parseReport, REPORT_IMAGE_FILE, REPORT_LIMITS, SCOUT_OUTPUT_JSON_SCHEMA } from "./scout-report.js";
+import { scoutHandbackSchema } from "./contracts/scout-report.js";
+import { parseReport, REPORT_IMAGE_FILE, REPORT_LIMITS, REPORT_VERSION, SCOUT_OUTPUT_JSON_SCHEMA } from "./scout-report.js";
 import { TOKEN_ENVS as TELEGRAM_TOKEN_ENVS } from "./telegram.js";
 import { evidenceRoot, mailboxName, quarantineMailboxes, readMailbox, reportFileName, SCREENSHOT_BYTE_CAP, storeEvidence, validateScreenshotBytes, writeEvidenceFile, } from "./evidence.js";
 import { MARKER as LEASE_MARKER } from "./worktree.js";
@@ -29,7 +30,7 @@ import { proveTreeUntouched, snapshotIgnored } from "./tree-proof.js";
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
 import { CLAUDE_LIMITS } from "./scope.js";
 import { catalogTool, projectToolsOf, toolLaunchFor } from "./project-tools.js";
-import { researchToolsOf } from "./mcp-connect.js";
+import { grantOf, researchToolsOf } from "./mcp-connect.js";
 import { startScoutProxy } from "./scout-net.js";
 import * as browserCheck from "./scout-browser.js";
 import { invokeAgent } from "./invoke.js";
@@ -160,6 +161,7 @@ function scoutBrief(title, goal, outOfScope, mailbox, reportFile, answers, struc
                 `\`${reportFile}\`:`,
             ]),
         "{",
+        `  "version": ${REPORT_VERSION},`,
         '  "title": "one line",',
         '  "summary": "one paragraph the operator reads first",',
         '  "report": "the report as markdown: what you found, the evidence, the risks",',
@@ -183,7 +185,7 @@ function connectedResearch(store, taskRef, runId) {
         const repo = store.refById(taskRef)?.repo ?? null;
         if (repo === null)
             return NO_RESEARCH;
-        return researchToolsOf(projectToolsOf(store, repo), new Set(toolLaunchFor(store, runId).tools.map(one => one.spec.name)));
+        return researchToolsOf(projectToolsOf(store, repo), new Set(toolLaunchFor(store, runId).tools.map(one => one.spec.name)), tool => grantOf(repo, tool));
     }
     catch {
         return NO_RESEARCH;
@@ -325,6 +327,7 @@ async function scoutWith(store, request, outputDir) {
             allowedTools: proxy === null ? [] : [...(browser === null ? SCOUT_RESEARCH_TOOLS : SCOUT_ALLOWED_TOOLS), ...research.allowed],
             ...(browser === null ? {} : { extraMcpServers: browser }),
             readOnlyTools: research.reads,
+            ...(research.withheld === undefined ? {} : { researchWithheld: research.withheld }),
             skipPermissions: false,
             resumeSession: null,
             ...(structured ? { jsonSchema: SCOUT_OUTPUT_JSON_SCHEMA } : {}),
@@ -484,7 +487,7 @@ async function scoutWith(store, request, outputDir) {
             ok: false,
             kind: "malformed",
             reason: "malformed-report",
-            message: `the scout concluded, but the payload is not a report: ${parsed.problems.map(problem => problem.reason).join(", ")}`,
+            message: `the scout concluded, but the payload is not a report: ${parsed.problems.map(problem => problem.message).join("; ")}`,
             problems: parsed.problems,
         };
     }
@@ -544,7 +547,7 @@ async function scoutWith(store, request, outputDir) {
         // the deliverable, and a task whose deliverable does not exist is not
         // done.
         try {
-            const content = Buffer.from(JSON.stringify(report, null, 2), "utf8");
+            const content = Buffer.from(JSON.stringify({ version: REPORT_VERSION, ...report }, null, 2), "utf8");
             const key = writeEvidenceFile(root, request.runId, "report.json", content);
             return {
                 ok: true,
@@ -630,17 +633,18 @@ function structuredHandback(structuredOutput) {
         value = JSON.parse(structuredOutput);
     }
     catch {
-        return { kind: "invalid", problems: [{ reason: "structured-not-json", message: "the structured output is not JSON" }] };
+        return { kind: "invalid", problems: [{ reason: "structured-not-json", message: "payload: the structured output is not JSON" }] };
     }
     const body = typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-    const kind = body["kind"];
-    const inner = kind === "report" ? body["report"] : kind === "question" ? body["decision"] : undefined;
-    if (kind !== "report" && kind !== "question") {
-        return { kind: "invalid", problems: [{ reason: "structured-kind", message: 'the structured output must say kind "report" or "question"' }] };
+    const read = scoutHandbackSchema.shape.kind.safeParse(body["kind"]);
+    if (!read.success) {
+        return { kind: "invalid", problems: [{ reason: "structured-kind", message: `kind: must be ${scoutHandbackSchema.shape.kind.options.map(one => JSON.stringify(one)).join(" or ")}` }] };
     }
+    const kind = read.data;
+    const inner = kind === "report" ? body["report"] : body["decision"];
     if (inner === undefined || inner === null) {
         const field = kind === "report" ? "report" : "decision";
-        return { kind: "invalid", problems: [{ reason: `structured-missing-${field}`, message: `kind "${kind}" needs its ${field}` }] };
+        return { kind: "invalid", problems: [{ reason: `structured-missing-${field}`, message: `${field}: required for kind "${kind}"` }] };
     }
     return { kind, raw: JSON.stringify(inner) };
 }

package/dist/serve.js

@@ -55,6 +55,7 @@ import { addFlowTriggerTo, checkFlowTriggerNow, HOOK_PATH, pressFlowButton, rece
 import { addCardToFlow, advanceFlows, cancelFlowCard, crossProjectProblem, decideFlowCard, FLOW_HREF, flowDefinitionOf, moveCardInFlow } from "./flow-engine.js";
 import { chooseFlowCard } from "./flow-send.js";
 import { FlowContractError, FLOW_TEMPLATES, validateFlowDefinition, withZoneNames } from "./flows.js";
+import { stageReferenceProblems } from "./contracts/stage-output.js";
 import { TOOL_CATALOG, addToolTo, catalogTool, discoverTools, localAppOf, projectToolsOf, removeToolFrom, secretsSetFor, setToolSecret, splitCommandLine, testToolOf } from "./project-tools.js";
 import { changeLearning, learningView } from "./project-learning.js";
 import { applySavedKnowledge, changeKnowledge, knowledgeView, knowledgeVersion, readKnowledgeSnapshot } from "./project-knowledge.js";
@@ -723,7 +724,7 @@ export function createDecisionServer(options) {
             tools: tools.map(tool => ({ tool, secretsSet: secretsSetFor(repo, tool.spec, toolHome) })),
             // A service that connects by signing in (or an app's own Connect) is offered only that way.
             catalog: TOOL_CATALOG.filter(one => !names.has(one.name) && oneClickOf(one.name) === null && localConnectOf(one.name) === null),
-            connections: connectionsOf(store, repo), kit, wanted,
+            connections: connectionsOf(store, repo, toolHome), kit, wanted,
             found: discoverTools(repo, codex, toolHome).filter(one => !names.has(one.spec.name)),
         };
     };
@@ -4539,14 +4540,25 @@ export function createDecisionServer(options) {
             clearTimeout(previous.expiry);
         const live = { steps: [], done: false, ok: false, listeners: previous?.listeners ?? new Set() };
         liveTurns.set(thread, live);
-        const current = () => live.steps.at(-1) ?? (live.steps.push({ tools: [], text: "" }), live.steps.at(-1));
+        const current = () => live.steps.at(-1) ?? (live.steps.push({ tools: [], toolCalls: [], text: "" }), live.steps.at(-1));
         return event => {
             if (live.done)
                 return;
             if (event.kind === "step")
-                live.steps.push({ tools: [], text: "" });
-            else if (event.kind === "tool")
+                live.steps.push({ tools: [], toolCalls: [], text: "" });
+            else if (event.kind === "tool") {
                 current().tools.push(event.label);
+                current().toolCalls.push({ id: event.id, label: event.label, state: "running" });
+            }
+            else if (event.kind === "tool-result") {
+                for (const step of live.steps) {
+                    const index = step.toolCalls.findIndex(tool => tool.id === event.id);
+                    if (index !== -1) {
+                        step.toolCalls[index] = { ...step.toolCalls[index], ...event.outcome };
+                        break;
+                    }
+                }
+            }
             else if (event.kind === "text")
                 current().text = event.text;
             for (const listener of live.listeners)
@@ -7186,6 +7198,10 @@ export function createDecisionServer(options) {
                 try {
                     drawn = JSON.parse(body.get("definition") ?? "null");
                     saved = validateFlowDefinition(drawn);
+                    // A {{stage.…}} this save adds must be one its zone hands on; ones the saved flow had stay.
+                    const references = stageReferenceProblems(saved, flowDefinitionOf(flow));
+                    if (references.length > 0)
+                        throw new FlowContractError(references.map(one => one.line));
                 }
                 catch (error) {
                     return answer(400, { ok: false, said: error instanceof SyntaxError ? "That flow couldn't be read." : error instanceof FlowContractError ? withZoneNames(error.lines, drawn) : error instanceof Error ? error.message : "That flow isn't valid." });
@@ -7834,7 +7850,9 @@ export function createDecisionServer(options) {
             const origin = consoleOrigin(request.headers.host);
             if (origin === null)
                 return back("Connect tools from this computer (localhost) or from your https address.");
-            const started = await startConnect({ service: service.id, repo: target, by: who.name, origin, kit: also === null ? kit : null, template }, options.connectFetch ?? fetch);
+            // Reconnect read-only (from a connected service's Tools entry): the same sign-in, asking only to read.
+            const readOnly = also === null && body.get("access") === "read";
+            const started = await startConnect({ service: service.id, repo: target, by: who.name, origin, kit: also === null ? kit : null, template, readOnly }, options.connectFetch ?? fetch);
             if (!started.ok)
                 return back(started.said);
             for (const [key, visit] of connectVisits)

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/slack-chat.js

@@ -11,6 +11,9 @@ import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
 import { renderReply } from "./reply-shape.js";
 import {} from "./mate-doors.js";
 import { SlackState, slackHash, } from "./slack-state.js";
+import { ChatDeliveryError, partContent } from "./chat-delivery-state.js";
+import { readChatPart } from "./contracts/chat-content.js";
+import { readSlackBlockActions, readSlackButton, SLACK_LINK_ACTION } from "./contracts/slack-callback.js";
 import { object, slackId, slackTs, slackMember, SlackError, uploadSlackBytes, } from "./slack-api.js";
 import { resultImageFileName, safeResultImageCaption, verifyResultImage, } from "./chat-evidence.js";
 import {} from "./store.js";
@@ -70,25 +73,23 @@ export function receiveSlack(state, identity, type, raw, now) {
         id = slackHash(`${identity.installation}:event:${body.event_id}`);
     }
     else if (type === "interactive" && body.type === "block_actions") {
-        const actions = Array.isArray(body.actions) ? body.actions : [];
-        if (actions.length !== 1)
+        const interaction = readSlackBlockActions(body);
+        if (!interaction.ok || interaction.value.container.type !== "message")
             return false;
-        const action = object(actions[0]), container = object(body.container);
-        if (
-        // toolroll_* since the rename; standing_orders_* buttons on older messages still work.
-        !/^(?:toolroll|standing_orders)_(confirm|dismiss|yes|cancel|flow_approve|flow_edit|flow_send_back|flow_choose_[0-3]|flow_note_(?:yes|no)|question_choice|question_words)$/.test(String(action.action_id)) ||
-            typeof action.value !== "string" ||
-            !/^[a-f0-9]{32}$/.test(action.value) ||
-            !slackTs(action.action_ts) ||
-            container.type !== "message")
+        const { actions, container, user } = interaction.value;
+        // A link button opens its page itself: nothing to do, and nothing to say.
+        if (actions.length === 1 && SLACK_LINK_ACTION.test(actions[0].action_id ?? ""))
             return false;
-        member = object(body.user).id;
+        member = user.id;
         channel = container.channel_id;
         ts = container.message_ts;
-        thread = object(body.message).thread_ts ?? ts;
+        thread = interaction.value.message?.thread_ts ?? ts;
         kind = "action";
-        payload = { token: action.value };
-        id = slackHash(`${identity.installation}:action:${member}:${ts}:${action.value}:${action.action_ts}`);
+        // A button that isn't one Toolroll made is answered with why, once the tap is proved to be the paired person's below.
+        const button = readSlackButton(interaction.value);
+        payload = button.ok ? { token: button.value.value } : { problem: button.issues.map(issue => issue.line).join("; ") };
+        const tapped = actions[0];
+        id = slackHash(`${identity.installation}:action:${member}:${ts}:${tapped?.value ?? ""}:${tapped?.action_ts ?? ""}`);
     }
     else
         return false;
@@ -101,9 +102,10 @@ export function receiveSlack(state, identity, type, raw, now) {
     // A channel or private group is a room: accepted only while it follows a
     // conversation, or for the `/team` words that make it follow one.
     const isRoom = !slackId(channel, "D");
+    const words = "text" in payload ? payload.text ?? "" : "";
     // v89: a channel that feeds a flow takes anyone's message (as a card, with no say over anything); "flow 12" connects one.
-    const inbox = isRoom && kind === "message" ? channelInbox(state.store, "slack", identity.installation, String(channel), String(payload.text ?? "")) : { watched: false, command: false };
-    const roomish = isRoom && (state.room(identity.installation, String(channel)) !== null || (kind === "message" && roomCommand(String(payload.text ?? "")) !== null) || inbox.watched || inbox.command);
+    const inbox = isRoom && kind === "message" ? channelInbox(state.store, "slack", identity.installation, String(channel), words) : { watched: false, command: false };
+    const roomish = isRoom && (state.room(identity.installation, String(channel)) !== null || (kind === "message" && roomCommand(words) !== null) || inbox.watched || inbox.command);
     if (isRoom && !roomish)
         return false;
     const binding = state.bindingFor(identity.installation, member);
@@ -124,7 +126,7 @@ export function receiveSlack(state, identity, type, raw, now) {
         member,
         ts,
         thread,
-        payload: JSON.stringify(payload),
+        payload,
         created: now.toISOString(),
     });
 }
@@ -227,7 +229,7 @@ export async function deliverSlackPart(options) {
         const repos = await access(options, binding, session?.ceilingDigest);
         if (event.kind === "notice" && options.canNotify?.() === false)
             return false;
-        const content = JSON.parse(row.payload);
+        const content = partContent(row.payload);
         const destination = content.channel ?? binding.channel;
         let text = content.text, buttons = [];
         if (content.task &&
@@ -435,9 +437,13 @@ export async function deliverSlackPart(options) {
         return true;
     }
     catch (error) {
+        if (error instanceof ChatDeliveryError && error.permanent) {
+            state.prepare("UPDATE chat_part SET state='dropped',next_at=NULL,problem=? WHERE id=?").run(error.message, row.id);
+            return true;
+        }
         // No permission to upload files here: one plain line instead of the result's screenshots.
-        const content = JSON.parse(row.payload);
-        if (content.image && content.shot && error instanceof SlackError && ["missing_scope", "no_permission"].includes(error.code)) {
+        const saved = readChatPart(row.payload), content = saved.ok ? saved.value : null;
+        if (content !== null && content.image && content.shot && error instanceof SlackError && ["missing_scope", "no_permission"].includes(error.code)) {
             refuseResultShots(state, store, row, content, "Slack", nowOf(options));
             return true;
         }

package/dist/slack-state.js

@@ -1,5 +1,6 @@
 /** Slack compatibility names for the shared durable transport state. */
-import { ChatState, chatSchema, chatTables } from "./chat-delivery-state.js";
+import { ChatState } from "./chat-delivery-state.js";
+import { chatSchema, chatTables } from "./contracts/chat-tables.js";
 export { chatHash as slackHash } from "./chat-delivery-state.js";
 export const SLACK_SCHEMA = chatSchema("slack"), SLACK_TABLES = chatTables("slack");
 export class SlackState extends ChatState {

package/dist/store.d.ts

@@ -1,3 +1,5 @@
+import type { DecisionOption } from "./contracts/decision.js";
+import type { FlowCardChange, FlowCardFields } from "./contracts/flow-card.js";
 import { type Actor } from "./actor.js";
 import { type CriterionMatrixRow, type CriterionJudgementWord } from "./proof.js";
 import { type ExecutionProfile, type ChainEntry, type UnattendedPermissionMode, type AcceptanceCriterion } from "./scope.js";
@@ -764,24 +766,9 @@ export type FlowCardSource = {
         binding: number;
     };
 };
-export type FlowCardRow = {
-    id: number;
-    flow: number;
-    title: string;
-    description: string | null;
-    stage: string;
-    entry: number;
-    state: "active" | "done" | "cancelled";
-    task: string | null;
-    primaryTask: string | null;
-    note: string | null;
-    waiting: string | null;
-    outputs: Record<string, string>;
-    createdBy: string;
-    createdAt: string;
-    updatedAt: string;
+/** A flow card as read (src/contracts/flow-card.ts), and where it came from. */
+export type FlowCardRow = FlowCardFields & {
     source: FlowCardSource | null;
-    owner: string | null;
 };
 /** One line of a card's discussion: a comment (and whom it @mentioned), or who became its owner. */
 export type FlowCommentRow = {
@@ -1361,13 +1348,8 @@ export type PushPair = {
     lastError: string | null;
     acceptedAt: string | null;
 };
-/** One option of a decision. `reversible` is a field so a scheduler can refuse to auto-apply. */
-export type DecisionOption = {
-    id: string;
-    label: string;
-    consequence: string;
-    reversible: boolean;
-};
+/** One option of a decision (src/contracts/decision.ts). `reversible` is a field so a scheduler can refuse to auto-apply. */
+export type { DecisionOption };
 /** The judgement call an agent refused to guess at (§7). Identity = its run. */
 export type Decision = {
     id: number;
@@ -6389,13 +6371,9 @@ export declare class Store {
     }, now: Date): boolean;
     /** What a card's current zone is doing: its task, the card's main work, what it waits on, what zones reported. */
     /** Read and written in one transaction, so a pass changing one field never writes back another pass's older task or waiting. */
-    updateFlowCard(id: number, change: {
-        task?: string | null;
-        primaryTask?: string;
-        waiting?: string | null;
-        outputs?: Record<string, string>;
-        state?: "done" | "cancelled";
-    }, now: Date): void;
+    /** Outputs are written only when they change (src/contracts/stage-output.ts), never over a row a newer Toolroll wrote;
+     * a zone's attachment stays only while its output does. */
+    updateFlowCard(id: number, change: FlowCardChange, now: Date): void;
     flowEvents(card: number): {
         fromStage: string | null;
         toStage: string;
@@ -8216,4 +8194,3 @@ export type VerifiedAuthor = string & {
     readonly __verifiedAuthor: unique symbol;
 };
 export declare function verifiedAuthor(name: string): VerifiedAuthor;
-export {};

package/dist/store.js

@@ -1,5 +1,4 @@
-import { chatSchema, chatTables } from "./chat-delivery-state.js";
-import { SLACK_SCHEMA, SLACK_TABLES } from "./slack-state.js";
+import { chatSchema, chatTables } from "./contracts/chat-tables.js";
 import { assessmentFromSavedEvidence, verificationEvidence } from "./verification-evidence.js";
 import { LEARNING_SCHEMA, queueLearning } from "./project-learning.js";
 import { SKILLS_SCHEMA } from "./project-skills.js";
@@ -8,6 +7,7 @@ import { MEMORY_SCHEMA } from "./project-memory.js";
 import { MODELS_SCHEMA } from "./model-catalog.js";
 import { validateTaskText } from "./task-text.js";
 import { flowDefinitionForStore, flowDefinitionFromStore } from "./flows.js";
+import { cardOutputsForStore, cardOutputsFromStore } from "./contracts/stage-output.js";
 import { chatControlHref, chatResultHref } from "./chat-controls.js";
 import { actorLabel, currentActor, leadSecretMatches, mintLeadToken, parseLeadToken } from "./actor.js";
 import { scanForSecrets } from "./evidence.js";
@@ -687,18 +687,11 @@ function readFlowStepRunRow(row) {
         durationMs: number("duration_ms"), exitCode: number("exit_code"), result: optional("result"), log: optional("log"), decisionJson: optional("decision_json") };
 }
 function readFlowCardRow(row) {
-    let outputs = {};
-    try {
-        const parsed = JSON.parse(String(row["outputs_json"] ?? "{}"));
-        if (parsed !== null && typeof parsed === "object")
-            outputs = Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === "string"));
-    }
-    catch {
-        outputs = {};
-    }
+    // What finished zones handed on (src/contracts/stage-output.ts): a row saved before it carried a version reads as it always did.
+    const { outputs, attached } = cardOutputsFromStore(String(row["outputs_json"] ?? "{}"));
     const optional = (key) => row[key] === null || row[key] === undefined ? null : String(row[key]);
     return { id: Number(row["id"]), flow: Number(row["flow"]), title: String(row["title"]), description: optional("description"), stage: String(row["stage"]), entry: Number(row["entry"]),
-        state: String(row["state"]), task: optional("task"), primaryTask: optional("primary_task"), note: optional("note"), waiting: optional("waiting"), outputs,
+        state: String(row["state"]), task: optional("task"), primaryTask: optional("primary_task"), note: optional("note"), waiting: optional("waiting"), outputs, attached,
         createdBy: String(row["created_by"]), createdAt: String(row["created_at"]), updatedAt: String(row["updated_at"]), source: readFlowCardSource(row["source_json"]), owner: optional("owner") };
 }
 function readFlowCardSource(value) {
@@ -3950,7 +3943,7 @@ function initializeStore(db, file) {
             throw new Error(`${file}: shared action history has an unknown shape; refusing to recreate it`);
     }
     if (preflight !== null && Math.abs(preflight) >= 67) {
-        for (const table of SLACK_TABLES)
+        for (const table of chatTables("slack"))
             if (!tableExists(db, table))
                 throw new Error(`${file}: Slack history is missing; refusing to recreate receipts`);
     }
@@ -3971,7 +3964,7 @@ function initializeStore(db, file) {
     db.exec(MEMORY_SCHEMA);
     db.exec(MODELS_SCHEMA);
     db.exec(SKILLS_SCHEMA);
-    db.exec(SLACK_SCHEMA);
+    db.exec(chatSchema("slack"));
     db.exec(chatSchema("discord"));
     db.exec(chatSchema("teams"));
     db.exec(TEAM_SCHEMA);
@@ -19362,12 +19355,22 @@ export class Store {
     }
     /** What a card's current zone is doing: its task, the card's main work, what it waits on, what zones reported. */
     /** Read and written in one transaction, so a pass changing one field never writes back another pass's older task or waiting. */
+    /** Outputs are written only when they change (src/contracts/stage-output.ts), never over a row a newer Toolroll wrote;
+     * a zone's attachment stays only while its output does. */
     updateFlowCard(id, change, now) {
         this.transact(() => {
             const card = this.getFlowCard(id);
             if (card === null)
                 return;
-            this.db.prepare("UPDATE flow_card SET task = ?, primary_task = ?, waiting = ?, outputs_json = ?, state = ?, updated_at = ? WHERE id = ?").run(change.task === undefined ? card.task : change.task, change.primaryTask ?? card.primaryTask, change.waiting === undefined ? card.waiting : change.waiting, JSON.stringify(change.outputs ?? card.outputs), change.state ?? card.state, now.toISOString(), id);
+            this.db.prepare("UPDATE flow_card SET task = ?, primary_task = ?, waiting = ?, state = ?, updated_at = ? WHERE id = ?").run(change.task === undefined ? card.task : change.task, change.primaryTask ?? card.primaryTask, change.waiting === undefined ? card.waiting : change.waiting, change.state ?? card.state, now.toISOString(), id);
+            if (change.outputs === undefined && change.attached === undefined)
+                return;
+            const saved = this.db.prepare("SELECT outputs_json FROM flow_card WHERE id = ?").get(id);
+            if (cardOutputsFromStore(String(saved?.["outputs_json"] ?? "{}")).newer)
+                return;
+            const outputs = change.outputs ?? card.outputs;
+            const attached = { ...Object.fromEntries(Object.entries(card.attached).filter(([zone]) => outputs[zone] === card.outputs[zone])), ...change.attached };
+            this.db.prepare("UPDATE flow_card SET outputs_json = ? WHERE id = ?").run(cardOutputsForStore(outputs, attached), id);
         });
     }
     flowEvents(card) {

package/dist/structured-output.js

@@ -8,12 +8,13 @@
  * subject to the phase's strict parser.
  */
 import { redactSecretLines, scanForSecrets, storeEvidence } from "./evidence.js";
+import { TEXT_LIMITS } from "./text-limits.js";
 export const STRUCTURED_REPAIR_ATTEMPTS = 2;
 export const STRUCTURED_REPAIR_MAX_TURNS = 4;
 export const STRUCTURED_REPAIR_TIMEOUT_MS = 5 * 60_000;
 /** Native parsing counts UTF-16 code units. A shorter writing target keeps
  * notes concise without imposing a second, stricter transport contract. */
-export const REVIEW_OUTPUT_LIMITS = { comments: 40, criteria: 12, note: 500, path: 300 };
+export const REVIEW_OUTPUT_LIMITS = { comments: 40, criteria: 12, note: TEXT_LIMITS.reviewNote, path: TEXT_LIMITS.reviewPath };
 export const REVIEW_NOTE_CODE_POINTS = Math.floor(REVIEW_OUTPUT_LIMITS.note / 2);
 export const REVIEW_NOTE_GUIDANCE = `Keep each comment and criterion note to one concise finding and its evidence. Aim for ${REVIEW_NOTE_CODE_POINTS} characters or fewer; the hard limit is ${REVIEW_OUTPUT_LIMITS.note} UTF-16 units. Preserve the conclusion and any needed provenance; omit repeated rubric text.`;
 /** Strip only unambiguous, whole-payload wrappers. */

package/dist/subscription-chat.d.ts

@@ -9,6 +9,10 @@ export type SubscriptionMateRequest = {
     dataDocument: string;
     history: readonly MateHistoryMessage[];
     tools: readonly MateToolSchema[];
+    /** A structured answer of another shape (the memory pass's verdict): this JSON Schema is the harness's
+     * `--json-schema` (Codex's `--output-schema`) in place of the mate envelope, and its JSON text comes back as the
+     * answer's text, unread, for the caller's own schema to parse. */
+    outputSchema?: Record<string, unknown>;
     timeoutMs: number;
     /** The turn's own deadline: aborting it ends the harness's whole process group. */
     signal?: AbortSignal;

package/dist/subscription-chat.js

@@ -191,7 +191,7 @@ export async function performSubscriptionMateRequest(request, runner = run) {
     try {
         const prompt = composeSubscriptionMatePrompt(request);
         const streaming = request.provider !== "codex-subscription" && request.onText !== undefined;
-        const schema = outputSchema(request.tools);
+        const schema = request.outputSchema ?? outputSchema(request.tools);
         let command;
         let args;
         if (request.provider === "codex-subscription") {
@@ -271,6 +271,9 @@ export async function performSubscriptionMateRequest(request, runner = run) {
         const output = request.provider === "codex-subscription" ? codexOutput(result.stdout) : claudeOutput(streaming ? lastResultLine(result.stdout) : result.stdout);
         if (output.text === null)
             return { ok: false, problem: "malformed-reply" };
+        if (request.outputSchema !== undefined) {
+            return { ok: true, answer: { text: output.text, calls: [], tokensIn: output.tokensIn, tokensOut: output.tokensOut, reportedCostMicrousd: null } };
+        }
         return parseSubscriptionMateAnswer(output.text, output);
     }
     finally {

package/dist/task-review-brief.d.ts

@@ -1,15 +1,9 @@
 /** A read-only packet of saved result facts. Never opens a worktree or emits logs, patches or saved shell commands. */
 import type { Store } from './store.js';
 import { type AssignmentAccess } from './assignment.js';
-import { type FindingSeverity } from './review-switch.js';
+import { type BuildFinding as Finding, type FindingSeverity } from './contracts/review-findings.js';
 declare const MISSING: 'not recorded';
 type Missing = typeof MISSING;
-type Finding = {
-    severity: FindingSeverity;
-    file: string;
-    line: number;
-    scenario: string;
-};
 export type ReviewBrief = {
     header: {
         task: string;

package/dist/task-review-brief.js

@@ -2,13 +2,13 @@ import { assignmentChecksForRun, assignmentOf } from './assignment.js';
 import { assignmentPresentationOf } from './assignment-presentation.js';
 import { readVerifiedArtifact, readVerifiedProofForRun, reportShotsOf, scanForSecrets } from './evidence.js';
 import { SCREENSHOT_CAPTURE, structuredHandoffView, terminalDiffView } from './result-evidence-readers.js';
+import { FINDING_SEVERITIES } from './contracts/review-findings.js';
 import { buildReviewOf } from './review-switch.js';
 import { parseReport } from './scout-report.js';
 import { sanitizeTranscriptLine } from './live.js';
 import { redactSecretAssignments } from './builder.js';
 import { parseExecutionPlanDocument } from './plan.js';
 const MISSING = 'not recorded';
-const SEVERITIES = ['HIGH', 'MEDIUM', 'LOW'];
 /** Redact before shortening so a clipped credential cannot escape recognition. Apply to every data string in both formats. */
 function safeText(value, secrets, cap = 300) {
     if (typeof value !== 'string' || !value.trim())
@@ -65,11 +65,11 @@ export function taskReviewBrief(store, task, root, now, access, options = {}) {
             ...Object.entries(progress?.suites ?? {}).filter(([, suite]) => suite.state === 'failed').map(([name, suite]) => `${name}: ${suite.failed} failed`),
         ])] : [];
     const review = run === null ? null : buildReviewOf(store, run.id);
-    const findings = review === null ? [] : [...review.high, ...review.followUps].filter(one => one && SEVERITIES.includes(one.severity));
-    const counts = Object.fromEntries(SEVERITIES.map(severity => [severity, findings.filter(one => one.severity === severity).length]));
-    const shown = SEVERITIES.flatMap(severity => severity === 'LOW' && !options.all ? [] : findings.filter(one => one.severity === severity))
+    const findings = review === null ? [] : [...review.high, ...review.followUps].filter(one => one && FINDING_SEVERITIES.includes(one.severity));
+    const counts = Object.fromEntries(FINDING_SEVERITIES.map(severity => [severity, findings.filter(one => one.severity === severity).length]));
+    const shown = FINDING_SEVERITIES.flatMap(severity => severity === 'LOW' && !options.all ? [] : findings.filter(one => one.severity === severity))
         .slice(0, 12).map(one => ({ severity: one.severity, file: safe(one.file), line: Number.isSafeInteger(one.line) ? one.line : 0, scenario: safe(one.scenario) }));
-    const omitted = Object.fromEntries(SEVERITIES.map(severity => [severity, counts[severity] - shown.filter(one => one.severity === severity).length]));
+    const omitted = Object.fromEntries(FINDING_SEVERITIES.map(severity => [severity, counts[severity] - shown.filter(one => one.severity === severity).length]));
     const proof = run === null ? null : readVerifiedProofForRun(store, root, run.id);
     const shots = artifacts.filter(one => one.kind === 'screenshot');
     const reportShots = report?.ok && run !== null ? reportShotsOf(artifacts, root, run.id, report.report.images) : [];
@@ -152,7 +152,7 @@ export function renderReviewBrief(brief) {
     else {
         lines.push(`Automatic review: ${brief.review.state}${brief.review.reason === MISSING ? '' : ` · ${brief.review.reason}`}`);
         lines.push(...brief.review.findings.map(one => `  ${one.severity} ${one.file}:${one.line} — ${one.scenario}`));
-        for (const severity of SEVERITIES)
+        for (const severity of FINDING_SEVERITIES)
             if (brief.review.omitted[severity])
                 lines.push(`  ${severity}: ${brief.review.omitted[severity]} more (${brief.review.counts[severity]} total)`);
         if (Object.values(brief.review.counts).every(count => count === 0) && brief.review.state === 'reviewed')

package/dist/task-sizing.d.ts

@@ -1,5 +1,6 @@
+import { type SizeAnswer } from "./contracts/task-sizing.js";
 import { run, type ExecResult } from "./exec.js";
-import { type TaskSize, type TaskSizing } from "./phase-routing.js";
+import { type TaskSizing } from "./phase-routing.js";
 import type { Store } from "./store.js";
 /** The classifier's whole budget, from asking to answer. */
 export declare const SIZING_BUDGET_MS = 5000;
@@ -11,11 +12,7 @@ export type SizingInput = {
     outOfScope?: string | null | undefined;
     touches?: readonly string[] | undefined;
 };
-export type SizeAnswer = {
-    size: TaskSize;
-    risky: boolean;
-    reason: string;
-};
+export type { SizeAnswer } from "./contracts/task-sizing.js";
 /** One classifier: null (or a throw) is "no answer"; the signal ends at the budget. */
 export type Sizer = (input: SizingInput, signal: AbortSignal) => Promise<SizeAnswer | null>;
 /** Structural or broad work — the description signal planning has always read. */
@@ -27,26 +24,6 @@ export declare function planningSignals(input: SizingInput): boolean;
 export declare function heuristicSizing(input: SizingInput, why?: string | null): TaskSizing;
 /** What the classifier reads: the task as data, bounded, keys blanked. */
 export declare function sizingText(input: SizingInput): string;
-export declare const SIZING_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly size: {
-            readonly type: "string";
-            readonly enum: readonly ["small", "medium", "large"];
-        };
-        readonly risky: {
-            readonly type: "boolean";
-        };
-        readonly reason: {
-            readonly type: "string";
-            readonly maxLength: 160;
-        };
-    };
-    readonly required: readonly ["size", "risky", "reason"];
-    readonly additionalProperties: false;
-};
-/** Read an answer back: only the three sizes, a boolean, and a short reason. */
-export declare function readSizeAnswer(value: unknown): SizeAnswer | null;
 type CommandRunner = (file: string, args: readonly string[], options: Parameters<typeof run>[2]) => Promise<ExecResult>;
 /** A small Claude model on this computer's sign-in: no tools, no MCP servers, no repository, credential keys stripped.
  * The abort ends it: a late answer never keeps a command (or its process) waiting. */
@@ -75,4 +52,3 @@ export declare function filingSizerInstalled(): boolean;
 export declare function refineFiledSizing(store: Store, taskId: string, input: SizingInput, followPlanning: boolean, clock?: () => Date): Promise<void> | null;
 /** Wait for every classification still in flight (each is bounded by the budget). */
 export declare function settleSizings(): Promise<void>;
-export {};