toolroll 0.9.93 → 0.9.95

package/dist/contracts/project-knowledge.d.ts

@@ -68,10 +68,12 @@ export declare const knowledgeOmissionSchema: z.ZodObject<{
     title: z.ZodString;
     reason: z.ZodString;
 }, z.core.$strict>;
-export declare const KNOWLEDGE_SELECTION_VERSION = 1;
+/** Version 2 (docs/plans/learning-loops.md, "Versioned snapshots"): a selection says when it was frozen, and its decision
+ * lines their revision. Version 1 stays readable exactly as it was frozen, its fields as they are. */
+export declare const KNOWLEDGE_SELECTION_VERSION = 2;
 /** The selection a run is given, as it is frozen. The keys are in the order a selection has always been written. */
 export declare const knowledgeSelectionSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+    version: z.ZodLiteral<2>;
     revision: z.ZodInt;
     instructions: z.ZodString;
     references: z.ZodArray<z.ZodObject<{
@@ -91,11 +93,39 @@ export declare const knowledgeSelectionSchema: z.ZodObject<{
         id: z.ZodInt;
         claim: z.ZodString;
         decidedAt: z.ZodString;
+        revision: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>>>;
     repository: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    capturedAt: z.ZodString;
 }, z.core.$strict>;
-/** A frozen selection as it is read back. */
+/** A frozen selection as it is read back: the version it was frozen under. */
 export declare const savedKnowledgeSelectionSchema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    revision: z.ZodInt;
+    instructions: z.ZodString;
+    references: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        content: z.ZodString;
+        path: z.ZodNullable<z.ZodString>;
+        sourceSha: z.ZodNullable<z.ZodString>;
+        sourceRevision: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    omitted: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    inheritedFrom: z.ZodNullable<z.ZodInt>;
+    decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        claim: z.ZodString;
+        decidedAt: z.ZodString;
+        revision: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>>;
+    repository: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    capturedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const savedKnowledgeSelectionV1Schema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     revision: z.ZodInt;
     instructions: z.ZodString;
@@ -116,11 +146,14 @@ export declare const savedKnowledgeSelectionSchema: z.ZodObject<{
         id: z.ZodInt;
         claim: z.ZodString;
         decidedAt: z.ZodString;
+        revision: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>>>;
     repository: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
 }, z.core.$strict>;
-export type KnowledgeSelection = Omit<z.infer<typeof knowledgeSelectionSchema>, "repository"> & {
+export type KnowledgeSelection = Omit<z.infer<typeof knowledgeSelectionSchema>, "repository" | "version" | "capturedAt"> & {
+    version: 1 | 2;
+    capturedAt?: string;
     repository?: RepositoryContext;
 };
-/** Read a frozen selection: version 1 (every selection ever frozen) as itself, a newer one refused plainly. */
+/** Read a frozen selection: version 1 and 2 each as themselves, a newer one refused plainly. */
 export declare function readKnowledgeSelection(input: unknown): ContractResult<KnowledgeSelection>;

package/dist/contracts/project-knowledge.js

@@ -82,12 +82,18 @@ const selectionShape = (text) => ({
     /** Source excerpts from the crew's checkout (repository-context.ts owns their shape); absent when not captured. */
     repository: z.looseObject({}).optional(),
 });
-export const KNOWLEDGE_SELECTION_VERSION = 1;
+/** Version 2 (docs/plans/learning-loops.md, "Versioned snapshots"): a selection says when it was frozen, and its decision
+ * lines their revision. Version 1 stays readable exactly as it was frozen, its fields as they are. */
+export const KNOWLEDGE_SELECTION_VERSION = 2;
 /** The selection a run is given, as it is frozen. The keys are in the order a selection has always been written. */
-export const knowledgeSelectionSchema = versioned(KNOWLEDGE_SELECTION_VERSION, selectionShape(written));
-/** A frozen selection as it is read back. */
-export const savedKnowledgeSelectionSchema = versioned(KNOWLEDGE_SELECTION_VERSION, selectionShape(saved));
-/** Read a frozen selection: version 1 (every selection ever frozen) as itself, a newer one refused plainly. */
+export const knowledgeSelectionSchema = versioned(KNOWLEDGE_SELECTION_VERSION, { ...selectionShape(written), capturedAt: z.string() });
+/** A frozen selection as it is read back: the version it was frozen under. */
+export const savedKnowledgeSelectionSchema = versioned(KNOWLEDGE_SELECTION_VERSION, { ...selectionShape(saved), capturedAt: z.string() });
+export const savedKnowledgeSelectionV1Schema = versioned(1, selectionShape(saved));
+/** Read a frozen selection: version 1 and 2 each as themselves, a newer one refused plainly. */
 export function readKnowledgeSelection(input) {
+    const version = input !== null && typeof input === "object" ? input.version : undefined;
+    if (version === 1)
+        return readVersioned(savedKnowledgeSelectionV1Schema, input);
     return readVersioned(savedKnowledgeSelectionSchema, input);
 }

package/dist/contracts/project-memory.d.ts

@@ -75,11 +75,13 @@ export declare const decisionDraftSchema: z.ZodObject<{
     supersedes: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
 }, z.core.$strict>;
 export type DecisionDraft = z.infer<typeof decisionDraftSchema>;
-/** One decision in a brief: its id, the choice and when; the why loads on demand by id. */
+/** One decision in a brief: its id, the choice and when (the revision on snapshots from version 2 on); the why loads on
+ * demand by id. */
 export declare const decisionLineSchema: z.ZodObject<{
     id: z.ZodInt;
     claim: z.ZodString;
     decidedAt: z.ZodString;
+    revision: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 export type DecisionLine = z.infer<typeof decisionLineSchema>;
 export declare const DECISION_CHANGE_VERSION = 1;

package/dist/contracts/project-memory.js

@@ -38,8 +38,9 @@ export const decisionDraftSchema = z.strictObject({
     sourceRef: z.string().nullable().optional(),
     supersedes: z.int().nullable().optional(),
 });
-/** One decision in a brief: its id, the choice and when; the why loads on demand by id. */
-export const decisionLineSchema = z.strictObject({ id: z.int(), claim: z.string(), decidedAt: z.string() });
+/** One decision in a brief: its id, the choice and when (the revision on snapshots from version 2 on); the why loads on
+ * demand by id. */
+export const decisionLineSchema = z.strictObject({ id: z.int(), claim: z.string(), decidedAt: z.string(), revision: z.int().min(1).optional() });
 export const DECISION_CHANGE_VERSION = 1;
 /**
  * One entry of a decision's history (`decision_change.payload`): the record when it was made, or the reason its status

package/dist/contracts/storage.d.ts

@@ -11,6 +11,13 @@ export declare const checkoutCleanupSchema: z.ZodEnum<{
     finished: "finished";
     never: "never";
 }>;
+/** How long a task stays idle before its clean folder goes (v151, checkout-cleanup.ts). A saved row's NULL is the default. */
+export declare const checkoutIdleSchema: z.ZodEnum<{
+    "14d": "14d";
+    "30d": "30d";
+    "7d": "7d";
+    never: "never";
+}>;
 /** A saved `checkout_cleanup_setting` row (at most one; none means the default), unknown columns ignored. */
 export declare const checkoutCleanupRowSchema: z.ZodObject<{
     cleanup: z.ZodEnum<{
@@ -19,5 +26,12 @@ export declare const checkoutCleanupRowSchema: z.ZodObject<{
         finished: "finished";
         never: "never";
     }>;
+    idle: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        "14d": "14d";
+        "30d": "30d";
+        "7d": "7d";
+        never: "never";
+    }>>>;
 }, z.core.$strip>;
 export type CheckoutCleanup = z.infer<typeof checkoutCleanupSchema>;
+export type CheckoutIdle = z.infer<typeof checkoutIdleSchema>;

package/dist/contracts/storage.js

@@ -6,5 +6,7 @@
  */
 import { z } from "zod";
 export const checkoutCleanupSchema = z.enum(["finished", "2d", "7d", "never"]);
+/** How long a task stays idle before its clean folder goes (v151, checkout-cleanup.ts). A saved row's NULL is the default. */
+export const checkoutIdleSchema = z.enum(["7d", "14d", "30d", "never"]);
 /** A saved `checkout_cleanup_setting` row (at most one; none means the default), unknown columns ignored. */
-export const checkoutCleanupRowSchema = z.object({ cleanup: checkoutCleanupSchema });
+export const checkoutCleanupRowSchema = z.object({ cleanup: checkoutCleanupSchema, idle: checkoutIdleSchema.nullable().optional() });

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

@@ -166,8 +166,13 @@ declare const STORE_COLUMN_VALUES: {
     readonly "lead_proposal.payload_json": z.ZodUnion<readonly [z.ZodObject<{
         version: z.ZodLiteral<1>;
         operation: z.ZodEnum<{
+            code_map_holdout_end: "code_map_holdout_end";
+            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";
@@ -187,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";
@@ -213,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/contracts/youiyoux-request.d.ts

@@ -15,7 +15,7 @@ export declare const YOUIYOUX_FILED_VIA = "youiyoux";
  * Approve all and each one's own Approve and Open. */
 export declare const YOUIYOUX_CARD_KIND = "youiyoux-requests";
 /** Where a person sees and approves everything waiting on them in the console (flow-triggers.ts NEEDS_YOU_HREF). */
-export declare const YOUIYOUX_HOME_PATH = "/work?view=needs-you";
+export declare const YOUIYOUX_HOME_PATH = "/tasks?view=needs-you";
 export declare const YOUIYOUX_EVIDENCE: readonly ["screenshot", "check", "changed-path", "manual-review"];
 /** What an options request offers its agent: the one file to write (`.youi/proposals/<proposal>.json`), the props an
  * option may set (enum values from `values`), and whether it may give the component new text. */

package/dist/contracts/youiyoux-request.js

@@ -15,7 +15,7 @@ export const YOUIYOUX_FILED_VIA = "youiyoux";
  * Approve all and each one's own Approve and Open. */
 export const YOUIYOUX_CARD_KIND = "youiyoux-requests";
 /** Where a person sees and approves everything waiting on them in the console (flow-triggers.ts NEEDS_YOU_HREF). */
-export const YOUIYOUX_HOME_PATH = "/work?view=needs-you";
+export const YOUIYOUX_HOME_PATH = "/tasks?view=needs-you";
 const text = (max) => z.string().min(1).max(max);
 const who = z.object({ kind: z.enum(["person", "agent"]), name: text(100) });
 // The published schema's date-time: an ISO timestamp with a zone.

package/dist/desktop-access.js

@@ -2,8 +2,8 @@
 import { mkdtempSync, readFileSync, writeFileSync, unlinkSync, rmdirSync, opendirSync, realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execFileSync } from "node:child_process";
 import { run } from "./exec.js";
+import { checkoutGitSync, checkoutTop } from "./teardown-git.js";
 export function accessFailure(repo, code) {
     if (code === "EROFS")
         return { repo, state: "permission-needed", message: "This project is on a read-only drive. Choose a writable copy; Privacy Settings cannot make a read-only drive writable." };
@@ -23,7 +23,11 @@ export function probeDesktopProject(repo) {
         const directory = opendirSync(repo);
         directory.readSync();
         directory.closeSync();
-        const common = execFileSync("git", ["-C", repo, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf8", timeout: 4000, stdio: ["ignore", "pipe", "pipe"] }).trim();
+        // The project's own repository, read through a frozen view: a build's include naming a FIFO can't hang the probe.
+        const top = checkoutTop(repo, 4000);
+        if (top === null)
+            throw Error("Not a readable Git checkout");
+        const common = checkoutGitSync(top, ["rev-parse", "--path-format=absolute", "--git-common-dir"], { timeoutMs: 4000, binding: { repo: top } }).trim();
         scratch = mkdtempSync(join(realpathSync(common), "standing-orders-access-"));
         const file = join(scratch, "check");
         writeFileSync(file, "Toolroll access check\n", { flag: "wx", mode: 0o600 });

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";
@@ -16,6 +17,8 @@ import { REVIEW_TOKENS, resultStatusOf, reviewFactsOf } from "./workspace-ui.js"
 import { replacedWords } from "./task-status.js";
 import { failedAttemptSentence, latestFinishedAttempt } from "./needs-you.js";
 import { buildReviewOf } from "./review-switch.js";
+import { vanishedStopOf, vanishedStopSentence } from "./vanished-retry.js";
+import { routeChangeOf } from "./route-change.js";
 import { BUILT_IN, refArchived, parseCapabilityKey } from "./store.js";
 import { shortWhen } from "./when-html.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
@@ -81,7 +84,7 @@ export function scopeApprovedForDispatch(store, taskRef, now) {
        JOIN task_ref ON task_ref.id = ? AND task_scope.task_id = task_ref.external_id
        WHERE task_scope.approved_digest = task_scope.digest AND task_scope.approved_at IS NOT NULL
          AND ${authorityStandsSql("task_scope", "task_ref.repo", "?")}`)
-        .get(taskRef, now.toISOString(), now.toISOString(), now.toISOString());
+        .get(taskRef, now.toISOString(), now.toISOString(), now.toISOString(), now.toISOString());
     return row !== undefined;
 }
 /** The phase the ordinary dispatch loop would choose before it resolves an
@@ -159,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;
 }
@@ -229,9 +232,9 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
             return answer(code, code === "reviewing" ? "running" : "waiting", status.label, status.detail, { action: retry.state === "retryable" ? "retry-review" : "open-result", review });
         }
         if (!accepted && proof?.verdict === "refuted")
-            return answer("proof-refuted", "waiting", status.label, `${status.detail} Review the evidence to correct it, or record an explicit acceptance.`, { action: "open-result", review });
+            return answer("proof-refuted", "waiting", status.label, `${status.detail} Open the result to send it back, or accept it with a reason.`, { action: "open-result", review });
         if (!accepted && proof?.verdict === "short")
-            return answer("needs-verification", "waiting", status.label, `${status.detail} Open the result for the exact criteria still needing verification.`, { action: "open-result", review });
+            return answer("needs-verification", "waiting", status.label, `${status.detail} Open the result to see which requirements still need checking.`, { action: "open-result", review });
         if (!accepted && proof === null && noChangeRecord !== true)
             return answer("needs-verification", "waiting", status.label, status.detail, { action: "open-result", review });
         return answer("complete", "terminal", status.label, review?.state === "succeeded" && review.attempt !== null && review.attempt > 1
@@ -248,16 +251,22 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         // The family's latest finished attempt's own recorded reason, or that none was recorded: never "review its incident".
         const family = store.taskFamilyOf(taskId, ref.repo === null ? [] : [ref.repo], ref.repo === null);
         const runs = family === null || family.problem !== null ? store.runsFor(ref.id) : family.versions.flatMap(version => store.runsFor(version.refId));
-        return answer("failed", "terminal", "Needs a retry", failedAttemptSentence(latestFinishedAttempt(runs)?.reason), { action: "retry-task" });
+        const stopped = vanishedStopOf(store, ref.id);
+        return answer("failed", "terminal", "Needs a retry", stopped === null ? failedAttemptSentence(latestFinishedAttempt(runs)?.reason) : vanishedStopSentence(stopped), { action: "retry-task" });
     }
     if (store.hasLiveClaim(ref.id, now))
-        return answer("running", "running", "Running now", "A worker owns the current live claim.");
+        return answer("running", "running", "Running now", "A builder is working on it now.");
     if (task.state === "running")
-        return answer("vanished-run", "waiting", "Build vanished", "The task says running, but no current claim owns it; reconcile it before retrying.", { action: "retry-task" });
+        return answer("vanished-run", "waiting", "Build vanished", "The build stopped unexpectedly. Retry it.", { action: "retry-task" });
     if (updateAdmissionPaused(store.raw()))
         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);
@@ -270,7 +279,7 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         if (local.ownerKind === "decision")
             return answer("waiting-decision", "waiting", "Waiting on your answer", "An agent parked a question; answering it resumes the task.", { action: "answer-decision" });
         if (local.ownerKind === "incident")
-            return answer("waiting-incident", "waiting", "Needs a retry", "An unresolved incident holds the next attempt.", { action: "retry-task" });
+            return answer("waiting-incident", "waiting", "Needs a retry", "The last attempts failed the same way. Retry, or change the plan.", { action: "retry-task" });
         if (local.ownerKind === "stop")
             return answer("stopped", "waiting", "Paused", `${local.message.replace(/^held:\s*/, "")}. The attempt's work is preserved; resuming that exact attempt lifts this pause.`, { action: "resume-run" });
         return answer("held", "waiting", "On hold", local.message.replace(/^held:\s*/, ""), { action: local.ownerKind === "operator" ? "unhold" : "inspect-hold" });
@@ -288,14 +297,14 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
     const role = dispatchRoleFor(store, ref.id, now);
     const scope = store.getScope(taskId);
     if (ref.repo === null)
-        return answer("needs-project", "waiting", "Needs a project", "Place this task in a repository before a worker can claim it.", { action: "place-task", role });
+        return answer("needs-project", "waiting", "Needs a project", "Choose a project for this task so a builder can start it.", { action: "place-task", role });
     if (role !== "planner") {
         if (scope === null)
-            return answer("needs-scope", "waiting", "Needs a scope", "Write the success contract or ask the planner to draft it.", { action: "write-scope", role });
+            return answer("needs-scope", "waiting", "Needs a plan", "Write the plan, or ask the planner to draft it.", { action: "write-scope", role });
         if (scope.profileState === "unresolved")
             return answer("needs-agent-profile", "waiting", "Needs an agent profile", scope.unresolvedReason ?? "Choose an available provider and model.", { action: "select-agent", role });
         if (!scopeApprovedForDispatch(store, ref.id, now) || !approvalOf(scope).approved) {
-            return answer("needs-approval", "waiting", "Needs your approval", "Review and sign the current scope before a worker can claim it.", { action: "approve-scope", role });
+            return answer("needs-approval", "waiting", "Needs your approval", routeChangeOf(store, taskId) ?? "Review the plan and approve it so a builder can start.", { action: "approve-scope", role });
         }
     }
     const gap = missingCapability(store, ref.id, ref.repo, now);
@@ -315,14 +324,14 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
     }
     const available = alive.filter(one => store.liveClaimCount(one.name, now) < one.capacity);
     if (available.length === 0)
-        return answer("worker-at-capacity", "retrying", "Waiting for worker capacity", "Every eligible worker is busy; this task starts when a slot is released.", { role });
+        return answer("worker-at-capacity", "retrying", "Waiting its turn", "Builders are busy; it starts when one is free.", { role });
     const profile = approvedProfile(scope);
     if (profile !== null) {
         const exhausted = available.map(one => store.readQuotaState(one.name, profile.provider, profile.model, now)).filter(one => one?.state === "exhausted");
         if (exhausted.length === available.length) {
             const resets = exhausted.map(one => one?.resetAt ?? null).filter((one) => one !== null).sort();
             const nextAt = resets[0] ?? null;
-            return answer("provider-quota", "retrying", "Provider quota exhausted", nextAt === null ? "The provider has not supplied a reset time; this needs operator attention." : `The next recorded reset is ${nextAt}.`, { action: nextAt === null ? "select-agent" : null, nextAt, role });
+            return answer("provider-quota", "retrying", "Provider quota exhausted", nextAt === null ? "The provider gave no reset time. Choose another agent, or wait for the limit to reset." : `The next recorded reset is ${nextAt}.`, { action: nextAt === null ? "select-agent" : null, nextAt, role });
         }
     }
     // The sign-in pause: the task's provider stopped working; nothing it would
@@ -343,11 +352,11 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         const sourceProblem = plannerSourceProblemOf(store, taskId);
         if (sourceProblem !== null)
             return answer("planner-source", "waiting", sourceProblem.title, sourceProblem.detail, { action: "write-scope", role });
-        return answer("planning-ready", "retrying", "Planner ready", "An eligible worker can draft the scope on the next pass.", { role });
+        return answer("planning-ready", "retrying", "Waiting to plan", "A builder can draft the plan next.", { role });
     }
     if (role === "scout")
-        return answer("scouting-ready", "retrying", "Scout ready", "An eligible worker can produce the report on the next pass.", { role });
-    return answer("ready", "retrying", "Ready to run", "An eligible worker has capacity and every dispatch gate currently passes.", { role });
+        return answer("scouting-ready", "retrying", "Waiting to research", "A builder can write the report next.", { role });
+    return answer("ready", "retrying", "Ready to run", "A builder is free and nothing is in the way.", { role });
 }
 export function diagnosisIsDispatchable(diagnosis) {
     return diagnosis?.code === "ready" || diagnosis?.code === "planning-ready" || diagnosis?.code === "scouting-ready";

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";
 };