toolroll 0.9.34 → 0.9.37

package/dist/serve.js

@@ -1,3 +1,4 @@
+import { SCREENSHOT_CAPTURE, structuredHandoffView, terminalDiffView } from "./result-evidence-readers.js";
 import { checkLeadIdentity, leadIdentityOf, leadNameOf, LEAD_NAME_MAX, LEAD_PERSONA_MAX } from "./lead-identity.js";
 import { aboutYouOf, checkAboutYou, saveAboutYou, ABOUT_YOU_LINE_MAX, ABOUT_YOU_MAX_LINES } from "./lead-about.js";
 import { withActor } from "./actor.js";
@@ -53,7 +54,8 @@ import { FORM_PATH, flowFormPage, receiveFlowForm, shareFlowButton, stopSharingF
 import { addFlowTriggerTo, checkFlowTriggerNow, HOOK_PATH, pressFlowButton, receiveFlowHook, removeFlowTrigger, renewFlowHook, removeLinearKey, saveHooksBase, saveLinearKey, saveLinearSigningSecret } from "./flow-triggers.js";
 import { addCardToFlow, advanceFlows, cancelFlowCard, crossProjectProblem, decideFlowCard, FLOW_HREF, flowDefinitionOf, moveCardInFlow } from "./flow-engine.js";
 import { chooseFlowCard } from "./flow-send.js";
-import { FLOW_TEMPLATES, validateFlowDefinition } from "./flows.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";
@@ -722,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)),
         };
     };
@@ -1136,6 +1138,8 @@ export function createDecisionServer(options) {
             response.end(`<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="refresh" content="0;url=${escape(to)}"><title>Toolroll</title>${HANDOFF_STYLE}<p>${escape(words)} <a href="${escape(to)}">Back to Toolroll</a></p>`);
         };
         const state = url.searchParams.get("state") ?? "";
+        // Every arrival is logged (never the code or state): a sign-in that never came back is then visible as an absence.
+        logEvent("info", "connect.callback", { error: url.searchParams.get("error"), known: connectVisits.has(state) });
         if (!startedHere(request, state))
             return done("/settings/tools", "problem", "That sign-in was started in another browser. Connect again from this one.");
         const visit = connectVisits.get(state);
@@ -7179,12 +7183,17 @@ export function createDecisionServer(options) {
                 return redirect(response, "/flows");
             }
             if (action === "save") {
-                let saved;
+                let saved, drawn;
                 try {
-                    saved = validateFlowDefinition(JSON.parse(body.get("definition") ?? "null"));
+                    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 Error ? error.message : "That flow isn't valid." });
+                    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." });
                 }
                 const name = (body.get("name") ?? flow.name).replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, 80) || flow.name;
                 // The owner (v86) is whom "the owner decides" zones ask: someone who can approve on this project.
@@ -7830,7 +7839,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)
@@ -22504,32 +22515,6 @@ function runsPage(chrome, rows, liveIds, nextCursor, verdicts = new Map(), accep
     const older = nextCursor === null ? "" : `<p><a href="/runs?before=${nextCursor}">older →</a></p>`;
     return screen("builds", [`<h1>Builds <a class="badge" href="/peek">Peek at the live ones \u2192</a></h1>`, buildsViews("builds"), `<p class="hint">one build = one attempt by an agent to complete a task, on its own branch</p>`, list, older].join("\n"), { chrome });
 }
-function structuredHandoffView(artifacts, root) {
-    const artifact = [...artifacts].reverse().find(one => one.kind === "handoff");
-    if (artifact === undefined)
-        return null;
-    const read = readVerifiedArtifact(root, artifact);
-    if (!read.ok)
-        return null;
-    try {
-        const parsed = JSON.parse(read.content.toString("utf8"));
-        if (parsed === null || typeof parsed !== "object" || typeof parsed["conclusion"] !== "string")
-            return null;
-        const conclusion = oneLineOf(parsed["conclusion"], 600);
-        if (conclusion === "" || hasForbiddenControls(conclusion))
-            return null;
-        const list = (name) => Array.isArray(parsed[name])
-            ? parsed[name]
-                .filter((one) => typeof one === "string" && one.trim() !== "" && !hasForbiddenControls(one))
-                .slice(0, 8)
-                .map(one => oneLineOf(one, 240))
-            : [];
-        return { conclusion, changes: list("changes"), verification: list("verification"), followUps: list("followUps") };
-    }
-    catch {
-        return null;
-    }
-}
 /** What a scout found, each with its link and picture, then any screenshot no item shows. Every link is the cited
  * http(s) address the report parser admitted; every picture is served from verified evidence. */
 function reportItemsHtml(items, shots, runId) {
@@ -22606,7 +22591,6 @@ function sharedResultFactsOf(run, proof, terminal, handoff, report, publication)
         publicationWords: receiptPublicationWords(publication),
     };
 }
-const SCREENSHOT_CAPTURE = /^agent-claimed screenshot at (.+) \(validated (?:png|jpeg)\)/;
 function proofBundleView(store, run, artifacts, root) {
     const verdictRow = store.proofVerdictFor(run.id);
     const acceptanceRow = store.proofAcceptance(run.id);
@@ -22722,74 +22706,6 @@ function completionReceiptView(store, run, artifacts, root, review = null) {
         facts: sharedResultFactsOf(run, proof, terminal, handoff, report, publication),
     };
 }
-const CAPTURE_EXIT = /\(exit ([0-9]{1,4})\)\s*$/;
-/**
- * Assemble the terminal-diff card's facts. Every branch names its state:
- * a failed capture (nonzero exit recorded in the capture string) reads as
- * the failure it is, unverifiable bytes read as their problem, and absence
- * returns null so old runs simply show nothing rather than a broken card.
- */
-function terminalDiffView(artifacts, root) {
-    const patchArtifact = artifacts.find(one => one.kind === "terminal-diff");
-    const statArtifact = artifacts.find(one => one.kind === "diff-stat");
-    if (patchArtifact === undefined && statArtifact === undefined)
-        return null;
-    const view = { patch: null, stat: null };
-    if (patchArtifact !== undefined) {
-        const exit = CAPTURE_EXIT.exec(patchArtifact.capture);
-        if (exit !== null && exit[1] !== "0") {
-            view.patch = { problem: `capture failed — ${patchArtifact.capture}` };
-        }
-        else {
-            const read = readVerifiedArtifact(root, patchArtifact);
-            view.patch = read.ok
-                ? { text: read.content.toString("utf8"), truncated: patchArtifact.truncated, artifactId: patchArtifact.id }
-                : { problem: `stored but unverifiable — ${read.problem}` };
-        }
-    }
-    if (statArtifact !== undefined) {
-        const exit = CAPTURE_EXIT.exec(statArtifact.capture);
-        if (exit !== null && exit[1] !== "0") {
-            view.stat = { problem: `capture failed — ${statArtifact.capture}` };
-        }
-        else {
-            const read = readVerifiedArtifact(root, statArtifact);
-            if (!read.ok) {
-                view.stat = { problem: `stored but unverifiable — ${read.problem}` };
-            }
-            else {
-                try {
-                    const parsed = JSON.parse(read.content.toString("utf8"));
-                    // Every field this page renders is type-proved (arc 6, finding 7):
-                    // "an object with a base key" was accepting any shape at all.
-                    const count = (value) => typeof value === "number" && Number.isFinite(value);
-                    const wellFormed = parsed !== null &&
-                        typeof parsed === "object" &&
-                        typeof parsed["base"] === "string" &&
-                        typeof parsed["head"] === "string" &&
-                        count(parsed["fileCount"]) &&
-                        count(parsed["additions"]) &&
-                        count(parsed["deletions"]) &&
-                        count(parsed["binaryCount"]) &&
-                        typeof parsed["filesTruncated"] === "boolean" &&
-                        Array.isArray(parsed["files"]) &&
-                        parsed["files"].every(one => one !== null &&
-                            typeof one === "object" &&
-                            typeof one["path"] === "string" &&
-                            (count(one["additions"]) || one["additions"] === null) &&
-                            (count(one["deletions"]) || one["deletions"] === null));
-                    view.stat = wellFormed
-                        ? parsed
-                        : { problem: "stat is not the shape this page knows" };
-                }
-                catch {
-                    view.stat = { problem: "stat did not parse as JSON" };
-                }
-            }
-        }
-    }
-    return view;
-}
 const REVIEW_DIFF_LINE_CAP = 4_000;
 /** Parse only the stable structure Git's unified patch format guarantees.
  * Unknown metadata remains visible, and a patch that cannot be structured

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/surface.js

@@ -278,7 +278,14 @@ export const COMMAND_GUIDE = [
     operator("task approve", "the yes — nothing builds without one; binds to the scope digest"),
     operator("task requeue", "exit a stall: incidents resolved, strikes cleared, queued again"),
     operator("task regate", "explicitly rerun the approved check on the last exact commit — no agent or automatic retry"),
-    operator("task review", "show a run's automatic review: HIGH findings, suggested follow-ups, or why it was not reviewed"),
+    { invocation: "task review", synopsis: "read a task's compact result packet with --brief, or a run's automatic findings without it", audience: "agent", agentMayInvoke: true, mutation: "none",
+        positionals: [{ name: "id", required: true, meaning: "task id with --brief; run id otherwise" }],
+        flags: [jsonFlag, dbFlag,
+            { name: "brief", takesValue: false, meaning: "saved conclusion, changed files, checks, findings, screenshots, plan and next actions; missing fields say not recorded" },
+            { name: "run", takesValue: true, meaning: "with --brief, select an exact finished attempt instead of the latest" },
+            { name: "all", takesValue: false, meaning: "include LOW findings within the compact packet's limit; extra findings are counted" },
+            { name: "token", takesValue: true, meaning: "the lead token (or TOOLROLL_LEAD_TOKEN)" }],
+        notableReasons: ["usage", "unauthenticated", "not-found"] },
     operator("task accept", "record an explicit acceptance with limitations; does not change checks or prove deployment"),
     operator("task repair", "inspect or approve an existing historical repair draft; use task revise for new feedback"),
     operator("task route", "which configured agents plan, build and repair this task; phase and risk changes require renewed approval"),

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

@@ -0,0 +1,69 @@
+/** 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 BuildFinding as Finding, type FindingSeverity } from './contracts/review-findings.js';
+declare const MISSING: 'not recorded';
+type Missing = typeof MISSING;
+export type ReviewBrief = {
+    header: {
+        task: string;
+        run: number | Missing;
+        provider: string;
+        model: string;
+        minutes: number | Missing;
+        outcome: string;
+        base: string;
+        head: string;
+        state: string;
+    };
+    conclusion: string;
+    changedFiles: {
+        files: {
+            path: string;
+            additions: number | Missing;
+            deletions: number | Missing;
+        }[];
+        total: number;
+        omitted: number;
+    } | Missing;
+    check: {
+        status: string;
+        exit: number | Missing;
+        failed: string[] | Missing;
+    };
+    review: {
+        state: string;
+        reason: string;
+        findings: Finding[];
+        counts: Record<FindingSeverity, number>;
+        omitted: Record<FindingSeverity, number>;
+    } | Missing;
+    screenshots: {
+        files: {
+            path: string;
+            bytes: number | Missing;
+        }[];
+        omitted: number;
+    } | Missing;
+    plan: {
+        titles: string[];
+        omitted: number;
+    } | Missing;
+    nextActions: string[];
+};
+/** Select only finished build/report attempts in the admitted family. An explicit run never crosses that boundary. */
+export declare function taskReviewBrief(store: Store, task: string, root: string, now: Date, access: AssignmentAccess, options?: {
+    run?: number;
+    all?: boolean;
+    secrets?: readonly string[];
+}): {
+    ok: true;
+    brief: ReviewBrief;
+} | {
+    ok: false;
+    reason: string;
+    message: string;
+};
+/** Text and JSON share this bounded projection; --all includes LOW details within the same line budget. */
+export declare function renderReviewBrief(brief: ReviewBrief): string[];
+export {};