toolroll 0.9.93 → 0.9.94

package/dist/contracts/gateway-tools.js

@@ -11,7 +11,7 @@
 import { z } from "zod";
 import { TEXT_LIMITS } from "../text-limits.js";
 import { envelopeSchema } from "./cli.js";
-import { catchUpOutput, decisionOutput, decisionsOutput, LISTED_TASK_STATES, queueColumnsOutput, recapOutput, repositoryContextOutput, scopeText, touches } from "./lead-tools.js";
+import { catchUpOutput, CODE_MAP_VIEWS, codeMapOutput, decisionOutput, decisionsOutput, LISTED_TASK_STATES, queueColumnsOutput, recapOutput, repositoryContextOutput, scopeText, touches } from "./lead-tools.js";
 const text = (key) => z.string().max(TEXT_LIMITS[key]);
 const ref = z.string().min(1).max(TEXT_LIMITS.taskRef);
 const projectPath = text("projectPath").min(1);
@@ -30,6 +30,7 @@ export const ASSIGNMENT_INPUTS = {
 };
 export const GATEWAY_TOOL_INPUTS = {
     get_project_context: z.strictObject({ repo: projectPath, query: text("contextQuery").min(1), mode: z.enum(["search", "impact"]).optional() }),
+    get_code_map: z.strictObject({ repo: projectPath, version: z.int().min(1).optional(), view: z.enum(CODE_MAP_VIEWS), id: text("projectPath").optional(), query: text("contextQuery").optional(), cursor: z.string().max(40).optional() }),
     get_assignment: ASSIGNMENT_INPUTS.show,
     list_assignment_updates: ASSIGNMENT_INPUTS.updates,
     claim_assignment: ASSIGNMENT_INPUTS.claim,
@@ -68,6 +69,7 @@ const proposed = z.looseObject({ proposal: int, kind: z.enum(["next", "reserve",
 const assignmentOutput = z.looseObject({ version: z.literal(1), rootId: str, activeTaskId: str, title: str, state: str, detail: str, attention: z.array(str) });
 export const GATEWAY_TOOL_OUTPUTS = {
     get_project_context: repositoryContextOutput,
+    get_code_map: codeMapOutput,
     get_assignment: assignmentOutput,
     list_assignment_updates: z.looseObject({ events: list, nextCursor: int, hasMore: z.boolean() }),
     claim_assignment: assignmentOutput,

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

@@ -30,6 +30,7 @@ export declare const acceptance: z.ZodArray<z.ZodObject<{
         screenshot: "screenshot";
     }>>;
 }, z.core.$strict>>;
+export declare const CODE_MAP_VIEWS: readonly ["overview", "area", "file", "search"];
 /** Task states a list filters by. */
 export declare const LISTED_TASK_STATES: readonly ["queued", "running", "done", "failed", "cancelled"];
 export declare const LEAD_TOOL_INPUTS: {
@@ -48,6 +49,22 @@ export declare const LEAD_TOOL_INPUTS: {
             search: "search";
         }>>;
     }, z.core.$strict>;
+    readonly get_code_map: z.ZodObject<{
+        repo: z.ZodString;
+        version: z.ZodOptional<z.ZodInt>;
+        view: z.ZodEnum<{
+            area: "area";
+            file: "file";
+            overview: "overview";
+            search: "search";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly refresh_code_map: z.ZodObject<{
+        repo: z.ZodString;
+    }, z.core.$strict>;
     readonly get_action_status: z.ZodObject<{
         proposal: z.ZodInt;
     }, z.core.$strict>;
@@ -74,6 +91,7 @@ export declare const LEAD_TOOL_INPUTS: {
         url: z.ZodOptional<z.ZodString>;
         secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
         about: z.ZodOptional<z.ZodString>;
+        on: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>;
     readonly propose_task_action: z.ZodObject<{
         task: z.ZodString;
@@ -537,6 +555,10 @@ export declare const LEAD_TOOL_INPUTS: {
         reference: z.ZodOptional<z.ZodString>;
         decision: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
+    readonly get_flaky_tests: z.ZodObject<{
+        repo: z.ZodString;
+        row: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
     readonly get_task_conversation: z.ZodObject<{
         task: z.ZodString;
         limit: z.ZodOptional<z.ZodInt>;
@@ -785,6 +807,22 @@ export declare const LEAD_TOOL_READ_INPUTS: {
             search: "search";
         }>>;
     }, z.core.$strict>;
+    readonly get_code_map: z.ZodObject<{
+        repo: z.ZodString;
+        version: z.ZodOptional<z.ZodInt>;
+        view: z.ZodEnum<{
+            area: "area";
+            file: "file";
+            overview: "overview";
+            search: "search";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly refresh_code_map: z.ZodObject<{
+        repo: z.ZodString;
+    }, z.core.$strict>;
     readonly get_action_status: z.ZodObject<{
         proposal: z.ZodInt;
     }, z.core.$strict>;
@@ -811,6 +849,7 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         url: z.ZodOptional<z.ZodString>;
         secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
         about: z.ZodOptional<z.ZodString>;
+        on: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>;
     readonly propose_task_action: z.ZodObject<{
         task: z.ZodString;
@@ -1267,6 +1306,10 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         reference: z.ZodOptional<z.ZodString>;
         decision: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
+    readonly get_flaky_tests: z.ZodObject<{
+        repo: z.ZodString;
+        row: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
     readonly commit_to: z.ZodObject<{
         what: z.ZodString;
         when: z.ZodEnum<{
@@ -1503,6 +1546,11 @@ export declare const LEAD_TOOL_READ_INPUTS: {
 export type LeadToolInput<N extends LeadToolName> = z.infer<(typeof LEAD_TOOL_READ_INPUTS)[N]>;
 /** How a tool's call names a key it doesn't know: propose_flow suggests the flow vocabulary's own words. */
 export declare const LEAD_TOOL_OPTIONS: Partial<Record<LeadToolName, ContractOptions>>;
+/** One bounded answer from the shared code map reader (code-map-read.ts `MapAnswer`). */
+export declare const codeMapOutput: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    ok: z.ZodBoolean;
+}, z.core.$loose>;
 /** A repository-context read (repository-context.ts `RepositoryContext`). */
 export declare const repositoryContextOutput: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -1609,6 +1657,16 @@ export declare const LEAD_TOOL_OUTPUTS: {
         asOf: z.ZodString;
         excerpts: z.ZodArray<z.ZodUnknown>;
     }, z.core.$loose>;
+    readonly get_code_map: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        ok: z.ZodBoolean;
+    }, z.core.$loose>;
+    readonly refresh_code_map: z.ZodObject<{
+        request: z.ZodEnum<{
+            "already-queued": "already-queued";
+            queued: "queued";
+        }>;
+    }, z.core.$loose>;
     readonly get_action_status: z.ZodObject<{
         proposal: z.ZodNumber;
         operation: z.ZodString;
@@ -1824,6 +1882,9 @@ export declare const LEAD_TOOL_OUTPUTS: {
     readonly get_project_knowledge: z.ZodObject<{
         revision: z.ZodNumber;
     }, z.core.$loose>;
+    readonly get_flaky_tests: z.ZodObject<{
+        notice: z.ZodString;
+    }, z.core.$loose>;
     readonly get_task_conversation: z.ZodObject<{
         task: z.ZodString;
         messages: z.ZodArray<z.ZodObject<{

package/dist/contracts/lead-tools.js

@@ -46,6 +46,7 @@ export const touches = z.array(text("taskTouch")).max(50);
 export const acceptance = z.array(acceptanceCriterionSchema).min(1).max(ACCEPTANCE_LIMITS.criteria);
 /** A note the operator's own words fill (revise feedback, steering, a flow card's note). */
 const note = z.string().max(LIMITS.note, { error: issue => overBy(LIMITS.note, issue.input) }).describe(`At most ${LIMITS.note} characters; longer is refused with its length, not cut.`);
+export const CODE_MAP_VIEWS = ["overview", "area", "file", "search"];
 /** Task states a list filters by. */
 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. */
@@ -54,6 +55,8 @@ export const LEAD_TOOL_INPUTS = {
     get_brief: z.strictObject({ repo: repoId.optional() }),
     get_project_activity: z.strictObject({ repo: repoId, offset: offset.optional() }),
     get_project_context: z.strictObject({ repo: repoId, query: text("contextQuery").min(1), mode: z.enum(["search", "impact"]).optional() }),
+    get_code_map: z.strictObject({ repo: repoId, version: id.optional(), view: z.enum(CODE_MAP_VIEWS), id: text("projectPath").optional(), query: text("contextQuery").optional(), cursor: z.string().max(40).optional() }),
+    refresh_code_map: z.strictObject({ repo: repoId }),
     get_action_status: z.strictObject({ proposal: id }),
     get_actions: z.strictObject({}),
     propose_action: z.strictObject({
@@ -61,7 +64,7 @@ export const LEAD_TOOL_INPUTS = {
         sample: text("actionSample").optional(), content: text("actionContent").optional(), instructions: text("flowInstructions").optional(),
         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(),
+        url: text("actionUrl").optional(), secrets: z.array(text("actionSecret")).max(12).optional(), about: text("actionAbout").optional(), on: z.boolean().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({}),
@@ -100,6 +103,7 @@ export const LEAD_TOOL_INPUTS = {
     get_flow_insights: z.strictObject({ repo: repoId.optional(), flow: id.optional(), days: z.int().min(1).max(90).optional(), card: id.optional(), entry: id.optional() }),
     get_skills: z.strictObject({ repo: repoId, version: z.string().regex(/^[a-f0-9]{20}$/).optional(), offset: offset.optional() }),
     get_project_knowledge: z.strictObject({ repo: repoId, reference: text("knowledgeReference").optional(), decision: id.optional() }),
+    get_flaky_tests: z.strictObject({ repo: repoId, row: text("knowledgeReference").optional() }),
     get_task_conversation: z.strictObject({ task: taskRef, limit: z.int().min(1).max(30).optional() }),
     commit_to: z.strictObject({
         what: text("promise").min(3), when: z.enum(["task", "run", "check", "time"]), task: taskRef.optional(), run: id.optional(),
@@ -185,6 +189,8 @@ const rows = (shape) => z.array(z.looseObject(shape));
 const cardDrafted = z.looseObject({ proposal: int, label: str, awaiting: str, executed: z.literal(false) });
 /** A proposal row drafted by one of the queue, hold, scope and answer tools. */
 const proposed = (kind, shape = {}) => z.looseObject({ proposal: int, kind: z.literal(kind), awaiting: str, ...shape });
+/** One bounded answer from the shared code map reader (code-map-read.ts `MapAnswer`). */
+export const codeMapOutput = z.looseObject({ v: z.literal(1), ok: z.boolean() });
 /** A repository-context read (repository-context.ts `RepositoryContext`). */
 export const repositoryContextOutput = z.looseObject({ version: z.literal(1), readOnly: z.boolean(), query: str, mode: z.enum(["search", "impact"]), asOf: str, excerpts: list });
 /** The local catch-up (assignment-brief.ts `AssignmentCatchUp`). */
@@ -201,6 +207,8 @@ export const LEAD_TOOL_OUTPUTS = {
     get_brief: catchUpOutput,
     get_project_activity: z.looseObject({ asOf: str, since: str, days: int, limit: int, truncated: z.boolean(), ready: z.object({ count: int, oldestFinishedAgeMs: nullable(int), dated: int }), completed: z.looseObject({ count: int }), families: list, familiesTotal: int, familiesOffset: int, nextOffset: nullable(int), incompleteHistory: int }),
     get_project_context: repositoryContextOutput,
+    get_code_map: codeMapOutput,
+    refresh_code_map: z.looseObject({ request: z.enum(["queued", "already-queued"]) }),
     get_action_status: z.looseObject({ proposal: int, operation: str, state: str, outcome: z.unknown(), finishedAt: nullable(str) }),
     get_actions: z.looseObject({ actions: rows({ operation: str, label: str, secureReview: z.boolean(), inputs: z.array(str) }), notice: str }),
     propose_action: cardDrafted,
@@ -241,6 +249,7 @@ export const LEAD_TOOL_OUTPUTS = {
         z.looseObject({ skills: list, nextOffset: nullable(int) }),
     ]),
     get_project_knowledge: z.looseObject({ revision: int }),
+    get_flaky_tests: z.looseObject({ notice: z.string() }),
     get_task_conversation: z.looseObject({ task: str, messages: rows({ from: z.enum(["operator", "lead"]), text: str, at: str }), notice: nullable(str) }),
     commit_to: z.looseObject({ commitment: int, condition: str, expires: str, report: str }),
     release_commitment: z.looseObject({ commitment: int, state: z.literal("cancelled") }),

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,6 +166,8 @@ 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";
             flow_browser: "flow_browser";

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

@@ -16,6 +16,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 +83,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
@@ -229,9 +231,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,12 +250,13 @@ 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);
@@ -270,7 +273,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 +291,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 +318,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 +346,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.js

@@ -1,4 +1,6 @@
 // Assignment tracking grants no repair authority or attempts.
+import { authorizeCheckOnly } from "./check-only.js";
+import { proposeNewRoute } from "./route-change.js";
 import { originalTaskBase, focusedTestCommandSupported } from "./observations.js";
 /**
  * The build disposition service (Parity II Phase 2, v4 Q2 / v6 W1): the
@@ -158,6 +160,8 @@ function disposeBuildOutcomeLocked(context, result) {
             });
             // A stated no-change publishes nothing.
             if (result.noChange !== true && result.committed) {
+                // The approval that built this commit allows one automatic recheck of it, should its verdict go missing.
+                authorizeCheckOnly(store, runId, clock());
                 const grant = store.publicationGrantFor(repo);
                 const headSha = store.getRun(runId)?.headRevision ?? null;
                 if (grant !== null &&
@@ -357,6 +361,8 @@ function disposeBuildOutcomeLocked(context, result) {
  */
 export function holdStaleApproval(store, args, now) {
     const scope = store.getScope(args.taskId);
+    // Toolroll proposes the new exact route itself (route-change.ts): the person's one act is Approve, on one line.
+    const proposed = proposeNewRoute(store, args.taskRef, args.taskId, now);
     store.holdOwned({
         taskRef: args.taskRef,
         ownerKind: "backoff",
@@ -370,8 +376,8 @@ export function holdStaleApproval(store, args, now) {
         kind: "stale-approval",
         pushClass: "attention",
         link: `/t/${encodeURIComponent(args.taskId)}`,
-        subject: `${args.taskId}: its approval no longer matches the build routing — approve it again`,
-        body: `${args.message}\nNothing runs on it until the scope is approved again; the hold lifts with the yes.`,
+        subject: `${args.taskId}: its agents changed — approve it again`,
+        body: `${proposed?.words ?? args.message}\nNothing runs on it until it's approved again.`,
     }, now);
 }
 // ---- the bounded repair loop (v40, evidence-review-v1) --------------------

package/dist/easy-start.js

@@ -284,9 +284,8 @@ export function defaultEasyStartSeams(options) {
             }
         },
         findRepo: async (dir) => {
-            const { run } = await import("./exec.js");
-            const top = await run("git", ["rev-parse", "--show-toplevel"], { cwd: dir, timeoutMs: 10_000 });
-            return top.code === 0 ? top.stdout.trim() : null;
+            const { checkoutTop } = await import("./teardown-git.js");
+            return checkoutTop(dir);
         },
         enrolled: async (repo) => {
             const { loadRepos } = await import("./repos.js");

package/dist/evals.js

@@ -27,6 +27,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { closeSync, constants, lstatSync, mkdirSync, mkdtempSync, openSync, readdirSync, realpathSync, rmSync, writeSync } from "node:fs";
 import { dirname, join, relative, sep } from "node:path";
 import { homedir, hostname } from "node:os";
+import { sameMachineHost } from "./machine-identity.js";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { readVerifiedCommit, verifiedBlobs } from "./commit-extract.js";
@@ -840,7 +841,7 @@ export function recoverEvalCampaigns(store, now, options = {}) {
     const out = [];
     for (const campaign of store.handle.prepare("SELECT id, runner_host, runner_pid, runner_started FROM eval_campaign WHERE state = 'running' ORDER BY admitted_at").all()) {
         const id = String(campaign["id"]);
-        if (String(campaign["runner_host"]) !== host) {
+        if (!sameMachineHost(String(campaign["runner_host"]), host)) {
             out.push({ id, recovered: false, why: `its runner is on ${String(campaign["runner_host"])}` });
             continue;
         }