toolroll 0.9.91 → 0.9.92

package/dist/memory-cli.js

@@ -21,11 +21,11 @@ export const MEMORY_DESCRIPTORS = [
     { action: 'search', synopsis: 'search decisions, instructions, references, lessons and your conversations', mutation: 'none', takesQuery: true, flags },
     { action: 'decisions', synopsis: "list a project's active decisions (--all for history)", mutation: 'none', takesQuery: false, flags },
     { action: 'show', synopsis: 'read one decision with its reason and history', mutation: 'none', takesQuery: true, flags },
-    { action: 'decide', synopsis: 'record a settled choice: memory decide "<choice>" --why "<reason>" --repo PATH', mutation: 'unkeyed', takesQuery: true, flags },
-    { action: 'retire', synopsis: 'retire a decision that no longer holds: memory retire <id> --reason "<why>"', mutation: 'unkeyed', takesQuery: true, flags },
+    { action: 'decide', synopsis: 'record a settled choice: memory decide "<choice>" --why "<reason>" --repo PATH', mutation: 'unkeyed', takesQuery: true, flags, audience: 'operator' },
+    { action: 'retire', synopsis: 'retire a decision that no longer holds: memory retire <id> --reason "<why>"', mutation: 'unkeyed', takesQuery: true, flags, audience: 'operator' },
     { action: 'propose', synopsis: 'the backward pass: read recent sessions, keep a ledger of evidenced gaps, propose a few edits (writes nothing to memory)', mutation: 'unkeyed', takesQuery: false, flags },
     { action: 'review', synopsis: 'list pending memory proposals with their evidence', mutation: 'none', takesQuery: false, flags },
-    { action: 'apply', synopsis: 'decide one proposal: memory apply <id> --decision accept|reject — the only writer', mutation: 'unkeyed', takesQuery: true, flags },
+    { action: 'apply', synopsis: 'decide one proposal: memory apply <id> --decision accept|reject — the only writer', mutation: 'unkeyed', takesQuery: true, flags, audience: 'operator' },
     { action: 'status', synopsis: 'surface version, instruction budget, sessions analysed, open gaps and pending proposals', mutation: 'none', takesQuery: false, flags },
 ];
 const line = (d) => `#${d.id} ${d.claim} — ${d.decidedBy}, ${d.decidedAt.slice(0, 10)}${d.status === 'active' ? '' : ` (${d.status})`}`;

package/dist/memory-pass.js

@@ -17,7 +17,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { scanForSecrets, readVerifiedArtifact } from './evidence.js';
 import { changeKnowledge, knowledgeView } from './project-knowledge.js';
-import { listDecisions, recordDecision } from './project-memory.js';
+import { listDecisions, recordDecision, refuseLeadMemoryWrite } from './project-memory.js';
 import { composeLeadRequest, performLeadRequest, isDirectChatProvider, CHAT_KEY_ENV } from './converse.js';
 import { performSubscriptionLeadRequest } from './subscription-chat.js';
 import { TEXT_LIMITS } from './text-limits.js';
@@ -399,7 +399,11 @@ export function listProposals(store, repo, status = 'pending') {
 }
 /** The one writer: accept applies the edit through the knowledge or decision store as the person; reject remembers the fingerprint and its corroboration. */
 export function decideProposal(store, args, now = new Date()) {
+    refuseLeadMemoryWrite();
     return store.transact(() => {
+        // A person who may change this project's memory, read inside the write (a revoked account or lost access refuses).
+        if (!store.accountCanAccess(args.actor, args.repo) || store.accountOf(args.actor)?.role !== 'approver')
+            throw Error('Project memory is outside your access.');
         const row = store.handle.prepare('SELECT * FROM memory_proposal WHERE id=? AND repo=?').get(args.id, args.repo);
         if (!row)
             throw Error('That proposal is unavailable.');

package/dist/model-choices.d.ts

@@ -1,5 +1,5 @@
 import { type SeenModel } from "./model-catalog.js";
-import { type PhaseRoute } from "./phase-routing.js";
+import { type EarnedRule, type PhaseRoute } from "./phase-routing.js";
 import type { Store } from "./store.js";
 export type SlotPhase = "plan" | "build" | "repair" | "review";
 export type SlotTier = "routine" | "light" | "strong";
@@ -76,7 +76,9 @@ export declare const ROUTE_CASES: readonly {
     risky: boolean;
     strict: boolean;
 }[];
-export declare function effectiveRoutes(store: Store, repo: string | null): {
+export declare function effectiveRoutes(store: Store, repo: string | null, options?: {
+    rules?: readonly EarnedRule[] | false;
+}): {
     ok: true;
     routes: {
         label: string;
@@ -164,7 +166,9 @@ export type ScopeCheck = {
  * 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 declare function checkScope(store: Store, repo: string | null): ScopeCheck;
+export declare function checkScope(store: Store, repo: string | null, options?: {
+    rules?: readonly EarnedRule[];
+}): ScopeCheck;
 /** A resolver's words for a browser: what is wrong, never a terminal command to fix it. */
 export declare function browserWords(problem: string): string;
 /** The problem alone, or null when tasks can be filed. */

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. */