toolroll 0.9.91 → 0.9.93

package/dist/contracts/route-results.js

@@ -0,0 +1,71 @@
+/**
+ * Result records (docs/plans/results-routing.md, slice 1): the words and shapes a task family's result record is kept
+ * and shown in. A policy path (release-auto.ts EVAL_POLICY): the states, reasons and the execution-class table decide
+ * what a cheaper model's evidence is, so a change to them needs a person.
+ */
+import { z } from "zod";
+/** A record's lifecycle. Only mature and rejected records are decided; pending and provisional never count anywhere. */
+export const RECORD_STATES = ["pending", "provisional", "mature", "rejected", "not-counted"];
+/** Why a record was rejected, in the order they are checked. */
+export const REJECT_REASONS = ["model-failures", "task-failed", "cancelled-after-result", "high-finding", "person-revision", "proof-refuted", "check-failed"];
+/** Why a record is not counted. Never counted as good, never as 0. */
+export const NOT_COUNTED_REASONS = [
+    "before-records", "not-eligible", "mixed-cohort", "mixed-models", "model-not-reported", "infrastructure-only", "cancelled-before-result",
+    "no-check", "check-unavailable", "touched-protected", "changed-files-unknown", "unanswered",
+];
+/** The plain words for each reason. */
+export const REASON_WORDS = Object.freeze({
+    "model-failures": "two or more attempts failed on the model's own account",
+    "task-failed": "the task failed",
+    "cancelled-after-result": "it was cancelled after a result",
+    "high-finding": "the automatic review found a serious problem",
+    "person-revision": "a person asked for changes",
+    "proof-refuted": "its evidence didn't match the changes",
+    "check-failed": "its checks failed",
+    "before-records": "started before results were recorded",
+    "not-eligible": "not a small or routine task with default checks",
+    "mixed-cohort": "its attempts ran under different task sizes or settings",
+    "mixed-models": "its attempts ran on different models",
+    "model-not-reported": "the provider didn't report the model",
+    "infrastructure-only": "it failed only for reasons outside the model",
+    "cancelled-before-result": "it was cancelled before a result",
+    "no-check": "no checks configured",
+    "check-unavailable": "its check result can't be read",
+    "touched-protected": "touched protected files",
+    "changed-files-unknown": "changed files unknown",
+    "unanswered": "no answer in 30 days",
+});
+/** Why a run was refused a cohort before dispatch: any of these makes its record not counted ("not eligible"). */
+export const INELIGIBLE_REASONS = ["no-sealed-route", "not-built-in", "large", "risky", "unsized", "strict", "evidence-demands", "automerge", "release", "protected"];
+/** Who a revision came from (task_ref.revision_origin). Only `person` rejects a record. */
+export const REVISION_ORIGINS = ["person", "automatic-review", "flow", "lead", "machine"];
+/** A failed run's execution class, kept before the tick normalizes its reason (run.exec_class). */
+export const EXEC_CLASSES = ["model", "infrastructure"];
+/** The build leg's sealed selection, as a run's cohort keeps it (route v3 `selection`; earlier routes by `chosen`). */
+export const selectionSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("rule"), rule: z.number().int().positive(), ruleGeneration: z.number().int().positive() }),
+    z.strictObject({ kind: z.literal("trial"), rule: z.number().int().positive(), reservation: z.number().int().positive() }),
+    z.strictObject({ kind: z.enum(["configured", "override", "pin"]) }),
+]);
+/** One record as `toolroll models results --json` returns it. */
+export const resultRecordSchema = z.strictObject({
+    task: z.string(),
+    repo: z.string().nullable(),
+    size: z.enum(["small", "medium"]).nullable(),
+    provider: z.string().nullable(),
+    model: z.string().nullable(),
+    state: z.enum(RECORD_STATES),
+    reason: z.enum([...REJECT_REASONS, ...NOT_COUNTED_REASONS]).nullable(),
+    words: z.string(),
+    resultRun: z.number().int().nullable(),
+    acceptedAt: z.string().nullable(),
+    decidedAt: z.string().nullable(),
+    failures: z.strictObject({ model: z.number().int(), infrastructure: z.number().int() }),
+    spend: z.strictObject({ apiMicrousd: z.number().int(), subscriptionRuns: z.number().int(), subscriptionTokens: z.number().int(), unknownRuns: z.number().int(), remediationRuns: z.number().int() }),
+    /** Counts that keep accumulating after the verdict is final, until the record closes. */
+    personRevisions: z.number().int(),
+    firstCheckPassed: z.boolean().nullable(),
+    turns: z.strictObject({ known: z.number().int(), unknownRuns: z.number().int() }),
+    closed: z.boolean(),
+    selections: z.array(selectionSchema),
+});

package/dist/contracts/route.d.ts

@@ -12,6 +12,7 @@
  */
 import { z } from "zod";
 import { type ContractResult } from "./contract.js";
+import { type Selection } from "./route-results.js";
 /** The phases a route has a leg for, in the order its legs run. */
 export declare const ROUTE_PHASES: readonly ["plan", "build", "repair", "review"];
 /** provider.ts's provider ids, restated (provider.ts sits above phase-routing.ts in the module graph) and pinned to
@@ -22,8 +23,15 @@ export declare const ROUTE_PROVIDERS: readonly ["claude", "codex", "openrouter",
 export declare const MODEL_ID_SHAPE: RegExp;
 export declare const RISKS: readonly ["routine", "elevated", "high"];
 export declare const TASK_SIZE_WORDS: readonly ["small", "medium", "large"];
-/** The route version this code seals; version 1 (before sizing) still reads. */
-export declare const ROUTE_VERSION = 2;
+/** The newest route version this code seals (docs/plans/results-routing.md, slice 2): version 3 adds the build leg's
+ * sealed `selection`, and is sealed only for a build leg that carries one (an earned rule's). Every other route still
+ * seals as version 2 (PLAIN_ROUTE_VERSION), so its bytes and digest are what they always were; version 1 (before
+ * sizing) still reads. */
+export declare const ROUTE_VERSION = 3;
+/** The version a route with no selection seals as. */
+export declare const PLAIN_ROUTE_VERSION = 2;
+/** The newest route version this code reads. */
+export declare const READ_ROUTE_VERSION = 3;
 /** How big a change the task is, as it was sized (by the classifier, the description, or a person). */
 export declare const taskSizingSchema: z.ZodObject<{
     size: z.ZodEnum<{
@@ -114,6 +122,73 @@ export declare const routeLegSchema: z.ZodObject<{
     reasons: z.ZodArray<z.ZodString>;
     problem: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
+/** One leg of a version 3 route: a version 2 leg, and the build leg may say how it was selected. */
+export declare const routeLegV3Schema: z.ZodObject<{
+    phase: z.ZodEnum<{
+        build: "build";
+        plan: "plan";
+        repair: "repair";
+        review: "review";
+    }>;
+    provider: z.ZodEnum<{
+        claude: "claude";
+        cline: "cline";
+        codex: "codex";
+        cursor: "cursor";
+        gemini: "gemini";
+        goose: "goose";
+        opencode: "opencode";
+        openrouter: "openrouter";
+        qwen: "qwen";
+    }>;
+    model: z.ZodString;
+    tier: z.ZodEnum<{
+        light: "light";
+        routine: "routine";
+        strong: "strong";
+    }>;
+    chosen: z.ZodEnum<{
+        override: "override";
+        pinned: "pinned";
+        recommended: "recommended";
+    }>;
+    recommended: z.ZodObject<{
+        provider: z.ZodEnum<{
+            claude: "claude";
+            cline: "cline";
+            codex: "codex";
+            cursor: "cursor";
+            gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
+            openrouter: "openrouter";
+            qwen: "qwen";
+        }>;
+        model: z.ZodString;
+        tier: z.ZodEnum<{
+            light: "light";
+            routine: "routine";
+            strong: "strong";
+        }>;
+    }, z.core.$strict>;
+    reasons: z.ZodArray<z.ZodString>;
+    problem: z.ZodNullable<z.ZodString>;
+    selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"rule">;
+        rule: z.ZodNumber;
+        ruleGeneration: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"trial">;
+        rule: z.ZodNumber;
+        reservation: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            configured: "configured";
+            override: "override";
+            pin: "pin";
+        }>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
 export declare const sealedRouteV1Schema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     risk: z.ZodEnum<{
@@ -328,7 +403,137 @@ export declare const sealedRouteV2Schema: z.ZodObject<{
         reason: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-/** A sealed route as saved, in either version. */
+export declare const sealedRouteV3Schema: z.ZodObject<{
+    version: z.ZodLiteral<3>;
+    risk: z.ZodEnum<{
+        elevated: "elevated";
+        high: "high";
+        routine: "routine";
+    }>;
+    qualityMode: z.ZodEnum<{
+        default: "default";
+        strict: "strict";
+    }>;
+    publication: z.ZodEnum<{
+        automerge: "automerge";
+        none: "none";
+        notify: "notify";
+    }>;
+    evidence: z.ZodArray<z.ZodEnum<{
+        "changed-path": "changed-path";
+        check: "check";
+        "manual-review": "manual-review";
+        screenshot: "screenshot";
+    }>>;
+    posture: z.ZodEnum<{
+        economy: "economy";
+        strong: "strong";
+    }>;
+    demands: z.ZodArray<z.ZodString>;
+    legs: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            build: "build";
+            plan: "plan";
+            repair: "repair";
+            review: "review";
+        }>;
+        provider: z.ZodEnum<{
+            claude: "claude";
+            cline: "cline";
+            codex: "codex";
+            cursor: "cursor";
+            gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
+            openrouter: "openrouter";
+            qwen: "qwen";
+        }>;
+        model: z.ZodString;
+        tier: z.ZodEnum<{
+            light: "light";
+            routine: "routine";
+            strong: "strong";
+        }>;
+        chosen: z.ZodEnum<{
+            override: "override";
+            pinned: "pinned";
+            recommended: "recommended";
+        }>;
+        recommended: z.ZodObject<{
+            provider: z.ZodEnum<{
+                claude: "claude";
+                cline: "cline";
+                codex: "codex";
+                cursor: "cursor";
+                gemini: "gemini";
+                goose: "goose";
+                opencode: "opencode";
+                openrouter: "openrouter";
+                qwen: "qwen";
+            }>;
+            model: z.ZodString;
+            tier: z.ZodEnum<{
+                light: "light";
+                routine: "routine";
+                strong: "strong";
+            }>;
+        }, z.core.$strict>;
+        reasons: z.ZodArray<z.ZodString>;
+        problem: z.ZodNullable<z.ZodString>;
+        selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"rule">;
+            rule: z.ZodNumber;
+            ruleGeneration: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"trial">;
+            rule: z.ZodNumber;
+            reservation: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                configured: "configured";
+                override: "override";
+                pin: "pin";
+            }>;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    overrides: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            build: "build";
+            plan: "plan";
+            repair: "repair";
+            review: "review";
+        }>;
+        provider: z.ZodEnum<{
+            claude: "claude";
+            cline: "cline";
+            codex: "codex";
+            cursor: "cursor";
+            gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
+            openrouter: "openrouter";
+            qwen: "qwen";
+        }>;
+        model: z.ZodString;
+        by: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strict>>;
+    size: z.ZodNullable<z.ZodObject<{
+        size: z.ZodEnum<{
+            large: "large";
+            medium: "medium";
+            small: "small";
+        }>;
+        risky: z.ZodBoolean;
+        source: z.ZodEnum<{
+            classifier: "classifier";
+            heuristic: "heuristic";
+            person: "person";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** A sealed route as saved, in any version. */
 export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     version: z.ZodLiteral<1>;
     risk: z.ZodEnum<{
@@ -541,15 +746,148 @@ export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         reason: z.ZodString;
     }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<3>;
+    risk: z.ZodEnum<{
+        elevated: "elevated";
+        high: "high";
+        routine: "routine";
+    }>;
+    qualityMode: z.ZodEnum<{
+        default: "default";
+        strict: "strict";
+    }>;
+    publication: z.ZodEnum<{
+        automerge: "automerge";
+        none: "none";
+        notify: "notify";
+    }>;
+    evidence: z.ZodArray<z.ZodEnum<{
+        "changed-path": "changed-path";
+        check: "check";
+        "manual-review": "manual-review";
+        screenshot: "screenshot";
+    }>>;
+    posture: z.ZodEnum<{
+        economy: "economy";
+        strong: "strong";
+    }>;
+    demands: z.ZodArray<z.ZodString>;
+    legs: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            build: "build";
+            plan: "plan";
+            repair: "repair";
+            review: "review";
+        }>;
+        provider: z.ZodEnum<{
+            claude: "claude";
+            cline: "cline";
+            codex: "codex";
+            cursor: "cursor";
+            gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
+            openrouter: "openrouter";
+            qwen: "qwen";
+        }>;
+        model: z.ZodString;
+        tier: z.ZodEnum<{
+            light: "light";
+            routine: "routine";
+            strong: "strong";
+        }>;
+        chosen: z.ZodEnum<{
+            override: "override";
+            pinned: "pinned";
+            recommended: "recommended";
+        }>;
+        recommended: z.ZodObject<{
+            provider: z.ZodEnum<{
+                claude: "claude";
+                cline: "cline";
+                codex: "codex";
+                cursor: "cursor";
+                gemini: "gemini";
+                goose: "goose";
+                opencode: "opencode";
+                openrouter: "openrouter";
+                qwen: "qwen";
+            }>;
+            model: z.ZodString;
+            tier: z.ZodEnum<{
+                light: "light";
+                routine: "routine";
+                strong: "strong";
+            }>;
+        }, z.core.$strict>;
+        reasons: z.ZodArray<z.ZodString>;
+        problem: z.ZodNullable<z.ZodString>;
+        selection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"rule">;
+            rule: z.ZodNumber;
+            ruleGeneration: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"trial">;
+            rule: z.ZodNumber;
+            reservation: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                configured: "configured";
+                override: "override";
+                pin: "pin";
+            }>;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    overrides: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            build: "build";
+            plan: "plan";
+            repair: "repair";
+            review: "review";
+        }>;
+        provider: z.ZodEnum<{
+            claude: "claude";
+            cline: "cline";
+            codex: "codex";
+            cursor: "cursor";
+            gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
+            openrouter: "openrouter";
+            qwen: "qwen";
+        }>;
+        model: z.ZodString;
+        by: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strict>>;
+    size: z.ZodNullable<z.ZodObject<{
+        size: z.ZodEnum<{
+            large: "large";
+            medium: "medium";
+            small: "small";
+        }>;
+        risky: z.ZodBoolean;
+        source: z.ZodEnum<{
+            classifier: "classifier";
+            heuristic: "heuristic";
+            person: "person";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>], "version">;
 export type SealedRoute = z.infer<typeof sealedRouteSchema>;
 export type RouteVersion = SealedRoute["version"];
-export type RouteLeg = z.infer<typeof routeLegSchema>;
+/** A leg as every reader returns it: only a version 3 build leg can carry a selection. */
+export type RouteLeg = z.infer<typeof routeLegSchema> & {
+    selection?: Selection | undefined;
+};
 export type RouteOverride = z.infer<typeof routeOverrideSchema>;
 export type TaskSizing = z.infer<typeof taskSizingSchema>;
 /** A route as every reader returns it: a version 1 route reads with no size. */
-export type PhaseRoute = Omit<z.infer<typeof sealedRouteV2Schema>, "version"> & {
+export type PhaseRoute = Omit<z.infer<typeof sealedRouteV2Schema>, "version" | "legs"> & {
     version: RouteVersion;
+    legs: RouteLeg[];
 };
 /** The posture legs actually run under: strong only when a leg runs a configured strong agent as recommended. */
 export declare function postureOf(legs: readonly Pick<RouteLeg, "chosen" | "tier">[]): "economy" | "strong";

package/dist/contracts/route.js

@@ -13,6 +13,7 @@
 import { z } from "zod";
 import { EVIDENCE_KINDS } from "./acceptance-terms.js";
 import { limited, parseContract, versioned } from "./contract.js";
+import { selectionSchema } from "./route-results.js";
 /** The phases a route has a leg for, in the order its legs run. */
 export const ROUTE_PHASES = ["plan", "build", "repair", "review"];
 /** provider.ts's provider ids, restated (provider.ts sits above phase-routing.ts in the module graph) and pinned to
@@ -23,8 +24,15 @@ export const ROUTE_PROVIDERS = ["claude", "codex", "openrouter", "gemini", "open
 export const MODEL_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
 export const RISKS = ["routine", "elevated", "high"];
 export const TASK_SIZE_WORDS = ["small", "medium", "large"];
-/** The route version this code seals; version 1 (before sizing) still reads. */
-export const ROUTE_VERSION = 2;
+/** The newest route version this code seals (docs/plans/results-routing.md, slice 2): version 3 adds the build leg's
+ * sealed `selection`, and is sealed only for a build leg that carries one (an earned rule's). Every other route still
+ * seals as version 2 (PLAIN_ROUTE_VERSION), so its bytes and digest are what they always were; version 1 (before
+ * sizing) still reads. */
+export const ROUTE_VERSION = 3;
+/** The version a route with no selection seals as. */
+export const PLAIN_ROUTE_VERSION = 2;
+/** The newest route version this code reads. */
+export const READ_ROUTE_VERSION = ROUTE_VERSION;
 const phase = z.enum(ROUTE_PHASES);
 const provider = z.enum(ROUTE_PROVIDERS);
 const model = z.string().regex(MODEL_ID_SHAPE, { error: "must be an exact model id: letters, digits and . _ : / -, not starting with a dash" });
@@ -53,6 +61,8 @@ function legSchema(tiers) {
 }
 /** One leg of a version 2 route: the light tier exists. */
 export const routeLegSchema = legSchema(["light", "routine", "strong"]);
+/** One leg of a version 3 route: a version 2 leg, and the build leg may say how it was selected. */
+export const routeLegV3Schema = routeLegSchema.extend({ selection: selectionSchema.optional() });
 const terms = {
     risk: z.enum(RISKS),
     qualityMode: z.enum(["default", "strict"]),
@@ -66,14 +76,20 @@ export const sealedRouteV1Schema = versioned(1, {
     legs: z.array(legSchema(["routine", "strong"])).length(ROUTE_PHASES.length),
     overrides: z.array(routeOverrideSchema),
 });
-export const sealedRouteV2Schema = versioned(ROUTE_VERSION, {
+export const sealedRouteV2Schema = versioned(PLAIN_ROUTE_VERSION, {
     ...terms,
     legs: z.array(routeLegSchema).length(ROUTE_PHASES.length),
     overrides: z.array(routeOverrideSchema),
     size: taskSizingSchema.nullable(),
 });
-/** A sealed route as saved, in either version. */
-export const sealedRouteSchema = z.discriminatedUnion("version", [sealedRouteV1Schema, sealedRouteV2Schema]);
+export const sealedRouteV3Schema = versioned(READ_ROUTE_VERSION, {
+    ...terms,
+    legs: z.array(routeLegV3Schema).length(ROUTE_PHASES.length),
+    overrides: z.array(routeOverrideSchema),
+    size: taskSizingSchema.nullable(),
+});
+/** A sealed route as saved, in any version. */
+export const sealedRouteSchema = z.discriminatedUnion("version", [sealedRouteV1Schema, sealedRouteV2Schema, sealedRouteV3Schema]);
 /** The posture legs actually run under: strong only when a leg runs a configured strong agent as recommended. */
 export function postureOf(legs) {
     return legs.some(leg => leg.chosen === "recommended" && leg.tier === "strong") ? "strong" : "economy";
@@ -94,14 +110,27 @@ export function readRouteOverrides(input) {
 /** Read a sealed route: either version as itself, every leg, override and the size proved, nothing unknown. */
 export function readSealedRoute(input) {
     const version = typeof input === "object" && input !== null ? input["version"] : undefined;
-    if (typeof version === "number" && Number.isInteger(version) && version > ROUTE_VERSION) {
-        return { ok: false, issues: [{ path: "version", kind: "newer-version", line: `version: made by a newer Toolroll (version ${version}; this one reads up to ${ROUTE_VERSION})` }] };
+    if (typeof version === "number" && Number.isInteger(version) && version > READ_ROUTE_VERSION) {
+        return { ok: false, issues: [{ path: "version", kind: "newer-version", line: `version: made by a newer Toolroll (version ${version}; this one reads up to ${READ_ROUTE_VERSION})` }] };
     }
     const parsed = parseContract(sealedRouteSchema, input);
     if (!parsed.ok)
         return parsed;
     const route = parsed.value;
     const issues = route.legs.flatMap((leg, index) => (leg.phase === ROUTE_PHASES[index] ? [] : [issue(`legs[${index}].phase`, `must be ${JSON.stringify(ROUTE_PHASES[index])} (legs run plan, build, repair, review)`)]));
+    // Version 3: only the build leg says how it was selected, and what it says agrees with how it was chosen.
+    route.legs.forEach((leg, index) => {
+        const selection = leg.selection;
+        if (selection === undefined)
+            return;
+        if (leg.phase !== "build") {
+            issues.push(issue(`legs[${index}].selection`, "only the build leg carries a selection"));
+            return;
+        }
+        const chosen = selection.kind === "override" ? "override" : selection.kind === "pin" ? "pinned" : "recommended";
+        if (leg.chosen !== chosen)
+            issues.push(issue(`legs[${index}].selection`, `a ${selection.kind} selection is chosen ${JSON.stringify(chosen)}, not ${JSON.stringify(leg.chosen)}`));
+    });
     const posture = postureOf(route.legs);
     if (posture !== route.posture)
         issues.push(issue("posture", `must be ${JSON.stringify(posture)}: that is what its legs run`));

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

@@ -210,12 +210,14 @@ declare const STORE_COLUMN_VALUES: {
             subagent_state: "subagent_state";
             subagent_tools: "subagent_tools";
             subagent_undo: "subagent_undo";
+            suggestion_not_now: "suggestion_not_now";
             sweep_cancel_rest: "sweep_cancel_rest";
             sweep_file: "sweep_file";
             task_cancel: "task_cancel";
             task_resume: "task_resume";
             tool_add: "tool_add";
             tool_remove: "tool_remove";
+            trial_stop: "trial_stop";
         }>;
         request: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
         repo: z.ZodString;

package/dist/desktop-update.d.ts

@@ -74,8 +74,8 @@ export declare function desktopUpdateWaitingOf(databaseFile: string, inTheWay: (
 /** The same settling reconcile the background worker runs: a finished run's leftover record of a process that never
  * started settles once the run's process groups are proven gone. A record nothing can prove either way stays. */
 export declare function settleLeftoverRecords(db: DatabaseSync, now: Date): number;
-/** Store.stopQuiescenceProblem's reasons, said for a person: no internal terms, and `toolroll run settle` only where it
- * can clear the record (it refuses while anything of the run is alive). */
+/** Store.stopQuiescenceProblem's reasons, said for a person: no internal terms. Nobody vouches that a run stopped:
+ * Toolroll proves it itself (stop-proof.ts), and `toolroll run settle` only has it look again now. */
 export declare function plainLingering(fallbackRun: number, problem: string): LingeringRun;
 export declare function previewDesktopUpdate(stateDir: string, installed: string, candidate: string, label: string, hooks?: UpdateHooks): Promise<{
     old: DesktopBundle;

package/dist/desktop-update.js

@@ -193,11 +193,11 @@ export function lingeringWork(db) {
     const lingering = lingeringRun(db);
     return lingering && lingeringWords(lingering);
 }
-export const lingeringWords = (l) => l.action ? `${l.on}. If nothing of it is running, run: ${l.action}` : `${l.on}.`;
+export const lingeringWords = (l) => l.action ? `${l.on}. To have Toolroll check again, run: ${l.action}` : `${l.on}.`;
 /** What an update says when it stops waiting on `l`: what is in the way, the command, and that new work resumed. */
 export const stoppedWaitingWords = (l) => `Stopped waiting after 2 minutes. ${l.on}. ${clearWords(l)} New work resumed; nothing was changed.`;
 /** The next step once an update has stopped on `l`. */
-export const clearWords = (l) => l.action ? `If nothing of it is running, run ${l.action}, then update again.` : "Update again once it has stopped.";
+export const clearWords = (l) => l.action ? `To have Toolroll check again, run ${l.action}, then update again.` : "Update again once it has stopped.";
 export function updateWaitingWords(o) {
     const { app, version, stopped, lingering: l } = o;
     const update = `${app ? "App update" : "Update"} to ${version}`;
@@ -206,7 +206,7 @@ export function updateWaitingWords(o) {
         const words = `${update} is waiting for ${on}. New work is paused.`;
         return { app, version, stopped: false, run: null, on, action: null, words, short: words };
     }
-    const next = l.action ? ` If nothing of it is running, run ${l.action}${stopped ? ", then update again" : ""}.` : stopped ? " Update again once it has stopped." : "";
+    const next = l.action ? ` To have Toolroll check again, run ${l.action}${stopped ? ", then update again" : ""}.` : stopped ? " Update again once it has stopped." : "";
     return { app, version, stopped, run: l.run, on: l.on, action: l.action,
         words: `${update} ${stopped ? "stopped waiting" : "is waiting"}: ${l.on}.${next}`,
         short: `${update} ${stopped ? `stopped: run #${l.run} is in the way` : `is waiting on run #${l.run}`}.${next}` };
@@ -284,18 +284,22 @@ export function desktopUpdateWaitingOf(databaseFile, inTheWay, stateDirs = [dirn
 export function settleLeftoverRecords(db, now) {
     return new Store(db).settleUnspawnedWitnesses(now);
 }
-/** Store.stopQuiescenceProblem's reasons, said for a person: no internal terms, and `toolroll run settle` only where it
- * can clear the record (it refuses while anything of the run is alive). */
+/** Store.stopQuiescenceProblem's reasons, said for a person: no internal terms. Nobody vouches that a run stopped:
+ * Toolroll proves it itself (stop-proof.ts), and `toolroll run settle` only has it look again now. */
 export function plainLingering(fallbackRun, problem) {
     const run = Number(/run #(\d+)/.exec(problem)?.[1] ?? fallbackRun);
-    const settle = `toolroll run settle ${run} --why "it is not running"`;
+    const settle = `toolroll run settle ${run}`;
     const pid = /process (\d+)/.exec(problem)?.[1];
     if (/incomplete spawn witness|before its process witness was recorded/.test(problem))
-        return { run, on: `Run #${run} finished, but Toolroll has no process ID for one of its processes, so it can't confirm that process ended`, action: settle };
-    if (/belongs to another host|another host/.test(problem))
+        return { run, on: `Run #${run} finished, and Toolroll is making sure none of its processes is still running`, action: settle };
+    if (/belongs to another host|another host|another computer/.test(problem))
         return { run, on: `Run #${run} finished on another computer, and Toolroll can only confirm its processes ended there`, action: `${settle} (on that computer)` };
+    if (/can't be proven stopped: .* is using its folder/.test(problem))
+        return { run, on: `Run #${run} finished, but something Toolroll didn't start is using its folder`, action: settle };
+    if (/can't be checked on this computer/.test(problem))
+        return { run, on: `Run #${run} finished, but Toolroll can't check this computer's processes`, action: settle };
     if (/incomplete native containment custody|cannot be proven empty/.test(problem))
-        return { run, on: `Run #${run} finished, but Toolroll can't confirm its sandbox is empty`, action: settle };
+        return { run, on: `Run #${run} finished, but Toolroll can't confirm its sandbox is empty`, action: null };
     if (/still has members/.test(problem))
         return { run, on: `Run #${run} finished, but processes are still running in its sandbox`, action: null };
     if (/workspace is still held/.test(problem))

package/dist/dispose.js

@@ -25,6 +25,7 @@ import { verificationEvidence, failedVerificationEvidence } from "./verification
 import { classifyGateFailure, describeGateFailure, gateFailureSummary } from "./gate-failure.js";
 import { propose, approve, liveReleaseOf, releaseCheckScope } from "./scope.js";
 import { headWithin } from "./names.js";
+import { recordExecClass } from "./route-store.js";
 /** The reasons tick classifies as the attempt itself breaking. */
 const TICK_FAILURE_REASONS = new Set([
     "agent",
@@ -247,6 +248,8 @@ function disposeBuildOutcomeLocked(context, result) {
             return { kind: "malformed", sealed: sealed.ok };
         }
         const outcome = STANDALONE_BROKE_REASONS.has(result.reason) ? "failed" : "refused";
+        if (outcome === "failed")
+            recordExecClass(store, runId, result.reason);
         store.finishRun(runId, { outcome, reason: result.reason, now: clock() });
         return { kind: "recorded", outcome };
     }
@@ -281,6 +284,9 @@ function disposeBuildOutcomeLocked(context, result) {
         return { kind: "handed-back", requeued: handed.requeued };
     }
     if (TICK_FAILURE_REASONS.has(result.reason)) {
+        // Results routing (v148): the raw reason's execution class, kept on the run before the mapping below folds
+        // timeouts and setup failures together (route-store.ts recordExecClass; first write wins).
+        recordExecClass(store, runId, result.reason);
         // One fenced transaction decides what the failure means. The
         // classification trusts only what the machine itself observed.
         const failureClass = result.reason === "agent-reported"