toolroll 0.9.94 → 0.9.95

package/dist/contracts/lead-tools.d.ts

@@ -92,6 +92,22 @@ export declare const LEAD_TOOL_INPUTS: {
         secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
         about: z.ZodOptional<z.ZodString>;
         on: z.ZodOptional<z.ZodBoolean>;
+        finding: z.ZodOptional<z.ZodInt>;
+        summary: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodInt>;
+        pointer: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodInt>;
+        incident: z.ZodOptional<z.ZodInt>;
+        provider: z.ZodOptional<z.ZodString>;
+        runner: z.ZodOptional<z.ZodString>;
+        persona: z.ZodOptional<z.ZodString>;
+        proposal: z.ZodOptional<z.ZodInt>;
+        decision: z.ZodOptional<z.ZodEnum<{
+            accept: "accept";
+            reject: "reject";
+        }>>;
+        reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     readonly propose_task_action: z.ZodObject<{
         task: z.ZodString;
@@ -110,6 +126,63 @@ export declare const LEAD_TOOL_INPUTS: {
         repo: z.ZodOptional<z.ZodString>;
         run: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
+    readonly show_card: z.ZodObject<{
+        spec: z.ZodObject<{
+            root: z.ZodString;
+            elements: z.ZodObject<{}, z.core.$catchall<z.ZodObject<{
+                type: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+                props: z.ZodObject<{
+                    source: z.ZodOptional<z.ZodEnum<{
+                        builders: "builders";
+                        findings: "findings";
+                        flow_zones: "flow_zones";
+                        flows: "flows";
+                        handover: "handover";
+                        integrations: "integrations";
+                        mode: "mode";
+                        projects: "projects";
+                        providers: "providers";
+                        results: "results";
+                        spend: "spend";
+                        tasks: "tasks";
+                    }>>;
+                    chart: z.ZodOptional<z.ZodEnum<{
+                        area: "area";
+                        bar: "bar";
+                        line: "line";
+                        pie: "pie";
+                    }>>;
+                    columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    facts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    state: z.ZodOptional<z.ZodEnum<{
+                        cancelled: "cancelled";
+                        done: "done";
+                        failed: "failed";
+                        queued: "queued";
+                        running: "running";
+                    }>>;
+                    limit: z.ZodOptional<z.ZodInt>;
+                    flow: z.ZodOptional<z.ZodInt>;
+                    days: z.ZodOptional<z.ZodInt>;
+                    text: z.ZodOptional<z.ZodString>;
+                    control: z.ZodOptional<z.ZodEnum<{
+                        [x: string]: string;
+                    }>>;
+                    task: z.ZodOptional<z.ZodString>;
+                    run: z.ZodOptional<z.ZodInt>;
+                    proposal: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strict>;
+                children: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly get_findings: z.ZodObject<{
+        task: z.ZodOptional<z.ZodString>;
+        repo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
     readonly offer_approval: z.ZodObject<{
         task: z.ZodOptional<z.ZodString>;
         card: z.ZodOptional<z.ZodInt>;
@@ -174,7 +247,9 @@ export declare const LEAD_TOOL_INPUTS: {
             add_card: "add_card";
             add_trigger: "add_trigger";
             allow_browser: "allow_browser";
+            allow_unattended: "allow_unattended";
             approve: "approve";
+            archive: "archive";
             assign: "assign";
             cancel_card: "cancel_card";
             choose: "choose";
@@ -191,11 +266,16 @@ export declare const LEAD_TOOL_INPUTS: {
             send_back: "send_back";
             starter: "starter";
             turn_off_browser: "turn_off_browser";
+            turn_off_unattended: "turn_off_unattended";
             unfollow: "unfollow";
         }>;
         repo: z.ZodOptional<z.ZodString>;
         flow: z.ZodOptional<z.ZodInt>;
         card: z.ZodOptional<z.ZodInt>;
+        days: z.ZodOptional<z.ZodInt>;
+        budget: z.ZodOptional<z.ZodString>;
+        runs: z.ZodOptional<z.ZodString>;
+        include: z.ZodOptional<z.ZodArray<z.ZodInt>>;
         kit: z.ZodOptional<z.ZodEnum<{
             [x: string]: string;
         }>>;
@@ -850,6 +930,22 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
         about: z.ZodOptional<z.ZodString>;
         on: z.ZodOptional<z.ZodBoolean>;
+        finding: z.ZodOptional<z.ZodInt>;
+        summary: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodInt>;
+        pointer: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodInt>;
+        incident: z.ZodOptional<z.ZodInt>;
+        provider: z.ZodOptional<z.ZodString>;
+        runner: z.ZodOptional<z.ZodString>;
+        persona: z.ZodOptional<z.ZodString>;
+        proposal: z.ZodOptional<z.ZodInt>;
+        decision: z.ZodOptional<z.ZodEnum<{
+            accept: "accept";
+            reject: "reject";
+        }>>;
+        reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     readonly propose_task_action: z.ZodObject<{
         task: z.ZodString;
@@ -868,6 +964,63 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         repo: z.ZodOptional<z.ZodString>;
         run: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
+    readonly show_card: z.ZodObject<{
+        spec: z.ZodObject<{
+            root: z.ZodString;
+            elements: z.ZodObject<{}, z.core.$catchall<z.ZodObject<{
+                type: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+                props: z.ZodObject<{
+                    source: z.ZodOptional<z.ZodEnum<{
+                        builders: "builders";
+                        findings: "findings";
+                        flow_zones: "flow_zones";
+                        flows: "flows";
+                        handover: "handover";
+                        integrations: "integrations";
+                        mode: "mode";
+                        projects: "projects";
+                        providers: "providers";
+                        results: "results";
+                        spend: "spend";
+                        tasks: "tasks";
+                    }>>;
+                    chart: z.ZodOptional<z.ZodEnum<{
+                        area: "area";
+                        bar: "bar";
+                        line: "line";
+                        pie: "pie";
+                    }>>;
+                    columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    facts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    state: z.ZodOptional<z.ZodEnum<{
+                        cancelled: "cancelled";
+                        done: "done";
+                        failed: "failed";
+                        queued: "queued";
+                        running: "running";
+                    }>>;
+                    limit: z.ZodOptional<z.ZodInt>;
+                    flow: z.ZodOptional<z.ZodInt>;
+                    days: z.ZodOptional<z.ZodInt>;
+                    text: z.ZodOptional<z.ZodString>;
+                    control: z.ZodOptional<z.ZodEnum<{
+                        [x: string]: string;
+                    }>>;
+                    task: z.ZodOptional<z.ZodString>;
+                    run: z.ZodOptional<z.ZodInt>;
+                    proposal: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strict>;
+                children: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly get_findings: z.ZodObject<{
+        task: z.ZodOptional<z.ZodString>;
+        repo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
     readonly offer_approval: z.ZodObject<{
         task: z.ZodOptional<z.ZodString>;
         card: z.ZodOptional<z.ZodInt>;
@@ -932,7 +1085,9 @@ export declare const LEAD_TOOL_READ_INPUTS: {
             add_card: "add_card";
             add_trigger: "add_trigger";
             allow_browser: "allow_browser";
+            allow_unattended: "allow_unattended";
             approve: "approve";
+            archive: "archive";
             assign: "assign";
             cancel_card: "cancel_card";
             choose: "choose";
@@ -949,11 +1104,16 @@ export declare const LEAD_TOOL_READ_INPUTS: {
             send_back: "send_back";
             starter: "starter";
             turn_off_browser: "turn_off_browser";
+            turn_off_unattended: "turn_off_unattended";
             unfollow: "unfollow";
         }>;
         repo: z.ZodOptional<z.ZodString>;
         flow: z.ZodOptional<z.ZodInt>;
         card: z.ZodOptional<z.ZodInt>;
+        days: z.ZodOptional<z.ZodInt>;
+        budget: z.ZodOptional<z.ZodString>;
+        runs: z.ZodOptional<z.ZodString>;
+        include: z.ZodOptional<z.ZodArray<z.ZodInt>>;
         kit: z.ZodOptional<z.ZodEnum<{
             [x: string]: string;
         }>>;
@@ -1709,6 +1869,19 @@ export declare const LEAD_TOOL_OUTPUTS: {
         label: z.ZodString;
         action: z.ZodString;
     }, z.core.$loose>;
+    readonly show_card: z.ZodObject<{
+        card: z.ZodNumber;
+        title: z.ZodString;
+        shows: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    readonly get_findings: z.ZodObject<{
+        findings: z.ZodArray<z.ZodObject<{
+            finding: z.ZodNumber;
+            task: z.ZodString;
+            state: z.ZodString;
+        }, z.core.$loose>>;
+        rule: z.ZodString;
+    }, z.core.$loose>;
     readonly offer_approval: z.ZodObject<{
         offered: z.ZodBoolean;
     }, z.core.$loose>;

package/dist/contracts/lead-tools.js

@@ -11,7 +11,9 @@
 import { z } from "zod";
 import { CHAT_ACTIONS } from "../chat-actions.js";
 import { RESULT_IMAGES_PER_TURN_CAP } from "../chat-evidence.js";
+import { CARD_CATALOG, CARD_SOURCES, CARD_TASK_STATES } from "../card-catalog.js";
 import { CHAT_CONTROLS } from "../chat-controls.js";
+import { CARD_CHART_TYPES, CARD_LIMITS } from "./chat-card.js";
 import { CHAT_TASK_ACTIONS } from "../chat-task-actions.js";
 import { LIMITS } from "../decision.js";
 import { CHECK_RESULTS, RUN_OUTCOMES, TASK_STATES } from "../lead-commitments.js";
@@ -51,6 +53,13 @@ export const CODE_MAP_VIEWS = ["overview", "area", "file", "search"];
 export const LISTED_TASK_STATES = ["queued", "running", "done", "failed", "cancelled"];
 /** The shared actions the lead proposes with propose_action; flows and subagents have their own tools. */
 const ACTION_OPERATIONS = Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith("flow_") && !one.startsWith("subagent_"));
+/** A card's spec as the lead sees it: one flat props object. Each element's own props are read strictly by card-catalog.ts. */
+const cardProps = z.strictObject({
+    source: z.enum(CARD_SOURCES).optional(), chart: z.enum(CARD_CHART_TYPES).optional(), columns: z.array(z.string().max(40)).max(CARD_LIMITS.columns).optional(), facts: z.array(z.string().max(40)).max(CARD_LIMITS.facts).optional(),
+    repo: repoId.optional(), state: z.enum(CARD_TASK_STATES).optional(), limit: z.int().min(1).max(CARD_LIMITS.rows).optional(), flow: id.optional(), days: z.int().min(1).max(90).optional(),
+    text: z.string().max(CARD_LIMITS.text).optional(), control: enumOf(Object.keys(CHAT_CONTROLS)).optional(), task: taskRef.optional(), run: id.optional(), proposal: id.optional(),
+});
+const cardSpec = z.strictObject({ root: z.string().max(40), elements: z.object({}).catchall(z.strictObject({ type: enumOf(Object.keys(CARD_CATALOG.data.components)), props: cardProps, children: z.array(z.string().max(40)).max(16) })) });
 export const LEAD_TOOL_INPUTS = {
     get_brief: z.strictObject({ repo: repoId.optional() }),
     get_project_activity: z.strictObject({ repo: repoId, offset: offset.optional() }),
@@ -65,10 +74,14 @@ export const LEAD_TOOL_INPUTS = {
         title: text("actionTitle").optional(), id: z.string().optional(), run: id.optional(), note: note.optional(), catalog: text("actionName").optional(),
         name: text("actionName").optional(), command: text("actionCommand").optional(), args: z.array(text("actionCommand")).max(40).optional(),
         url: text("actionUrl").optional(), secrets: z.array(text("actionSecret")).max(12).optional(), about: text("actionAbout").optional(), on: z.boolean().optional(),
+        finding: id.optional(), summary: text("actionAbout").optional(), file: text("actionName").optional(), line: id.optional(), pointer: z.string().max(40).optional(),
+        revision: id.optional(), incident: id.optional(), provider: z.string().max(40).optional(), runner: text("actionName").optional(), persona: note.optional(), proposal: id.optional(), decision: z.enum(["accept", "reject"]).optional(), reason: text("actionAbout").optional(),
     }),
     propose_task_action: z.strictObject({ task: taskRef, operation: enumOf(Object.keys(CHAT_TASK_ACTIONS)), dependency: taskRef.optional(), run: id.optional() }),
     get_controls: z.strictObject({}),
     show_control: z.strictObject({ control: enumOf(Object.keys(CHAT_CONTROLS)), task: taskRef.optional(), repo: repoId.optional(), run: id.optional() }),
+    show_card: z.strictObject({ spec: cardSpec }),
+    get_findings: z.strictObject({ task: taskRef.optional(), repo: repoId.optional() }),
     offer_approval: z.strictObject({ task: taskRef.optional(), card: id.optional() }),
     get_result: z.strictObject({ task: taskRef, run: id.optional(), feedback_offset: offset.optional() }),
     get_diff: z.strictObject({ task: taskRef, run: id.optional(), file: text("diffPath").min(1).optional(), offset: offset.optional() }),
@@ -215,6 +228,8 @@ export const LEAD_TOOL_OUTPUTS = {
     propose_task_action: z.looseObject({ proposal: int, action: str, awaiting: str }),
     get_controls: z.looseObject({ confirmedInChat: z.array(str), existingControls: rows({ id: str, label: str, needsTask: z.boolean(), needsProject: z.boolean() }), rule: str }),
     show_control: z.looseObject({ card: int, label: str, action: str }),
+    show_card: z.looseObject({ card: int, title: str, shows: z.array(str) }),
+    get_findings: z.looseObject({ findings: z.array(z.looseObject({ finding: int, task: str, state: str })), rule: str }),
     offer_approval: z.looseObject({ offered: z.boolean() }),
     get_result: z.looseObject({
         task: str, root: str, currentExecution: str, run: int, title: str, feedback: list, feedbackTotal: int, nextFeedbackOffset: nullable(int),

package/dist/contracts/store-json.d.ts

@@ -170,6 +170,9 @@ declare const STORE_COLUMN_VALUES: {
             code_map_switch: "code_map_switch";
             decision_record: "decision_record";
             decision_retire: "decision_retire";
+            finding_resend: "finding_resend";
+            finding_send: "finding_send";
+            flow_archive: "flow_archive";
             flow_browser: "flow_browser";
             flow_browser_off: "flow_browser_off";
             flow_card_add: "flow_card_add";
@@ -189,13 +192,22 @@ declare const STORE_COLUMN_VALUES: {
             flow_trigger_pause: "flow_trigger_pause";
             flow_trigger_remove: "flow_trigger_remove";
             flow_trigger_resume: "flow_trigger_resume";
+            flow_unattended: "flow_unattended";
+            flow_unattended_off: "flow_unattended_off";
+            incident_resolve: "incident_resolve";
             kit_setup: "kit_setup";
             knowledge_instructions: "knowledge_instructions";
             knowledge_remove: "knowledge_remove";
             knowledge_restore: "knowledge_restore";
             knowledge_save: "knowledge_save";
             lead_about_you: "lead_about_you";
+            lead_identity: "lead_identity";
+            memory_decide: "memory_decide";
+            mode_revoke: "mode_revoke";
+            provider_resume: "provider_resume";
             result_accept: "result_accept";
+            revision_accept: "revision_accept";
+            revision_reject: "revision_reject";
             scope_approve: "scope_approve";
             skill_disable: "skill_disable";
             skill_enable: "skill_enable";
@@ -215,11 +227,15 @@ declare const STORE_COLUMN_VALUES: {
             suggestion_not_now: "suggestion_not_now";
             sweep_cancel_rest: "sweep_cancel_rest";
             sweep_file: "sweep_file";
+            task_archive: "task_archive";
             task_cancel: "task_cancel";
+            task_reopen: "task_reopen";
+            task_restore: "task_restore";
             task_resume: "task_resume";
             tool_add: "tool_add";
             tool_remove: "tool_remove";
             trial_stop: "trial_stop";
+            worker_note: "worker_note";
         }>;
         request: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
         repo: z.ZodString;

package/dist/discord-chat.js

@@ -1,6 +1,9 @@
 /** Discord messages and buttons transport the shared assistant's saved actions. */
 import { chatQuestionButtons } from "./subagent-question.js";
 import { chatAskButtons } from "./chat-ask.js";
+import { discordCardEmbed } from "./card-render.js";
+import { withoutCard } from "./chat-card-part.js";
+import { cardWithin } from "./chat-card.js";
 import { chatFlowButtons } from "./chat-flow.js";
 import { refuseResultShots, resultShotsPruned, shotWaitsUntil } from "./result-shots.js";
 import { admitChatEvent } from "./chat-admission.js";
@@ -197,6 +200,10 @@ export async function deliverDiscordPart(options) {
         if (content.task &&
             !repos.includes(store.lookupRef(content.task)?.repo ?? ""))
             throw new DiscordError("Connected projects changed");
+        if (content.rich && !cardWithin(content.rich, repos)) {
+            state.dropPart(row.id, "Connected projects changed");
+            return true;
+        }
         let text = content.text, buttons = [], file;
         if (content.image && content.shot && resultShotsPruned(options.evidenceRoot, content.image.run)) {
             state.dropPart(row.id, "Removed by retention");
@@ -354,6 +361,8 @@ export async function deliverDiscordPart(options) {
             file.bytes = fresh.bytes;
         }
         const args = discordCard(text, buttons, content.voice === true && !content.proposal && !content.image);
+        if (content.rich)
+            args.embeds = [discordCardEmbed(content.rich, discordPlain)];
         if (file)
             args.attachments = [
                 { id: 0, filename: file.name, description: text.slice(0, 1024) },
@@ -392,6 +401,11 @@ export async function deliverDiscordPart(options) {
         }
         // No permission to attach files here: one plain line instead of the result's screenshots.
         const saved = readChatPart(row.payload), content = saved.ok ? saved.value : null;
+        // Discord refused the card's embed: the part's own plain text goes instead, so the message is never lost.
+        if (content?.rich && error instanceof DiscordError && error.code === "Discord could not complete the request" && error.retryMs === 60_000) {
+            state.repaint(row.id, withoutCard(content));
+            return true;
+        }
         if (content !== null && content.image && content.shot && error instanceof DiscordError && error.code === DISCORD_REFUSED) {
             refuseResultShots(state, store, row, content, "Discord", options.clock?.() ?? new Date());
             return true;

package/dist/dispatch.d.ts

@@ -39,7 +39,7 @@ export type DispatchAction = "open-result" | "retry-task" | "place-task" | "writ
  | "resume-run";
 export type DispatchDiagnosisCode = "updating" | "complete" | "needs-verification" | "proof-refuted" | "review-pending" | "reviewing" | "review-failed"
 /** v50: every root review attempt ended without a review; nothing retries. */
- | "review-exhausted" | "cancelled" | "failed" | "running" | "vanished-run" | "retry-scheduled" | "waiting-decision" | "waiting-incident" | "held"
+ | "review-exhausted" | "cancelled" | "failed" | "running" | "vanished-run" | "retry-scheduled" | "waiting-decision" | "waiting-incident" | "held" | "storage-blocked"
 /** v52: an operator stopped one exact attempt; only resuming it lifts the pause. */
  | "stopped" | "waiting-dependency" | "terminal-dependency" | "needs-project" | "needs-scope" | "needs-agent-profile" | "needs-approval" | "missing-requirement" | "no-worker-registered" | "no-worker-online" | "worker-at-capacity" | "provider-quota"
 /** The provider's sign-in stopped working; its dispatch is paused. */

package/dist/dispatch.js

@@ -6,6 +6,7 @@
  * fleet observations on top for people and agents reading the queue. A
  * diagnosis can go stale; it can never grant a lease.
  */
+import { STORAGE_HOLD_PREFIX } from "./needs-you.js";
 import { authorityStandsSql } from "./approval-authority.js";
 import { isAlive } from "./runner.js";
 import { updateAdmissionPaused, UPDATE_PAUSED } from "./desktop-update-gate.js";
@@ -161,7 +162,7 @@ function reviewViewOf(sourceRun, retry) {
     };
 }
 function approvedProfile(scope) {
-    if (scope === null || scope.approvalKind === "chain")
+    if (scope === null)
         return null;
     return scope.approvedProfile ?? scope.profile ?? null;
 }
@@ -261,6 +262,11 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         return answer("updating", "waiting", "Waiting for app update", UPDATE_PAUSED);
     const local = taskReadinessBlocker(store, ref.id, now);
     if (local?.code === "hold") {
+        // The storage check couldn't finish (dispose.ts holdForStorage): its own words, and Try again.
+        if (local.ownerKind === "backoff" && local.message.startsWith(`held: ${STORAGE_HOLD_PREFIX}`)) {
+            const when = local.until === null ? "" : ` It tries again on its own ${retryWhenWords(local.until, now)}.`;
+            return answer("storage-blocked", "waiting", "Needs macOS permission", `${local.message.slice(`held: ${STORAGE_HOLD_PREFIX}`.length)}${when}`, { action: "unhold", nextAt: local.until });
+        }
         if (local.ownerKind === "backoff") {
             // Run 2085: an attempt that stopped before its handoff says so plainly.
             const last = store.runsFor(ref.id).find(one => one.role === "builder" && one.finishedAt !== null);

package/dist/dispose.d.ts

@@ -1,3 +1,4 @@
+import { STORAGE_HOLD_PREFIX } from "./needs-you.js";
 import { type FailureClass } from "./claim.js";
 import type { BuildResult } from "./builder.js";
 import type { Store } from "./store.js";
@@ -89,6 +90,20 @@ export type Disposition = {
  * results and failed checks go straight to the person, as before. */
 export declare function maybeRequestAutoReview(store: Store, repo: string, runId: number, committed: boolean, noChange: boolean, now: Date, root?: string): void;
 export declare function disposeBuildOutcome(context: DisposeContext, result: BuildResult): Disposition;
+/** How long a task waits after the storage check couldn't finish before it tries again on its own. */
+export declare const STORAGE_RETRY_MS: number;
+export { STORAGE_HOLD_PREFIX };
+/**
+ * The storage HOLD: the check couldn't finish, so no launch can be fenced
+ * now. The task waits STORAGE_RETRY_MS and tries again on its own (a person
+ * who allowed access in Privacy & Security needn't do more), and "Try again"
+ * (unhold) lifts it at once. One message per task an hour, with the words.
+ */
+export declare function holdForStorage(store: Store, args: {
+    taskRef: number;
+    taskId: string;
+    message: string;
+}, now: Date): void;
 /**
  * The stale-approval HOLD, shared by the post-build disposition above and
  * the tick's pre-admission refusal (v48 integrity): a pre-routing row
@@ -152,6 +167,10 @@ export type RepairTrigger = {
 } | {
     kind: "stopped";
     reason: RepairStopReason;
+}
+/** The check runs once more on the same commit, with no agent: the failure looked unrelated to the change. */
+ | {
+    kind: "rerun";
 } | {
     kind: "none";
 };

package/dist/dispose.js

@@ -1,4 +1,6 @@
 // Assignment tracking grants no repair authority or attempts.
+import { STORAGE_HOLD_PREFIX } from "./needs-you.js";
+import { blockAfterSignedOut } from "./fallback.js";
 import { authorizeCheckOnly } from "./check-only.js";
 import { proposeNewRoute } from "./route-change.js";
 import { originalTaskBase, focusedTestCommandSupported } from "./observations.js";
@@ -20,6 +22,7 @@ import { bodyHashOf, publicationBody } from "./publish.js";
 import { modeTermsFromJson } from "./modes.js";
 import { evidenceRoot, readVerifiedArtifact, writeEvidenceFile } from "./evidence.js";
 import { queueBuildReview } from "./build-review.js";
+import { followBuiltRun } from "./check-repair.js";
 import { homedir } from "node:os";
 import { nightlyTaskRef, releaseTaskRef } from "./store.js";
 import {} from "./proof.js";
@@ -202,6 +205,7 @@ function disposeBuildOutcomeLocked(context, result) {
             store.resetStrikes(taskRef);
             store.clearQuota(runner, provider, model ?? "");
             maybeRequestAutoReview(store, repo, runId, result.committed, result.noChange === true, clock(), context.evidenceRoot);
+            followBuiltRun(store, repo, context.evidenceRoot ?? evidenceRoot(homedir()), runId, worktreePath, clock());
             return { kind: "built", committed: result.committed, noChange: result.noChange === true };
         }
         store.transact(() => {
@@ -331,11 +335,26 @@ function disposeBuildOutcomeLocked(context, result) {
             sealed: sealed.ok,
         };
     }
+    if (result.reason === "protected-storage") {
+        // The storage check couldn't finish (protected-storage.ts): nothing spent,
+        // no strike. The words are kept on the run, the task holds and tries
+        // again on its own, and a person reads why and which program to allow.
+        if (leaseId !== undefined)
+            release(store, leaseId, clock());
+        if (result.message.trim() !== "")
+            store.recordOutcomeFacts(runId, { handoff: result.message });
+        store.finishRun(runId, { outcome: "refused", reason: "protected-storage", now: clock() });
+        holdForStorage(store, { taskRef, taskId, message: result.message }, clock());
+        return { kind: "skipped", reason: "protected-storage" };
+    }
     // no-claim, not-yours, not-leased, protected-branch, wrong-branch:
     // invariants the dispatcher was supposed to uphold.
     if (leaseId !== undefined)
         release(store, leaseId, clock());
     store.finishRun(runId, { outcome: "refused", reason: result.reason, now: clock() });
+    // A fallback agent not signed in to its plan: the task waits for a person's retry, never loops (fallback.ts).
+    if (result.reason === "auth-mode" && blockAfterSignedOut(store, runId, clock()))
+        return { kind: "skipped", reason: "fallback-signed-out" };
     if (result.reason === "stale-approval") {
         // A deterministic refusal (setup review): the approval no longer
         // matches the routing, and nothing about the next pass changes that.
@@ -351,6 +370,27 @@ function disposeBuildOutcomeLocked(context, result) {
     }
     return { kind: "invariant", reason: result.reason };
 }
+/** How long a task waits after the storage check couldn't finish before it tries again on its own. */
+export const STORAGE_RETRY_MS = 10 * 60_000;
+export { STORAGE_HOLD_PREFIX };
+/**
+ * The storage HOLD: the check couldn't finish, so no launch can be fenced
+ * now. The task waits STORAGE_RETRY_MS and tries again on its own (a person
+ * who allowed access in Privacy & Security needn't do more), and "Try again"
+ * (unhold) lifts it at once. One message per task an hour, with the words.
+ */
+export function holdForStorage(store, args, now) {
+    store.holdOwned({ taskRef: args.taskRef, ownerKind: "backoff", ownerId: `storage:${args.taskRef}`, reason: `${STORAGE_HOLD_PREFIX}${args.message}`, until: new Date(now.getTime() + STORAGE_RETRY_MS) }, now);
+    store.enqueueNotification({
+        source: { taskRef: args.taskRef },
+        dedupeKey: `protected-storage:${args.taskRef}:${now.toISOString().slice(0, 13)}`,
+        kind: "protected-storage",
+        pushClass: "attention",
+        link: `/t/${encodeURIComponent(args.taskId)}`,
+        subject: `${args.taskId}: waiting for macOS permission`,
+        body: `${args.message}\nIt tries again on its own in ${STORAGE_RETRY_MS / 60_000} minutes.`,
+    }, now);
+}
 /**
  * The stale-approval HOLD, shared by the post-build disposition above and
  * the tick's pre-admission refusal (v48 integrity): a pre-routing row
@@ -544,9 +584,9 @@ export function regateTask(store, taskId, now, approval) {
 export function maybeTriggerRepair(store, repo, evidenceRoot, sourceRunId, verdict, now, cause = "review", automatic = false) {
     if (verdict !== "short" && verdict !== "refuted")
         return { kind: "none" };
-    // Findings go to the lead. Explicit repair/revision actions remain available.
-    // Historical mode signatures remain intact; no automatic follow-up spends.
-    if (automatic)
+    // A review's findings go to the lead, and a person asks for their repair. A failed check is the one automatic road
+    // (check-repair.ts), and only under a mode a person signed for it, checked below.
+    if (automatic && cause !== "verification")
         return { kind: "none" };
     // One attempt per source run, ever (source_run UNIQUE) — checked first so
     // a re-fired trigger is a silent no-op, never a duplicate.
@@ -604,9 +644,9 @@ export function maybeTriggerRepair(store, repo, evidenceRoot, sourceRunId, verdi
     const terms = mode === null ? null : modeTermsFromJson(mode.termsJson);
     let verification;
     if (cause === "verification") {
-        // A signed repair mode is required for this automatic producer. The
-        // existing review/manual road continues to offer unapproved drafts.
-        if (terms?.repairAuto !== true || run.finishedAt === null || !run.headRevision ||
+        // A signed repair mode is required for this automatic producer. A person
+        // asking (check-repair.ts startCheckRepair) gets an unapproved draft instead.
+        if ((automatic && terms?.repairAuto !== true) || run.finishedAt === null || !run.headRevision ||
             (run.outcome !== "built" && run.outcome !== "no-change"))
             return { kind: "none" };
         const owner = store.refForId(run.taskRef);
@@ -639,7 +679,7 @@ export function maybeTriggerRepair(store, repo, evidenceRoot, sourceRunId, verdi
                         subject: unrelated.kind === "gate-timed-out" ? "The project check ran out of time; running it once more" : "A slow test outside this change failed the check; running it once more",
                         body: `${gateFailureSummary(unrelated)} The check runs again once on the same commit ${run.headRevision.slice(0, 7)}, with no agent. If it fails again, a person decides.`,
                         link: `/t/${encodeURIComponent(taskId)}` }, now);
-                    return { kind: "none" };
+                    return { kind: "rerun" };
                 }
             }
             store.enqueueNotification({ source: { run: sourceRunId }, dedupeKey: `repair-unrelated:${sourceRunId}`, kind: "repair-evidence", pushClass: "attention",

package/dist/eval-oracle.js

@@ -19,6 +19,7 @@
  * The build's code never runs in the oracle's own process, and nothing the build wrote (a result file, a verdict) is
  * ever read as one: the verdict travels from the oracle to the runner over the oracle's own pipe.
  */
+import { prepareProtectedStorage } from "./protected-storage.js";
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { closeSync, constants, lstatSync, mkdirSync, mkdtempSync, openSync, realpathSync, rmSync, writeSync } from "node:fs";
@@ -55,10 +56,12 @@ export function canonical(value) {
 export const fencedGradeRunner = async ({ cwd, stdin, timeoutMs, deny }) => {
     if (!macosFenceAvailable() && !linuxFenceAvailable())
         throw new Error("this machine can't fence the graded program");
+    // The storage check, awaited off this thread (protected-storage.ts); a refusal keeps its words.
+    const storage = await prepareProtectedStorage();
     const egress = await startEgressProxy({ hosts: [] });
     try {
         const network = { mode: "allowlist", proxyPort: egress.port, brokerPorts: [], loopback: "proxy-only", socketRoots: [cwd], token: egress.secret };
-        const launch = fenceFor("check", { databaseFile: null, worktree: cwd, boundary: null, binding: null, runFolders: runFolders(null), poolRoots: [], extra: [...deny],
+        const launch = fenceFor("check", { databaseFile: null, worktree: cwd, boundary: null, binding: null, runFolders: runFolders(null), poolRoots: [], storage, extra: [...deny],
             writes: { writes: { subpaths: [cwd], prefixes: [] }, readOnly: [] }, network });
         const result = await run(process.execPath, ["probe.mjs"], { cwd, stdin, timeoutMs, maxBuffer: ORACLE_OUTPUT_BYTES, processGroup: true, envAllowlist: ["PATH"],
             env: { ...proxyEnv(egress, "proxy-only"), HOME: cwd, TMPDIR: cwd }, fence: launch.fence, fenceGrants: launch.fenceGrants, confinement: "required" });

package/dist/evidence-pair.d.ts

@@ -0,0 +1,53 @@
+import type { Store } from "./store.js";
+export type EvidenceReading = "failing" | "fixed" | "still-failing" | "check-changed" | "out-of-date";
+export type EvidenceSide = {
+    run: number;
+    head: string;
+    status: "passed" | "failed";
+    via: "build" | "follow-up";
+    screenshots: number[];
+};
+export type EvidencePair = {
+    id: number;
+    familyRoot: string;
+    before: EvidenceSide;
+    receiptDigest: string;
+    commandDigest: string | null;
+    savedBy: string;
+    savedAt: string;
+    after: EvidenceSide | null;
+    latestHead: string | null;
+    latestRun: number | null;
+    reading: EvidenceReading;
+};
+export declare function evidencePairsOf(store: Store, root: string, taskId: string, now: Date): EvidencePair[];
+export type SavePair = {
+    ok: true;
+    id: number;
+    existing: boolean;
+} | {
+    ok: false;
+    reason: "unknown" | "not-on-task" | "no-failed-check";
+    message: string;
+};
+/** Save a run's failed check as the before side. Only a sealed failure can be saved: there's nothing else to compare. */
+export declare function saveEvidencePair(store: Store, root: string, input: {
+    taskId: string;
+    runId?: number;
+    by: string;
+}, now: Date): SavePair;
+export type RerunPair = {
+    ok: true;
+    run: number;
+    head: string;
+    request: number;
+    existing: boolean;
+} | {
+    ok: false;
+    message: string;
+};
+/** Ask for the same check on the latest commit. Its level is the one the saved failure ran at. The caller proves the person. */
+export declare function rerunEvidence(store: Store, taskId: string, actor: string, now: Date): RerunPair;
+/** How a pair reads, in one sentence. */
+export declare function evidenceWords(pair: EvidencePair): string;
+export { askFailingFirst, dropFailingFirst, FAILING_FIRST_FILE, failingFirstOf, failingFirstReportSchema, failingFirstWords, saveFailingFirstReport, type FailingFirst } from "./failing-first.js";