toolroll 0.9.91 → 0.9.93

package/dist/model-choices.js

@@ -14,6 +14,7 @@ import { INSTALLATION_SCOPE, resolvePhaseAgent, resolveRouteCandidates } from ".
 import { seenModels } from "./model-catalog.js";
 import { passwordlessOn } from "./passwordless.js";
 import { exactModelId, recommendRoute, routeProblems } from "./phase-routing.js";
+import { liveEarnedRules } from "./route-store.js";
 import { isProviderId, validateSpec } from "./provider.js";
 /** Every row the editor owns, in the order the page and the diff show them. Alternates (`--also`) and the strong
  * repair row stay CLI-only; presets clear the strong repair row so repairs follow the builder. */
@@ -120,24 +121,29 @@ export const ROUTE_CASES = Object.freeze([
     { label: "large", size: "large", risky: false, strict: false }, { label: "risky", size: "small", risky: true, strict: false },
     { label: "strict", size: "medium", risky: false, strict: true },
 ]);
-export function effectiveRoutes(store, repo) {
+export function effectiveRoutes(store, repo, options = {}) {
     const candidates = resolveRouteCandidates(store, repo);
     if (!candidates.ok)
         return { ok: false, problem: candidates.problem };
-    return { ok: true, routes: routesOf(candidates.candidates) };
+    // A project's live earned rules route its eligible small and routine tasks (the one precedence order,
+    // phase-routing.ts selectBuildLeg); `rules: false` asks for the configured rows alone.
+    const rules = options.rules === false ? [] : options.rules ?? liveEarnedRules(store, repo);
+    return { ok: true, routes: routesOf(candidates.candidates, rules) };
 }
-/** Every size's and demand's route over these candidates. (A build moved to another provider for plan headroom takes
- * its repairs with it, so that move can't break a repair; a tier whose only candidate is another provider's is its
- * primary here, and checked.) */
-function routesOf(candidates) {
+/** Every size's and demand's route over these candidates, with a project's earned rules where they apply. (A build
+ * moved to another provider for plan headroom takes its repairs with it, so that move can't break a repair; a tier
+ * whose only candidate is another provider's is its primary here, and checked.) */
+function routesOf(candidates, rules = []) {
     const routes = ROUTE_CASES.map(one => ({ label: one.label, route: recommendRoute({ qualityMode: one.strict ? "strict" : "default", evidence: [], publication: "none",
-            candidates, overrides: [], size: { size: one.size, risky: one.risky, source: "heuristic", reason: "" } }) }));
+            candidates, overrides: [], size: { size: one.size, risky: one.risky, source: "heuristic", reason: "" },
+            earned: rules.length === 0 ? null : { rules, release: false, protected: false } }) }));
     return routes;
 }
 /** Which preset a scope's EFFECTIVE configuration matches (what each size would really run, inherited rows
  * included), or null ("a custom set"). */
 export function presetInUse(store, scope) {
-    const effective = effectiveRoutes(store, scope === INSTALLATION_SCOPE ? null : scope);
+    // The configured rows, not a project's earned rules: a rule never edits the owner's Models rows.
+    const effective = effectiveRoutes(store, scope === INSTALLATION_SCOPE ? null : scope, { rules: false });
     if (!effective.ok)
         return null;
     const legs = (label) => effective.routes.find(one => one.label === label).route.legs;
@@ -224,13 +230,22 @@ function projectsWithRows(store) {
  * or a route of any size or demand (small, routine, large, risky, strict) whose repair can't resume its builder,
  * inherited rows included. An invalid result is never saved.
  */
-export function checkScope(store, repo) {
+export function checkScope(store, repo, options = {}) {
     const build = resolvePhaseAgent(store, "build", repo, {});
     if (!build.ok)
         return { kind: "invalid", problem: build.problem };
     const plan = resolvePhaseAgent(store, "plan", repo, {});
     if (!plan.ok)
         return { kind: "invalid", problem: plan.problem };
+    // Every live earned rule's route is checked with the configured ones (results routing): a rule's builder must
+    // share any configured repair row's provider, since repairs resume the builder's session. `rules` is the set to
+    // check (an acceptance adds its candidate rule); by default the project's live rules.
+    const rules = options.rules ?? liveEarnedRules(store, repo);
+    const repairRow = (repo === null ? null : store.phaseConfig(repo, "repair")) ?? store.phaseConfig(INSTALLATION_SCOPE, "repair");
+    for (const rule of rules) {
+        if (repairRow !== null && repairRow.provider !== rule.provider)
+            return { kind: "invalid", problem: `Repairs must use the builder's provider (${rule.provider}): an earned rule builds ${rule.cohortSize === "small" ? "small" : "routine"} tasks on it.` };
+    }
     // The reviewer is not checked here: an unset reviewer follows the planner, and routing deliberately never lets a
     // reviewer setting stop a task from planning or building (agentconfig.ts resolveRouteCandidates; that leg never
     // runs). So a Gemini planner with no reviewer of its own stays a valid configuration. A reviewer row written here is
@@ -244,12 +259,12 @@ export function checkScope(store, repo) {
     const configured = resolveRouteCandidates(store, repo, { plan: standIn(plan.spec), build: standIn(build.spec) });
     if (!configured.ok)
         return { kind: /has no exact model/.test(configured.problem) ? "incomplete" : "invalid", problem: configured.problem };
-    for (const route of routesOf(configured.candidates)) {
+    for (const route of routesOf(configured.candidates, rules)) {
         const problems = routeProblems(route.route);
         if (problems.length > 0)
             return { kind: "invalid", problem: `${route.label} tasks: ${problems[0]}` };
     }
-    const effective = effectiveRoutes(store, repo);
+    const effective = effectiveRoutes(store, repo, { rules });
     if (!effective.ok)
         return { kind: /has no exact model/.test(effective.problem) ? "incomplete" : "invalid", problem: effective.problem };
     return { kind: "ok" };

package/dist/models-cli.d.ts

@@ -90,7 +90,207 @@ export declare const MODELS_DESCRIPTORS: readonly [{
         readonly takesValue: true;
         readonly meaning: "local Toolroll database";
     }];
+}, {
+    readonly action: "results";
+    readonly synopsis: "each finished task's result record: which model built it, and whether it counts";
+    readonly mutation: "none";
+    readonly takesQuery: false;
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "one project's records (default: every project you can open)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
+}, {
+    readonly action: "suggestions";
+    readonly synopsis: "cheaper models a project's own results suggest, and its earned rules";
+    readonly mutation: "none";
+    readonly takesQuery: false;
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "one project's records (default: every project you can open)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
+}, {
+    readonly action: "accept";
+    readonly synopsis: "accept a suggestion as an earned rule, with its switch-back terms: models accept <id> --repo <p>";
+    readonly mutation: "unkeyed";
+    readonly takesQuery: true;
+    readonly positional: "the suggestion's id, as models suggestions lists it";
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "the project (default: the one project you can open)";
+    }, {
+        readonly name: "as";
+        readonly takesValue: true;
+        readonly meaning: "your approver name";
+    }, {
+        readonly name: "token";
+        readonly takesValue: true;
+        readonly meaning: "your password (accepting and keeping take one typed now)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
+}, {
+    readonly action: "dismiss";
+    readonly synopsis: "Not now: keep a suggestion quiet for 30 days: models dismiss <id> --repo <p>";
+    readonly mutation: "unkeyed";
+    readonly takesQuery: true;
+    readonly positional: "the suggestion's id, as models suggestions lists it";
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "the project (default: the one project you can open)";
+    }, {
+        readonly name: "as";
+        readonly takesValue: true;
+        readonly meaning: "your approver name";
+    }, {
+        readonly name: "token";
+        readonly takesValue: true;
+        readonly meaning: "your password (accepting and keeping take one typed now)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
+}, {
+    readonly action: "turn-off";
+    readonly synopsis: "turn an earned rule off, or drop a paused one: models turn-off <rule>";
+    readonly mutation: "unkeyed";
+    readonly takesQuery: true;
+    readonly positional: "the rule's number, as models suggestions lists it";
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "the project (default: the one project you can open)";
+    }, {
+        readonly name: "as";
+        readonly takesValue: true;
+        readonly meaning: "your approver name";
+    }, {
+        readonly name: "token";
+        readonly takesValue: true;
+        readonly meaning: "your password (accepting and keeping take one typed now)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
+}, {
+    readonly action: "keep";
+    readonly synopsis: "keep a paused earned rule: models keep <rule>";
+    readonly mutation: "unkeyed";
+    readonly takesQuery: true;
+    readonly positional: "the rule's number, as models suggestions lists it";
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "the project (default: the one project you can open)";
+    }, {
+        readonly name: "as";
+        readonly takesValue: true;
+        readonly meaning: "your approver name";
+    }, {
+        readonly name: "token";
+        readonly takesValue: true;
+        readonly meaning: "your password (accepting and keeping take one typed now)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
+}, {
+    readonly action: "try";
+    readonly synopsis: "try a cheaper model on the next 10 small or routine tasks, each approved by a person: models try <id> --repo <p>";
+    readonly mutation: "unkeyed";
+    readonly takesQuery: true;
+    readonly positional: "the trial offer's id, as models suggestions lists it";
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "the project (default: the one project you can open)";
+    }, {
+        readonly name: "as";
+        readonly takesValue: true;
+        readonly meaning: "your approver name";
+    }, {
+        readonly name: "token";
+        readonly takesValue: true;
+        readonly meaning: "your password (accepting and keeping take one typed now)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
+}, {
+    readonly action: "stop";
+    readonly synopsis: "stop a trial; tasks already approved on it keep their model: models stop <trial>";
+    readonly mutation: "unkeyed";
+    readonly takesQuery: true;
+    readonly positional: "the trial's number, as models suggestions lists it";
+    readonly flags: readonly [{
+        readonly name: "repo";
+        readonly takesValue: true;
+        readonly meaning: "the project (default: the one project you can open)";
+    }, {
+        readonly name: "as";
+        readonly takesValue: true;
+        readonly meaning: "your approver name";
+    }, {
+        readonly name: "token";
+        readonly takesValue: true;
+        readonly meaning: "your password (accepting and keeping take one typed now)";
+    }, {
+        readonly name: "json";
+        readonly takesValue: false;
+        readonly meaning: "versioned structured response";
+    }, {
+        readonly name: "db";
+        readonly takesValue: true;
+        readonly meaning: "local Toolroll database";
+    }];
 }];
+/** `proof`: the person who proved themselves for this command — at the credential generation read before the proof,
+ * and how — or null. The rule doors re-prove it inside their own transaction. */
 export type ModelsCliContext = {
     store: Store;
     write: (line: string) => void;
@@ -98,5 +298,10 @@ export type ModelsCliContext = {
     now: Date;
     actor: string | null;
     seams?: CatalogSeams;
+    proof?: {
+        actor: string;
+        generation: number;
+        method: string;
+    } | null;
 };
 export declare function runModelsCommand(positional: readonly string[], options: Map<string, string | true>, context: ModelsCliContext): Promise<number>;

package/dist/models-cli.js

@@ -3,17 +3,44 @@
 import { envelopeJson } from "./envelope.js";
 import { checkModels, isNewModel, modelOptions, priceWords, RUNTIME_TOOLS, runtimeStates, seenModels, setWatch, updateRuntime, watchState } from "./model-catalog.js";
 import { isProviderId } from "./provider.js";
+import { canonicalProject } from "./project.js";
+import { resultRecords } from "./route-results.js";
+import { acceptSuggestion, dismissSuggestion, grantWords, keepRule, ruleById, ruleWords, rulesOf, startTrial, stopTrial, suggestionsFor, suggestionWords, trialOffersFor, trialOfferWords, trialsOf, trialWords, turnOffRule } from "./route-rules.js";
+import { trialPlacesOf } from "./route-store.js";
+import { currentLocalOwner } from "./local-owner.js";
+import { REASON_WORDS } from "./contracts/route-results.js";
+import { resolve } from "node:path";
 const flags = [
     { name: "provider", takesValue: true, meaning: "claude, codex, gemini or openrouter, for models list" },
     { name: "json", takesValue: false, meaning: "versioned structured response" },
     { name: "db", takesValue: true, meaning: "local Toolroll database" },
 ];
+const resultFlags = [
+    { name: "repo", takesValue: true, meaning: "one project's records (default: every project you can open)" },
+    { name: "json", takesValue: false, meaning: "versioned structured response" },
+    { name: "db", takesValue: true, meaning: "local Toolroll database" },
+];
+const ruleFlags = [
+    { name: "repo", takesValue: true, meaning: "the project (default: the one project you can open)" },
+    { name: "as", takesValue: true, meaning: "your approver name" },
+    { name: "token", takesValue: true, meaning: "your password (accepting and keeping take one typed now)" },
+    { name: "json", takesValue: false, meaning: "versioned structured response" },
+    { name: "db", takesValue: true, meaning: "local Toolroll database" },
+];
 export const MODELS_DESCRIPTORS = [
     { action: "status", synopsis: "installed CLI versions, available updates, new models and the automatic check", mutation: "none", takesQuery: false, flags },
     { action: "list", synopsis: "models a provider can run, newest first, with prices (--provider claude|codex|gemini|openrouter)", mutation: "none", takesQuery: false, flags },
     { action: "check", synopsis: "fetch the public model lists and check CLI versions now", mutation: "unkeyed", takesQuery: false, flags },
     { action: "update", synopsis: "update one CLI while no work is running: models update claude|codex|gemini", mutation: "unkeyed", takesQuery: true, flags },
     { action: "watch", synopsis: "turn the 6-hourly check and its messages on or off: models watch on|off", mutation: "unkeyed", takesQuery: true, flags },
+    { action: "results", synopsis: "each finished task's result record: which model built it, and whether it counts", mutation: "none", takesQuery: false, flags: resultFlags },
+    { action: "suggestions", synopsis: "cheaper models a project's own results suggest, and its earned rules", mutation: "none", takesQuery: false, flags: resultFlags },
+    { action: "accept", synopsis: "accept a suggestion as an earned rule, with its switch-back terms: models accept <id> --repo <p>", mutation: "unkeyed", takesQuery: true, positional: "the suggestion's id, as models suggestions lists it", flags: ruleFlags },
+    { action: "dismiss", synopsis: "Not now: keep a suggestion quiet for 30 days: models dismiss <id> --repo <p>", mutation: "unkeyed", takesQuery: true, positional: "the suggestion's id, as models suggestions lists it", flags: ruleFlags },
+    { action: "turn-off", synopsis: "turn an earned rule off, or drop a paused one: models turn-off <rule>", mutation: "unkeyed", takesQuery: true, positional: "the rule's number, as models suggestions lists it", flags: ruleFlags },
+    { action: "keep", synopsis: "keep a paused earned rule: models keep <rule>", mutation: "unkeyed", takesQuery: true, positional: "the rule's number, as models suggestions lists it", flags: ruleFlags },
+    { action: "try", synopsis: "try a cheaper model on the next 10 small or routine tasks, each approved by a person: models try <id> --repo <p>", mutation: "unkeyed", takesQuery: true, positional: "the trial offer's id, as models suggestions lists it", flags: ruleFlags },
+    { action: "stop", synopsis: "stop a trial; tasks already approved on it keep their model: models stop <trial>", mutation: "unkeyed", takesQuery: true, positional: "the trial's number, as models suggestions lists it", flags: ruleFlags },
 ];
 export async function runModelsCommand(positional, options, context) {
     const action = positional[0] ?? "status";
@@ -21,10 +48,20 @@ export async function runModelsCommand(positional, options, context) {
     const fail = (reason, message) => { context.write(context.json ? envelopeJson({ ok: false, command, reason, message }) : message); return reason === "usage" ? 2 : 1; };
     const ok = (result, lines) => { context.write(context.json ? envelopeJson({ ok: true, command, ...result }) : lines.join("\n")); return 0; };
     if (!MODELS_DESCRIPTORS.some(one => one.action === action))
-        return fail("usage", "Use models status | list --provider <p> | check | update <claude|codex|gemini> | watch on|off.");
-    if (context.actor === null)
+        return fail("usage", "Use models status | list --provider <p> | check | update <claude|codex|gemini> | watch on|off | results | suggestions | accept <id> | dismiss <id> | turn-off <rule> | keep <rule> | try <id> | stop <trial>.");
+    // This computer's local owner (local mode, through the terminal UI) may turn a rule off and say Not now: the door
+    // re-checks that its in-flight act is exactly that one.
+    const local = currentLocalOwner();
+    if (context.actor === null && !(local !== null && (action === "turn-off" || action === "dismiss" || action === "suggestions" || action === "stop")))
         return fail("unauthenticated", "Sign in first: the remembered local login drives models commands.");
     const { store, now } = context;
+    if (action === "results")
+        return modelsResults(options, context, ok, fail);
+    if (action === "suggestions" || action === "accept" || action === "dismiss" || action === "turn-off" || action === "keep" || action === "try" || action === "stop")
+        return modelsRules(action, positional, options, { ...context, actor: context.actor ?? local.account }, ok, fail, local !== null && context.proof == null);
+    const actor = context.actor;
+    if (actor === null)
+        return fail("unauthenticated", "Sign in first: the remembered local login drives models commands.");
     if (action === "status") {
         const runtimes = runtimeStates(store), watch = watchState(store);
         const fresh = ["claude", "codex", "gemini"].flatMap(source => seenModels(store, source)).filter(model => isNewModel(model, now));
@@ -55,12 +92,114 @@ export async function runModelsCommand(positional, options, context) {
         const tool = positional[1] ?? "";
         if (!(tool in RUNTIME_TOOLS))
             return fail("usage", "Name one CLI: models update claude|codex|gemini.");
-        const updated = await updateRuntime(store, tool, context.actor, now, context.seams);
+        const updated = await updateRuntime(store, tool, actor, now, context.seams);
         return updated.ok ? ok({ tool, message: updated.message }, [updated.message]) : fail("refused", updated.message);
     }
     const wanted = positional[1];
     if (wanted !== "on" && wanted !== "off")
         return fail("usage", "Use models watch on or models watch off.");
-    setWatch(store, wanted === "on", context.actor, now);
+    setWatch(store, wanted === "on", actor, now);
     return ok({ enabled: wanted === "on" }, [wanted === "on" ? "Automatic checks are on: every 6 hours, with a message for each new model or CLI update." : "Automatic checks are off."]);
 }
+/** `models results [--repo <p>]`: the saved result records of the projects this person can open, newest first — the
+ * same records the task page's "Result record" line reads. Read-only. */
+function modelsResults(options, context, ok, fail) {
+    const { store } = context;
+    for (const key of options.keys())
+        if (!["repo", "json", "db", "as", "token", "token-file", "token-env"].includes(key))
+            return fail("usage", `--${key} is not a models results option.`);
+    const open = store.knownRepos().filter(repo => store.accountCanAccess(context.actor, repo));
+    const asked = options.get("repo");
+    if (asked === true)
+        return fail("usage", "--repo takes a project path.");
+    const wanted = asked === undefined ? null : canonicalProject(asked) ?? resolve(asked);
+    if (wanted !== null && !open.includes(wanted))
+        return fail("refused", "That project isn't one you can open here.");
+    const records = resultRecords(store, wanted === null ? open : [wanted]);
+    const counted = (state) => records.filter(one => one.state === state).length;
+    const summary = `${records.length} record${records.length === 1 ? "" : "s"}: ${counted("mature")} counted, ${counted("rejected")} counted against, ${counted("provisional")} accepted and waiting, ${counted("pending")} pending, ${counted("not-counted")} not counted`;
+    return ok({ records, reasons: REASON_WORDS }, records.length === 0
+        ? ["No result records yet. A record starts when a task's first build runs."]
+        : [summary, ...records.map(one => `${one.task} · ${one.model ?? "unknown model"}${one.size === null ? "" : ` · ${one.size}`} · ${one.words}`)]);
+}
+/**
+ * Earned rules on the command line (docs/plans/results-routing.md, slice 2), the same doors Settings → Models uses:
+ * `suggestions` reads; `accept` and `keep` take the person's own proof, re-proved inside the write (a lead token or a
+ * remote token is refused there); `turn-off` and `dismiss` take the person, or this computer's local owner inside
+ * exactly that act.
+ */
+function modelsRules(action, positional, options, context, ok, fail, asLocal) {
+    const { store, now } = context;
+    const allowed = action === "suggestions" ? ["repo", "json", "db", "as", "token", "token-file", "token-env"] : ["repo", "json", "db", "as", "token", "token-file", "token-env"];
+    for (const key of options.keys())
+        if (!allowed.includes(key))
+            return fail("usage", `--${key} is not a models ${action} option.`);
+    const open = store.knownRepos().filter(repo => store.accountCanAccess(context.actor, repo));
+    const asked = options.get("repo");
+    if (asked === true)
+        return fail("usage", "--repo takes a project path.");
+    const wanted = asked === undefined ? null : canonicalProject(asked) ?? resolve(asked);
+    if (wanted !== null && !open.includes(wanted))
+        return fail("refused", "That project isn't one you can open here.");
+    if (action === "suggestions") {
+        const repos = wanted === null ? open : [wanted];
+        const suggestions = repos.flatMap(repo => suggestionsFor(store, repo, now));
+        const rules = repos.flatMap(repo => rulesOf(store, repo, now));
+        const trialOffers = repos.flatMap(repo => trialOffersFor(store, repo, now));
+        const trials = repos.flatMap(repo => trialsOf(store, repo, now));
+        return ok({
+            suggestions: suggestions.map(one => ({ id: one.id, repo: one.repo, size: one.cohortSize, model: one.model, name: one.name, configured: one.configured,
+                evidence: one.evidence, configuredEvidence: one.configuredEvidence, prices: one.prices, terms: grantWords(one.grant), words: suggestionWords(one) })),
+            rules: rules.map(one => ({ id: one.id, repo: one.repo, size: one.cohortSize, model: one.model, configured: one.configured, state: one.state, acceptedAt: one.acceptedAt,
+                acceptedBy: one.acceptedBy, expires: one.grant?.expires ?? null, endedAt: one.endedAt, endReason: one.endReason, words: ruleWords(store, one) })),
+            // Slice 3: cheaper models to try where results don't yet suggest one, and the trials in use.
+            trialOffers: trialOffers.map(one => ({ id: one.id, repo: one.repo, size: one.cohortSize, model: one.model, name: one.name, configured: one.configured,
+                evidence: one.evidence, configuredEvidence: one.configuredEvidence, prices: one.prices, places: one.places, words: trialOfferWords(one) })),
+            trials: trials.map(one => ({ id: one.id, repo: one.repo, size: one.cohortSize, model: one.model, configured: one.configured, state: one.state, startedAt: one.acceptedAt,
+                startedBy: one.acceptedBy, endedAt: one.endedAt, endReason: one.endReason, places: trialPlacesOf(store, one.id), words: trialWords(store, one) })),
+        }, suggestions.length === 0 && rules.length === 0 && trialOffers.length === 0 && trials.length === 0 ? ["No suggestions yet. A cheaper model is suggested once its results here match the configured one's."] : [
+            ...suggestions.flatMap(one => [`Suggested · ${one.repo} · ${suggestionWords(one)}`, `  accept: toolroll models accept ${one.id} --repo ${one.repo}`, `  not now: toolroll models dismiss ${one.id} --repo ${one.repo}`]),
+            ...rules.map(one => `Rule ${one.id} · ${one.repo} · ${ruleWords(store, one)}`),
+            ...trialOffers.flatMap(one => [`Try · ${one.repo} · ${trialOfferWords(one)}`, `  try: toolroll models try ${one.id} --repo ${one.repo}`, `  not now: toolroll models dismiss ${one.id} --repo ${one.repo}`]),
+            ...trials.map(one => `Trial ${one.id} · ${one.repo} · ${trialWords(store, one)}`),
+        ]);
+    }
+    const target = positional[1];
+    if (target === undefined || positional.length !== 2)
+        return fail("usage", action === "accept" || action === "dismiss" || action === "try" ? `Name one offer: models ${action} <id> --repo <p>.` : action === "stop" ? "Name one trial: models stop <trial>." : `Name one rule: models ${action} <rule>.`);
+    const proof = context.proof ?? null;
+    const door = proof !== null ? { kind: "person", person: { ...proof, live: () => true } } : asLocal ? { kind: "local-owner", actor: context.actor } : null;
+    if (door === null)
+        return fail("unauthenticated", "This takes your own sign-in: --as <you> --token <password>.");
+    const said = (result, payload, line) => result.ok ? ok(payload, [line]) : fail("refused", result.problem);
+    if (action === "accept" || action === "dismiss" || action === "try") {
+        const repo = wanted ?? (open.length === 1 ? open[0] : null);
+        if (repo === null)
+            return fail("usage", "Name the project: --repo <p>.");
+        if (action === "try") {
+            const started = startTrial(store, { repo, id: target }, door, now);
+            return started.ok ? ok({ trial: started.trial, repo, model: started.offer.model, size: started.offer.cohortSize, places: started.offer.places }, [`Trial ${started.trial}: the next ${started.offer.places} ${started.offer.cohortSize === "small" ? "small" : "routine"} tasks try ${started.offer.name}. Each waits for a person's approval.`]) : fail("refused", started.problem);
+        }
+        if (action === "accept") {
+            const accepted = acceptSuggestion(store, { repo, id: target }, door, now);
+            return accepted.ok ? ok({ rule: accepted.rule, repo, model: accepted.suggestion.model, size: accepted.suggestion.cohortSize, terms: grantWords(accepted.suggestion.grant) }, [`Rule ${accepted.rule}: ${suggestionWords(accepted.suggestion)}`, ...grantWords(accepted.suggestion.grant).map(line => `  ${line}`)]) : fail("refused", accepted.problem);
+        }
+        return said(dismissSuggestion(store, { repo, id: target }, door, now), { repo, id: target }, "Not now: this suggestion stays quiet for 30 days.");
+    }
+    const id = /^[1-9][0-9]{0,9}$/.test(target) ? Number(target) : null;
+    const rule = id === null ? null : ruleById(store, id);
+    if (action === "stop") {
+        if (rule === null || rule.kind !== "trial" || !open.includes(rule.repo))
+            return fail("refused", "That trial isn't one you can see here.");
+        const stopped = stopTrial(store, rule.id, door, now);
+        return stopped.ok ? ok({ trial: stopped.trial.id, state: stopped.trial.state }, [`Trial ${stopped.trial.id} stopped. Tasks already approved on it keep their model.`]) : fail("refused", stopped.problem);
+    }
+    if (rule === null || rule.kind !== "rule" || !open.includes(rule.repo))
+        return fail("refused", "That rule isn't one you can see here.");
+    if (action === "turn-off") {
+        const turned = turnOffRule(store, rule.id, door, now);
+        return turned.ok ? ok({ rule: turned.rule.id, state: turned.rule.state }, [`Rule ${turned.rule.id} is off. Tasks already approved keep the model they were approved with.`]) : fail("refused", turned.problem);
+    }
+    const kept = keepRule(store, rule.id, door, now);
+    return kept.ok ? ok({ rule: kept.rule.id, state: kept.rule.state }, [`Rule ${kept.rule.id} is on again: ${ruleWords(store, kept.rule)}`]) : fail("refused", kept.problem);
+}

package/dist/models-ui.d.ts

@@ -98,6 +98,63 @@ export type ModelsView = {
     }[];
     /** What this request's approval shows (approvalFactsNow): a step-up asks for the password unless Passwordless is on. */
     facts?: ApprovalFacts;
+    /** Results routing (slice 2): cheaper models this project's own results suggest, its earned rules, its switch. */
+    suggested?: SuggestedView;
+};
+/** The Suggested group: offers, a reviewed offer, the project's rules, and its "Suggest cheaper models" switch. */
+export type SuggestedView = {
+    /** The project shown, or null on the installation scope (offers from every project, each reviewed on its own). */
+    repo: string | null;
+    offers: {
+        id: string;
+        repo: string;
+        project: string;
+        title: string;
+        words: string;
+    }[];
+    /** "Review change": the evidence, the switch-back terms and the step-up save; `stale` when the offer reviewed is
+     * no longer the one on offer. */
+    review: {
+        id: string;
+        repo: string;
+        title: string;
+        evidence: string[];
+        prices: string;
+        terms: string[];
+        save: string;
+    } | {
+        stale: true;
+        repo: string;
+    } | null;
+    rules: {
+        id: number;
+        repo: string;
+        project: string;
+        title: string;
+        words: string;
+        state: "active" | "paused" | "ended";
+    }[];
+    /** The project's switch (null on the installation scope). */
+    suggest: {
+        on: boolean;
+    } | null;
+    /** Slice 3: cheaper models to try on the next few tasks (a step-up starts one), and the trials in use (Stop). */
+    trialOffers?: {
+        id: string;
+        repo: string;
+        project: string;
+        title: string;
+        words: string;
+        save: string;
+    }[];
+    trials?: {
+        id: number;
+        repo: string;
+        project: string;
+        title: string;
+        words: string;
+        live: boolean;
+    }[];
 };
 export declare function modelsHtml(view: ModelsView): Html;
 /** Filters one long picker as you type; the saved choice always stays listed. */

package/dist/models-ui.js

@@ -59,7 +59,7 @@ ${formRow("Automatic checks", `${view.watch.enabled ? "On" : "Off"}. Every 6 hou
         : note(`Checked ${when(view.watch.checkedAt)}.`);
     const fresh = view.fresh.length === 0 ? "" : sec("new", "New models", "", view.fresh.map(model => formRow(model.name, `${priceWords(model)}${model.releasedAt === null ? "" : ` · released ${model.releasedAt.slice(0, 10)}`}`, chip("New", "", { dot: false }), "inline")));
     const chat = view.chat === null ? "" : formRow("Chat", view.chat.words, btn("Change", { sm: true, variant: "ghost", href: "/settings/lead" }), "inline");
-    const body = html `<div class="models">${outcome}${preview}${choiceSection(view, manage, previewing)}${recentSection(view)}${sec("tools", "AI tools on this computer", "", html `${tools}${checks}`)}${fresh}${chat}</div>`;
+    const body = html `<div class="models">${outcome}${preview}${choiceSection(view, manage, previewing)}${suggestedSection(view)}${recentSection(view)}${sec("tools", "AI tools on this computer", "", html `${tools}${checks}`)}${fresh}${chat}</div>`;
     return settingsShell({ group: "agents", sub: true, title: "Models", lead: "Which model plans, builds and reviews each task. Changes apply to tasks filed from now on.", body });
 }
 /** Filters one long picker as you type; the saved choice always stays listed. */
@@ -123,3 +123,46 @@ function recentSection(view) {
         return "";
     return sec("recent", "Recent work", "", view.recent.map(one => formRow(one.role, `Chosen ${one.chosen} → ran on ${one.ranOn}`, html `<a class="k-link k-mono" href="/t/${encodeURIComponent(one.taskId)}">${one.taskId}</a>`, "inline")));
 }
+/** Settings → Models → Suggested (docs/plans/results-routing.md slice 2): what a project's own results suggest, each
+ * reviewed before it's saved with a step-up; the rules in force with Turn off (Keep or Drop when paused); and the
+ * project's "Suggest cheaper models" switch. Turning off and Not now only take authority away: no password. */
+function suggestedSection(view) {
+    const s = view.suggested;
+    if (s === undefined)
+        return "";
+    const manage = view.csrf !== "";
+    const scoped = (repo) => `/settings/models?scope=${encodeURIComponent(repo)}`;
+    const review = s.review === null ? ""
+        : "stale" in s.review
+            ? html `${notice("This suggestion is out of date: its results, a price or Models changed since. Nothing was saved.")}${acts(btn("Back", { sm: true, href: `${scoped(s.review.repo)}#models-suggested` }))}`
+            : html `<div class="models-diff">${factList([
+                ["Change", s.review.title],
+                ["Evidence", html `${s.review.evidence.map(line => html `<span>${line}</span><br>`)}`],
+                ["Prices", s.review.prices],
+                ["Switches back", html `${s.review.terms.map(line => html `<span>${line}</span><br>`)}`],
+            ])}${manage ? postForm("/settings/models/accept", html `${note(`Every task is still approved, and keeps the model it was approved with. ${termsOf("step-up", factsOf(view))}`)}${password(view, "models-accept-pw")}${acts(btn(s.review.save, { variant: "primary", type: "submit" }), btn("Cancel", { variant: "ghost", href: `${scoped(s.review.repo)}#models-suggested` }))}`, { hidden: { scope: s.review.repo, id: s.review.id }, attrs: { class: "models-editor" } }) : ""}</div>`;
+    const offers = s.offers.map(one => formRow(s.repo === null ? `${one.title} · ${one.project}` : one.title, one.words, manage
+        ? acts(btn("Review change", { sm: true, href: `${scoped(one.repo)}&suggestion=${encodeURIComponent(one.id)}#models-suggested` }), postForm("/settings/models/not-now", btn("Not now", { sm: true, variant: "ghost", type: "submit" }), { hidden: { scope: one.repo, id: one.id } }))
+        : html ``, "top"));
+    const rules = s.rules.map(one => formRow(s.repo === null ? `${one.title} · ${one.project}` : one.title, one.words, !manage || one.state === "ended" ? html ``
+        : one.state === "paused"
+            ? acts(postForm("/settings/models/keep", html `${password(view, `models-keep-${one.id}`)}${btn("Keep", { sm: true, type: "submit" })}`, { hidden: { scope: one.repo, rule: String(one.id) } }), postForm("/settings/models/turn-off", btn("Drop", { sm: true, variant: "ghost", type: "submit" }), { hidden: { scope: one.repo, rule: String(one.id) } }))
+            : postForm("/settings/models/turn-off", btn("Turn off", { sm: true, type: "submit" }), { hidden: { scope: one.repo, rule: String(one.id) } }), "top"));
+    // Trials (slice 3): an offer to try a cheaper model on the next few tasks — started with a step-up, each task still
+    // approved by a person — and the trials in use, each with its progress and Stop (stopping only lowers: no password).
+    const trialOffers = (s.trialOffers ?? []).map(one => formRow(s.repo === null ? `${one.title} · ${one.project}` : one.title, one.words, manage
+        ? acts(postForm("/settings/models/try", html `${password(view, `models-try-${one.id.replace(/[^a-z0-9]/gi, "-")}`)}${btn(one.save, { sm: true, type: "submit" })}`, { hidden: { scope: one.repo, id: one.id } }), postForm("/settings/models/not-now", btn("Not now", { sm: true, variant: "ghost", type: "submit" }), { hidden: { scope: one.repo, id: one.id } }))
+        : html ``, "top"));
+    const trials = (s.trials ?? []).map(one => formRow(s.repo === null ? `${one.title} · ${one.project}` : one.title, one.words, !manage || !one.live ? html ``
+        : postForm("/settings/models/stop", btn("Stop", { sm: true, type: "submit" }), { hidden: { scope: one.repo, rule: String(one.id) } }), "top"));
+    const toggle = s.suggest === null || s.repo === null ? "" : formRow("Suggest cheaper models", s.suggest.on
+        ? "On. When a cheaper model does as well on this project's small or routine tasks, it's suggested here. Nothing changes until you accept it."
+        : "Off. No new suggestions for this project.", !manage ? html `` : s.suggest.on
+        ? postForm("/settings/models/suggest-off", btn("Turn off", { sm: true, type: "submit" }), { hidden: { scope: s.repo } })
+        : postForm("/settings/models/suggest-on", html `${password(view, "models-suggest-pw")}${btn("Turn on", { sm: true, type: "submit" })}`, { hidden: { scope: s.repo } }), "inline");
+    const emptyWords = s.repo === null ? "No suggestions yet. Choose a project above to see its own." : "No suggestions yet. When a cheaper model's results on this project's small or routine tasks match the configured model's, it's suggested here.";
+    const nothing = offers.length === 0 && rules.length === 0 && trialOffers.length === 0 && trials.length === 0 && s.review === null;
+    const body = html `${review}${nothing ? note(emptyWords) : ""}${offers}${trialOffers}${rules.length === 0 ? "" : html `${group("Rules in use")}${rules}`}${trials.length === 0 ? "" : html `${group("Trials")}${trials}`}${toggle}`;
+    const waiting = s.offers.length + trialOffers.length;
+    return sec("suggested", "Suggested", waiting === 0 ? "" : `${waiting} to review`, body);
+}