toolroll 0.9.91 → 0.9.92

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/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"

package/dist/flow-engine.js

@@ -507,7 +507,7 @@ export function revisionWithNote(store, card, target, note, actor, repos, eviden
         return null;
     const revised = requestResultChanges(store, evidenceRoot, {
         run: runId, source: revisionSourceOf(store.getScope(runTask)?.digest ?? null), actor, repos,
-        batch: "", note, path: "", line: "", request: `flow-${card.id}-${card.entry}`, allowMode: true,
+        batch: "", note, path: "", line: "", request: `flow-${card.id}-${card.entry}`, allowMode: true, origin: "flow",
     }, now);
     return revised.ok ? revised.id : null;
 }

package/dist/flow-pull-request.js

@@ -140,7 +140,7 @@ export async function pullRequestStep(store, flow, definition, stage, card, now,
             const runTask = store.externalIdFor(store.getRun(runId)?.taskRef ?? -1);
             const revised = runTask === null ? null : requestResultChanges(store, io.evidenceRoot, {
                 run: runId, source: revisionSourceOf(store.getScope(runTask)?.digest ?? null), actor: "toolroll", repos: [flow.repo], batch: "",
-                note: found?.note ?? said, path: "", line: "", allowMode: true,
+                note: found?.note ?? said, path: "", line: "", allowMode: true, origin: "flow",
                 request: createHash("sha256").update(`flow-ci ${card.id} ${card.entry} ${publication.id}`).digest("hex").slice(0, 32),
             }, now);
             if (revised?.ok === true)

package/dist/lead-doors.js

@@ -25,7 +25,7 @@ import { teamChatAuthorization, subscriptionTeamChatProvider } from './team-chat
 import { readProjectAccess } from "./project-access.js";
 import { TeamLeads } from './team-leads.js';
 import { fileTaskProposal } from "./proposal.js";
-import { proposeGuarded } from "./scope.js";
+import { machineActing, proposeGuarded } from "./scope.js";
 import { isTaskSize, PHASES, specWords } from "./phase-routing.js";
 import { isProviderId } from "./provider.js";
 import { applyChatReview } from "./chat-review.js";
@@ -377,7 +377,9 @@ function executeProposal(store, actor, kind, payload, now, options) {
         const request = payload;
         if (request.snapshot == null || request.snapshot.task !== taskId || (request.operation !== "note" && request.operation !== "revise"))
             return refuse("refused", "This feedback card is incomplete. Ask again.");
-        const result = applyChatReview(store, actor, options.evidenceRoot, request, now, options.via !== "cli");
+        // A review card is the lead's (or a coordinator's) proposal; a person confirming it here decided the result needs
+        // these changes, so the revision is theirs. Under the lead's own chain or a remote run nobody confirmed it: lead.
+        const result = applyChatReview(store, actor, options.evidenceRoot, request, now, options.via !== "cli", machineActing() ? "lead" : "person");
         return result.ok ? { ok: true, kind, taskId: result.taskId, said: result.said } : refuse("stale", result.message);
     }
     // The place the proposer saw must be the place the task holds now

package/dist/lead-tools.js

@@ -1,3 +1,4 @@
+import { rulesOf, ruleWords as earnedRuleWords, suggestionsFor, suggestionWords, trialOffersFor, trialOfferWords, trialsOf, trialWords } from "./route-rules.js";
 import { sameFeedbackImage } from "./result-review.js";
 import { sweepLine, sweepTable } from "./lead-sweep.js";
 import { connectionsOf, oneClickOf } from "./mcp-connect.js";
@@ -1602,7 +1603,7 @@ const LEAD_TOOL_HANDLERS = {
         },
     },
     get_models: {
-        description: "Default agent per role with the exact model each name runs now, installed CLI versions and updates, and models released in the last two weeks. Read-only; changes happen in Settings → Models.",
+        description: "Default agent per role with the exact model each name runs now, installed CLI versions and updates, models released in the last two weeks, and cheaper models your projects' own results suggest (with their earned rules), cheaper models to try and the trials in use. Read-only; accepting and starting a trial happen in Settings → Models; Not now is propose_action suggestion_not_now; stopping a trial is propose_action trial_stop.",
         handle: (ctx) => {
             const roles = ["plan", "build", "review", "repair"].map(phase => {
                 const row = ctx.store.phaseConfig(INSTALLATION_SCOPE, phase);
@@ -1610,7 +1611,14 @@ const LEAD_TOOL_HANDLERS = {
             });
             const tools = runtimeStates(ctx.store).map(one => ({ name: one.name, installed: one.installed, latest: one.latest, updateAvailable: one.behind }));
             const newModels = ["claude", "codex", "gemini"].flatMap(source => seenModels(ctx.store, source)).filter(model => isNewModel(model, ctx.now)).map(model => ({ name: model.name, id: model.id, price: priceWords(model), released: model.releasedAt }));
-            return { ok: true, body: { roles, tools, newModels, change: "/settings/models" } };
+            // Results routing: the same suggestions and rules Settings → Models and `toolroll models suggestions` show.
+            const suggestions = ctx.who.repos.flatMap(repo => suggestionsFor(ctx.store, repo, ctx.now)).map(one => ({ id: one.id, repo: one.repo, words: suggestionWords(one),
+                review: `/settings/models?scope=${encodeURIComponent(one.repo)}&suggestion=${encodeURIComponent(one.id)}#models-suggested` }));
+            const rules = ctx.who.repos.flatMap(repo => rulesOf(ctx.store, repo, ctx.now)).map(one => ({ id: one.id, repo: one.repo, state: one.state, words: earnedRuleWords(ctx.store, one) }));
+            const trialOffers = ctx.who.repos.flatMap(repo => trialOffersFor(ctx.store, repo, ctx.now)).map(one => ({ id: one.id, repo: one.repo, words: trialOfferWords(one),
+                start: `/settings/models?scope=${encodeURIComponent(one.repo)}#models-suggested` }));
+            const trials = ctx.who.repos.flatMap(repo => trialsOf(ctx.store, repo, ctx.now)).map(one => ({ id: one.id, repo: one.repo, state: one.state, words: trialWords(ctx.store, one) }));
+            return { ok: true, body: { roles, tools, newModels, suggestions, rules, trialOffers, trials, change: "/settings/models" } };
         },
     },
     list_tasks: {

package/dist/local-owner.d.ts

@@ -10,7 +10,7 @@ export declare function authorityOf(value: unknown): Authority | null;
  * The acts a local owner may do (plan C1). Ids only: each surface (a route row, a chat action, a CLI command) names
  * the act it is, and an act not in this list is refused to a local owner.
  */
-export declare const LOCAL_OWNER_ACTS: readonly ["file-task", "lead-send", "approve-plan", "answer-question", "stop-run", "pause-run", "resume-run", "complete-task", "request-revision", "archive-task", "add-project", "choose-default-agent", "mark-seen", "watch-agent", "read"];
+export declare const LOCAL_OWNER_ACTS: readonly ["file-task", "lead-send", "approve-plan", "answer-question", "stop-run", "pause-run", "resume-run", "complete-task", "request-revision", "archive-task", "add-project", "choose-default-agent", "mark-seen", "watch-agent", "read", "routing-turn-off", "dismiss-suggestion", "trial-stop"];
 export type LocalOwnerAct = (typeof LOCAL_OWNER_ACTS)[number];
 /** Whether a runtime string names an act a local owner may do. */
 export declare function localOwnerAct(value: unknown): value is LocalOwnerAct;

package/dist/local-owner.js

@@ -32,6 +32,13 @@ export const LOCAL_OWNER_ACTS = Object.freeze([
     "mark-seen",
     "watch-agent",
     "read",
+    // Results routing (docs/plans/results-routing.md, Authority): lowering only — turning an earned rule off (or
+    // dropping a paused one), and saying Not now to a suggestion (or switching suggestions off). The writer
+    // (route-store.ts proveRuleDoor) checks the in-flight act is exactly the one it needs.
+    "routing-turn-off",
+    "dismiss-suggestion",
+    // Slice 3: stopping a trial of a cheaper model only lowers (proveRuleDoor checks this exact act).
+    "trial-stop",
 ]);
 const ACT_SET = new Set(LOCAL_OWNER_ACTS);
 /** Whether a runtime string names an act a local owner may do. */
@@ -150,6 +157,10 @@ export const CHAT_ACTION_LOCAL_ACTS = Object.freeze({
     subagent_create: null, subagent_soul: null, subagent_state: null, subagent_note: null, subagent_ask: null,
     subagent_answer: null, subagent_tools: null, subagent_memory: null, subagent_routine: null, subagent_undo: null,
     kit_setup: null, decision_record: null, decision_retire: null, lead_about_you: null,
+    // Results routing: Not now only lowers (the rule door checks this exact act).
+    suggestion_not_now: "dismiss-suggestion",
+    // Stopping a trial only lowers (the rule door checks this exact act).
+    trial_stop: "trial-stop",
     scope_approve: "approve-plan",
     result_accept: "complete-task",
     task_cancel: "stop-run",

package/dist/memory-cli.d.ts

@@ -200,6 +200,7 @@ export declare const MEMORY_DESCRIPTORS: readonly [{
         readonly takesValue: false;
         readonly meaning: 'read only the plane\'s own transcripts, not local Claude Code or Codex session files';
     }];
+    readonly audience: 'operator';
 }, {
     readonly action: 'retire';
     readonly synopsis: 'retire a decision that no longer holds: memory retire <id> --reason "<why>"';
@@ -250,6 +251,7 @@ export declare const MEMORY_DESCRIPTORS: readonly [{
         readonly takesValue: false;
         readonly meaning: 'read only the plane\'s own transcripts, not local Claude Code or Codex session files';
     }];
+    readonly audience: 'operator';
 }, {
     readonly action: 'propose';
     readonly synopsis: 'the backward pass: read recent sessions, keep a ledger of evidenced gaps, propose a few edits (writes nothing to memory)';
@@ -400,6 +402,7 @@ export declare const MEMORY_DESCRIPTORS: readonly [{
         readonly takesValue: false;
         readonly meaning: 'read only the plane\'s own transcripts, not local Claude Code or Codex session files';
     }];
+    readonly audience: 'operator';
 }, {
     readonly action: 'status';
     readonly synopsis: 'surface version, instruction budget, sessions analysed, open gaps and pending proposals';