toolroll 0.9.27 → 0.9.29

package/dist/mate-tools.js

@@ -1,3 +1,4 @@
+import { TEXT_LIMITS } from "./text-limits.js";
 import { connectionsOf, oneClickOf } from "./mcp-connect.js";
 import { checkLevelFromWords, isCheckLevel } from "./check-levels.js";
 import { policyParts } from "./policy.js";
@@ -42,7 +43,7 @@ import { parseAcceptanceCriteria, ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "./sc
 import { diagnoseTaskDispatch, withDispatchDiagnoses } from "./dispatch.js";
 import { agentChoicesFor, routeOfTask, INSTALLATION_SCOPE } from "./agentconfig.js";
 import { isNewModel, modelWords, priceWords, runtimeStates, seenModels } from "./model-catalog.js";
-import { agentsSummary, chosenWords, isRiskLevel, PHASES, postureWords, RISK_CHOICES, riskConsequence, riskTitle, routeProblems, sameSpec, specWords } from "./phase-routing.js";
+import { agentsSummary, chosenWords, isRiskLevel, isTaskSize, PHASES, postureWords, RISK_CHOICES, riskConsequence, riskTitle, routeProblems, sameSpec, sizeSourceWords, sizeWords, specWords } from "./phase-routing.js";
 import { TOOL_CATALOG, discoverTools, projectToolsOf, secretsSetFor, toolCommandLine, toolStanding } from "./project-tools.js";
 import { deciderOf, durationWords, FLOW_KIND_WORDS, FLOW_STAGE_KINDS, FLOW_TEMPLATES, flowFromSteps, stepsFor } from "./flows.js";
 import { flowDefinitionOf } from "./flow-engine.js";
@@ -359,6 +360,7 @@ export function agentsOver(store, taskId, now) {
     const base = {
         task: taskId,
         risk: { level: risk, title: riskTitle(risk), consequence: riskConsequence(risk) },
+        size: ref.sizing == null ? null : { size: ref.sizing.size, risky: ref.sizing.risky, reason: ref.sizing.reason, source: sizeSourceWords(ref.sizing.source) },
         riskChoices: RISK_CHOICES.map(one => ({ risk: one.risk, title: one.title, consequence: one.consequence })),
         editable,
         editableWhy,
@@ -378,6 +380,7 @@ export function agentsOver(store, taskId, now) {
         standing: routed.source === "approved" ? "approved" : routed.source === "proposed" ? "awaiting approval" : "recommended",
         summary: agentsSummary(route),
         posture: postureWords(route),
+        sizeWords: sizeWords(route),
         demands: route.demands.filter(reason => !/review/i.test(reason)),
         agents: route.legs.filter(leg => leg.phase !== "review").map(leg => ({ role: ROLE_WORD[leg.phase], provider: leg.provider, model: leg.model, chosen: chosenWords(leg), reasons: leg.reasons.map(reason => reason.replace("builder and reviewer", "builder")), problem: leg.problem })),
         problems: routeProblems(route),
@@ -433,7 +436,7 @@ export const MATE_TOOLS = [
     {
         name: "propose_action",
         description: "Read get_actions and relevant skills/evidence first. Save an exact-state proposal only; protected or long terms require full secure review.",
-        inputSchema: schema({ operation: { type: 'string', enum: Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith('flow_') && !one.startsWith('teammate_')) }, repo: { type: 'string' }, task: TASK_ARG, version: { type: 'string' }, restore: { type: 'integer', minimum: 1 }, sample: { type: 'string', maxLength: 800 }, content: { type: 'string', maxLength: 12000 }, instructions: { type: 'string', maxLength: 4000 }, title: { type: 'string', maxLength: 120 }, id: { type: 'string' }, run: { type: 'integer', minimum: 1 }, note: { type: 'string', maxLength: 2000 }, catalog: { type: 'string', maxLength: 40 }, name: { type: 'string', maxLength: 40 }, command: { type: 'string', maxLength: 400 }, args: { type: 'array', items: { type: 'string', maxLength: 400 }, maxItems: 40 }, url: { type: 'string', maxLength: 500 }, secrets: { type: 'array', items: { type: 'string', maxLength: 64 }, maxItems: 12 }, about: { type: 'string', maxLength: 240 } }, ['operation']),
+        inputSchema: schema({ operation: { type: 'string', enum: Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith('flow_') && !one.startsWith('teammate_')) }, repo: { type: 'string' }, task: TASK_ARG, version: { type: 'string' }, restore: { type: 'integer', minimum: 1 }, sample: { type: 'string', maxLength: 800 }, content: { type: 'string', maxLength: 12000 }, instructions: { type: 'string', maxLength: TEXT_LIMITS.flowInstructions }, title: { type: 'string', maxLength: 120 }, id: { type: 'string' }, run: { type: 'integer', minimum: 1 }, note: { type: 'string', maxLength: LIMITS.note, description: `At most ${LIMITS.note} characters; longer is refused with its length, not cut.` }, catalog: { type: 'string', maxLength: 40 }, name: { type: 'string', maxLength: 40 }, command: { type: 'string', maxLength: 400 }, args: { type: 'array', items: { type: 'string', maxLength: 400 }, maxItems: 40 }, url: { type: 'string', maxLength: 500 }, secrets: { type: 'array', items: { type: 'string', maxLength: 64 }, maxItems: 12 }, about: { type: 'string', maxLength: 240 } }, ['operation']),
         handle: (ctx, args) => {
             const operation = args['operation'];
             if (!isChatAction(operation))
@@ -894,7 +897,7 @@ export const MATE_TOOLS = [
             name: { type: "string", maxLength: 80 }, template: { type: "string", enum: FLOW_TEMPLATES.map(one => one.id) },
             steps: { type: "array", minItems: 1, maxItems: 24, items: { type: "object", additionalProperties: false, properties: {
                         id: { type: "string", maxLength: 32 }, title: { type: "string", maxLength: 60 }, kind: { type: "string", enum: [...FLOW_STAGE_KINDS] },
-                        instructions: { type: "string", maxLength: 4000 }, planning: { type: "string", enum: ["auto", "required", "skip"] },
+                        instructions: { type: "string", maxLength: TEXT_LIMITS.flowInstructions }, planning: { type: "string", enum: ["auto", "required", "skip"] },
                         decider: { type: "string", maxLength: 64 }, message: { type: "string", maxLength: 1000 },
                         script: { type: "string", maxLength: 40 }, close: { type: "boolean" },
                         question: { type: "string", maxLength: 300 }, sureAt: { type: "integer", minimum: 50, maximum: 99 },
@@ -913,7 +916,7 @@ export const MATE_TOOLS = [
                         ifReplied: { type: "string", maxLength: 60 }, repo: REPO_ARG,
                         next: { type: "string", maxLength: 60 }, ifFails: { type: "string", maxLength: 60 }, ifNotSure: { type: "string", maxLength: 60 },
                     } } },
-            title: { type: "string", maxLength: 200 }, description: { type: "string", maxLength: 4000 }, zone: { type: "string", maxLength: 60 }, note: { type: "string", maxLength: 2000 },
+            title: { type: "string", maxLength: 200 }, description: { type: "string", maxLength: 4000 }, zone: { type: "string", maxLength: 60 }, note: { type: "string", maxLength: LIMITS.note, description: `At most ${LIMITS.note} characters; longer is refused with its length, not cut.` },
             choice: { type: "integer", minimum: 1, maximum: 4 },
             trigger: { type: "integer", minimum: 1 }, owner: { type: "string", maxLength: 64 },
             script: { type: "object", additionalProperties: false, properties: { name: { type: "string", maxLength: 40 }, about: { type: "string", maxLength: 160 }, body: { type: "string", maxLength: 1600 }, timeoutMinutes: { type: "integer", minimum: 1, maximum: 60 },
@@ -1829,15 +1832,17 @@ export const MATE_TOOLS = [
     {
         name: "propose_steer",
         description: "Guide the next attempt within existing scope; never interrupt work.",
-        inputSchema: schema({ task: TASK_ARG, note: { type: "string", maxLength: 2_000 } }, ["task", "note"]),
+        inputSchema: schema({ task: TASK_ARG, note: { type: "string", maxLength: LIMITS.note, description: `At most ${LIMITS.note} characters; longer is refused with its length, not cut.` } }, ["task", "note"]),
         handle: (ctx, args) => {
             const taskId = taskIdOf(args);
             const ref = taskId === null ? null : admittedRef(ctx, taskId);
             const task = taskId === null ? null : ctx.store.getTask(taskId);
             if (taskId === null || ref === null || task === null)
                 return notFound();
-            if (!honest(args["note"], 2_000))
-                return { ok: false, message: "guidance is plain text up to 2,000 characters" };
+            if (typeof args["note"] === "string" && args["note"].length > LIMITS.note)
+                return { ok: false, message: `guidance is ${args["note"].length} characters; the limit is ${LIMITS.note}. Shorten it and propose again.` };
+            if (!honest(args["note"], LIMITS.note))
+                return { ok: false, message: `guidance is plain text up to ${LIMITS.note} characters` };
             if (task.state === "done" || task.state === "cancelled")
                 return { ok: false, message: "that task is finished, so guidance has no next attempt to reach" };
             if (ctx.store.openContestFor(ref.id) !== null)
@@ -1945,10 +1950,12 @@ export const MATE_TOOLS = [
     },
     {
         name: "propose_agents",
-        description: "Read get_agents. Change risk/configured role model or clear override; stales approval, refuses running work.",
+        description: "Read get_agents. Change risk, size (small: fast model, no plan; large or risky: strongest agents), configured role model, or clear override; stales approval, refuses running work.",
         inputSchema: schema({
             task: TASK_ARG,
             risk: { type: "string", enum: ["routine", "elevated", "high"] },
+            size: { type: "string", enum: ["small", "medium", "large"] },
+            risky: { type: "boolean" },
             role: { type: "string", enum: ["planner", "builder", "repair"] },
             agent: schema({ provider: { type: "string", maxLength: 20 }, model: { type: "string", maxLength: 120 } }, ["provider", "model"]),
             clear: { type: "boolean" },
@@ -1969,8 +1976,16 @@ export const MATE_TOOLS = [
                 return { ok: false, message: "role is planner, builder, or repair" };
             const clear = args["clear"] === true;
             const agent = args["agent"];
-            if (risk === undefined && phase === null)
-                return { ok: false, message: "say what changes: a risk, or a role with an agent (or clear: true)" };
+            const size = args["size"];
+            const risky = args["risky"];
+            if (size !== undefined && !isTaskSize(size))
+                return { ok: false, message: "size is small, medium, or large" };
+            if (risky !== undefined && typeof risky !== "boolean")
+                return { ok: false, message: "risky is true or false" };
+            const sized = ctx.store.refForId(ref.id)?.sizing ?? null;
+            const sizeChange = size === undefined && risky === undefined ? null : { size: size ?? sized?.size ?? "medium", risky: risky ?? sized?.risky ?? false };
+            if (risk === undefined && phase === null && sizeChange === null)
+                return { ok: false, message: "say what changes: a risk, a size, or a role with an agent (or clear: true)" };
             if (phase !== null && !clear && (agent === null || typeof agent !== "object"))
                 return { ok: false, message: "a role change names an agent from get_agents, or clear: true" };
             if (phase === null && (clear || agent !== undefined))
@@ -2014,6 +2029,7 @@ export const MATE_TOOLS = [
                 taskTitle: task.title,
                 repoId: ref.repoId,
                 ...(risk === undefined ? {} : { risk, riskConsequence: riskConsequence(risk) }),
+                ...(sizeChange === null ? {} : { size: sizeChange.size, risky: sizeChange.risky }),
                 ...(phase === null ? {} : { phase, role: ROLE_WORD[phase] }),
                 ...(chosen === null ? {} : { provider: chosen.provider, model: chosen.model }),
                 ...(clear ? { clear: true } : {}),
@@ -2031,6 +2047,7 @@ export const MATE_TOOLS = [
                     kind: "agents",
                     task: taskId,
                     ...(risk === undefined ? {} : { risk }),
+                    ...(sizeChange === null ? {} : { size: sizeChange.size, risky: sizeChange.risky }),
                     ...(phase === null ? {} : { role: ROLE_WORD[phase], ...(chosen === null ? { clear: true } : { agent: chosen }) }),
                     awaiting: view["approval"] === "approved" ? "the operator's confirmation — the current approval will then need renewing" : "the operator's confirmation",
                 },

package/dist/mate.js

@@ -9,7 +9,8 @@ import { redactSecretAssignments } from "./builder.js";
 import { MATE_CONTRACT } from "./mate-contract.js";
 import { MATE_MAX_PROPOSALS_PER_TURN, MATE_TOOL_SCHEMAS, executeMateTool, isMateTool, mateViewContextFor, projectLabelForMate, redactForMate, toolResultBytes } from "./mate-tools.js";
 import { composeSubscriptionMatePrompt, performSubscriptionMateRequest } from "./subscription-chat.js";
-import { leadContext } from './lead-context.js';
+import { LEAD_REPLY_LIMITS, leadContext } from './lead-context.js';
+import { shortenAsk } from './text-limits.js';
 import { envValue } from "./names.js";
 import { deliverableClaim, deliverableRepair, dropDeliverableClaims, replyCarriesDeliverable } from "./reply-shape.js";
 export const MATE_MESSAGE_MAX_CHARS = 2_000;
@@ -317,6 +318,9 @@ export async function runMateTurn(input) {
     let shownControl = false;
     /** The turn's one repair step for a reply that claims an attachment it does not carry. */
     let repaired = false;
+    /** The turn's one shorten step for a reply over its channel's message limit (LEAD_REPLY_LIMITS); still over, it is split. */
+    let shortened = false;
+    const replyLimit = input.channel === undefined ? null : LEAD_REPLY_LIMITS[input.channel];
     const unbacked = (text) => {
         const claim = deliverableClaim(text);
         if (claim === null || shownControl || replyCarriesDeliverable(text) || store.listMateTurnEvidence(turnId).length > 0)
@@ -447,7 +451,14 @@ export async function runMateTurn(input) {
                 history.push({ role: "operator", text: deliverableRepair(claim) });
                 continue;
             }
-            reply = claim === null ? answer.text : dropDeliverableClaims(answer.text);
+            const candidate = claim === null ? answer.text : dropDeliverableClaims(answer.text);
+            if (replyLimit !== null && candidate.length > replyLimit && !shortened && steps < maxSteps) {
+                shortened = true;
+                history.push({ role: "assistant", text: answer.text, calls: [] });
+                history.push({ role: "operator", text: shortenAsk([{ field: "Your reply", limit: replyLimit, length: candidate.length }]) });
+                continue;
+            }
+            reply = candidate;
             break;
         }
         if (answer.calls.length > MATE_MAX_CALLS_PER_STEP)

package/dist/needs-you.d.ts

@@ -8,7 +8,7 @@
 /** What a person is asked for. */
 export type NeedKey = "approval" | "card" | "answer" | "questions" | "sign-in" | "confirm-stopped" | "check-stopped" | "hold" | "choose-project" | "define-task" | "fix-request" | "choose-agent" | "fix-dependency" | "add-requirement" | "connect-builder" | "start-builder" | "vanished" | "review-result" | "rebuild" | "earlier-version" | "other";
 /** What the work waits for when no person can act. */
-export type WaitKey = "build-stopping" | "other-computer" | "card-reply" | "card-time" | "card-ci";
+export type WaitKey = "build-stopping" | "build-finishing" | "other-computer" | "card-reply" | "card-time" | "card-ci";
 /** The action's code: the WorkAction that owns the act, or one of the acts a surface renders itself. */
 export type NeedActionCode = "approve-scope" | "approve-card" | "answer-decision" | "inspect-decisions" | "sign-in" | "confirm-stopped" | "inspect-hold" | "place-task" | "write-scope" | "select-agent" | "repair-dependency" | "repair-capability" | "start-worker" | "reconcile-run" | "open-result" | "retry-task" | "inspect-task";
 export type NeedAction = {
@@ -73,7 +73,7 @@ export declare function waitSentence(key: WaitKey | undefined, reason: string |
  * `unknown`: Toolroll can't check, so the person confirms they checked. */
 export declare function processNeedOf(fact: {
     run: number;
-    kind: "open" | "alive" | "elsewhere" | "unprovable" | "unknown";
+    kind: "open" | "alive" | "elsewhere" | "unprovable" | "unknown" | "settling";
 } | null): {
     need: "confirm-stopped" | "check-stopped";
     build: number;

package/dist/needs-you.js

@@ -79,6 +79,7 @@ export const NEED_ASK = {
     "add-requirement": "unblock", "connect-builder": "unblock", "start-builder": "unblock", vanished: "unblock", "earlier-version": "unblock", other: "unblock",
 };
 export const WAITS = {
+    "build-finishing": () => "Finishing up; this clears on its own.",
     "build-stopping": context => `Waiting for ${build(context)} to stop. Nothing is needed from you.`,
     "other-computer": context => `Waiting for the computer that ran ${build(context)} to confirm it stopped.`,
     "card-reply": () => "Waiting for a reply.",
@@ -110,6 +111,8 @@ export function waitSentence(key, reason, context = {}) {
 export function processNeedOf(fact) {
     if (fact === null)
         return null;
+    if (fact.kind === "settling")
+        return { wait: "build-finishing", build: fact.run };
     if (fact.kind === "unprovable")
         return { need: "confirm-stopped", build: fact.run };
     if (fact.kind === "unknown")

package/dist/operate.d.ts

@@ -1,5 +1,6 @@
 import { type IntegrationIo } from "./integrations.js";
 import { type OnboardIo } from "./agent-onboard.js";
+import { type Sizer } from "./task-sizing.js";
 import { type TriggerIo } from "./flow-triggers.js";
 import type { StepIo } from "./flow-steps.js";
 import type { FetchLike } from "./flow-share.js";
@@ -83,6 +84,8 @@ export type OperateOptions = {
         env?: Record<string, string | undefined>;
         openBrowser?: (url: string) => void;
     };
+    /** Injected by tests: the classifier that sizes filed tasks (none by default under test). */
+    filingSizer?: Sizer;
 };
 export type OnboardSeams = Partial<Pick<OnboardIo, "home" | "env" | "cwd" | "interactive" | "confirm" | "findRepo" | "checkConnection" | "pullRequests">>;
 export declare const OPERATE_HELP: string;

package/dist/operate.js

@@ -26,6 +26,8 @@ import { checkIntegrations, integrationsBrokenLine, integrationsNow, renderInteg
 import { buildHandoff, handoffLines, loginAccount, runOnboard } from "./agent-onboard.js";
 import { backupFiles, backupFolderOf, backupOwner, backupNow, restoreDatabase, startBackups } from "./backup.js";
 import { pushLimitSink } from "./provider-limits.js";
+import { heuristicSizing, installFilingSizer, ownerSizer, refineFiledSizing, settleSizings } from "./task-sizing.js";
+import { tierLines, tierReport } from "./tier-report.js";
 import { limitsView } from "./limits-ui.js";
 import { startCodexLimits } from "./codex-limits.js";
 import { packageVersion, startMonitoring, targetOf } from "./monitoring.js";
@@ -176,7 +178,7 @@ import { TEMPLATES, templateByName } from "./templates.js";
 import { planTournament, planComparison, contestNoun, jointApprovalDigest, admitContest, crossReadyBarrier, finalizeContestant, recoverContests, maybeAggregate as contestMaybeAggregate, sweepContestCleanup, escalateOverdueContests } from "./contest.js";
 import { isDirectChatProvider, isSubscriptionChatProvider, priceOf, PRICED_MODELS } from "./converse.js";
 import { resolvePhaseAgent, resolveScopeProfile, resolveScopeChain, resolveRouteCandidates, routeOfTask, INSTALLATION_SCOPE } from "./agentconfig.js";
-import { isRiskLevel, legOf, projectRoute, riskConsequence, routeDigestOf, routeWords, RISK_LEVELS, PHASES as ROUTE_PHASES } from "./phase-routing.js";
+import { isRiskLevel, isTaskSize, legOf, projectRoute, riskConsequence, routeDigestOf, routeWords, RISK_LEVELS, TASK_SIZES, PHASES as ROUTE_PHASES } from "./phase-routing.js";
 import { observeProviderReadiness, reportProviderReadinessAuthed } from "./runner.js";
 import { parseDemoUrl, projectDemoUrl, saveProjectDemo } from "./project-demo.js";
 import { effectiveConcurrency, maySlotTake, parseProjectConcurrency, PROJECT_CONCURRENCY_DEFAULT, ProjectPasses, projectConcurrency, saveProjectConcurrency, savedProjectConcurrency } from "./project-concurrency.js";
@@ -423,6 +425,7 @@ Capabilities — what the work needs, recorded and probed, never valued
                                         the repo, asks you questions, and
                                         proposes a scope you approve
   toolroll task route <id> [--risk routine|elevated|high]
+      [--size small|medium|large] [--risky yes|no]
       [--phase plan|build|repair --provider <p> [--model <m>] | --clear-phase <phase>]
       --as <you> --token <t>            which agent plans, builds, and repairs
                                         this task, with the reason for
@@ -500,6 +503,17 @@ Agents — which provider and model each phase runs on
                                         the STRONG agent high-risk, strict,
                                         screenshot-proof, and automerge
                                         routes reach for; never inferred
+  toolroll config set build --tier light --provider <p> --model <m>
+      [--repo <path>] --as <you> --token <t>
+                                        the fast agent small changes build
+                                        on, with no plan
+  toolroll config set <plan|build> [--tier light|strong] --also
+      --provider <p> --model <m> [--repo <path>] --as <you> --token <t>
+                                        another provider's agent on the same
+                                        tier; each task runs the one whose
+                                        plan has more room
+  toolroll config clear <plan|build> [--tier light|strong] --also
+      [--provider <p>] [--repo <path>] --as <you> --token <t>
   toolroll config clear <phase> [--repo <path>] --as <you> --token <t>
 
   toolroll setup show --repo <path>  what a fresh checkout runs first
@@ -632,7 +646,7 @@ export const OPERATE_VALUE_FLAGS = new Set([
     "provider", "plan-model", "plan-provider", "public-url", "editor",
     "command", "timeout-seconds", "setup-digest", "stop-grace", "title", "name", "every", "lines",
     "label", "reviewers", "limit", "role", "key-file", "weekly-usd", "daily-turns", "per-hour", "token-file", "race", "compare", "race-per-usd", "race-total-usd", "race-count", "race-agents", "budget-usd", "build-usd", "sync-max-age", "merge-method",
-    "phase", "risk", "tier", "clear-phase",
+    "phase", "risk", "tier", "clear-phase", "size", "risky",
     "run", "containment", "agent",
     // onboard: the starter flows to switch on.
     "starter",
@@ -664,6 +678,8 @@ export const OPERATE_BOOLEAN_FLAGS = new Set([
     "revoke",
     // task merge: merge without waiting for the full check (Quick or Off results).
     "anyway",
+    // config set/clear: another provider's candidate on the same tier.
+    "also",
 ]);
 export function parseOperateArgs(argv, ownValues = new Set()) {
     const positional = [];
@@ -799,6 +815,9 @@ export async function runOperate(command, argv, write, options = {}) {
     }
     // v105: a Claude turn anywhere in this command says its plan's usage windows; keep the latest.
     const dropLimitSink = pushLimitSink(reading => store.recordProviderLimits(reading, new Date()));
+    // Filed tasks are sized by the owner's own fast classifier (never in tests, the demo, or with NO_TASK_CLASSIFIER).
+    const sizer = options.filingSizer ?? (process.env["VITEST"] !== undefined || envValue(process.env, "NO_TASK_CLASSIFIER") !== undefined || store.isDemo() ? null : ownerSizer());
+    const dropSizer = sizer === null ? () => { } : installFilingSizer(sizer);
     // One `Date` per command is fine for a lookup and wrong for a pass that
     // runs an agent for half an hour: leases granted, extended, and released
     // with the same stale stamp. Injected time stays frozen — a test's clock
@@ -853,6 +872,9 @@ export async function runOperate(command, argv, write, options = {}) {
         return fail(write, json, command, "failed", describe(error), EXIT.failed);
     }
     finally {
+        // A classification still in flight (at most its five-second budget) lands before the database closes.
+        await settleSizings();
+        dropSizer();
         dropLimitSink();
         store.close();
     }
@@ -5787,8 +5809,11 @@ async function configCommand(positional, flags, context) {
             phase: one,
             strong: candidates.ok ? candidates.candidates[one].strong : null,
         }));
+        const alsoRows = [...store.listPhaseTierAlternates(INSTALLATION_SCOPE), ...(scope === INSTALLATION_SCOPE ? [] : store.listPhaseTierAlternates(scope))];
+        // A light planner from before light became build-only is never used: said, with how to clear it.
+        const unusedLight = [INSTALLATION_SCOPE, ...(scope === INSTALLATION_SCOPE ? [] : [scope])].filter(one => store.phaseTierConfig(one, "plan", "light") !== null);
         if (json) {
-            write(envelopeJson({ ok: true, command: "config show", installation, project, resolved, fallback, strong, installationStrong: store.listPhaseTierConfig(INSTALLATION_SCOPE), projectStrong: scope === INSTALLATION_SCOPE ? [] : store.listPhaseTierConfig(scope) }));
+            write(envelopeJson({ ok: true, command: "config show", installation, project, resolved, fallback, strong, installationStrong: store.listPhaseTierConfig(INSTALLATION_SCOPE), projectStrong: scope === INSTALLATION_SCOPE ? [] : store.listPhaseTierConfig(scope), installationAlso: store.listPhaseTierAlternates(INSTALLATION_SCOPE), projectAlso: scope === INSTALLATION_SCOPE ? [] : store.listPhaseTierAlternates(scope) }));
             return EXIT.ok;
         }
         write(`Effective phase agents${scope === INSTALLATION_SCOPE ? "" : ` for ${scope}`}:`);
@@ -5807,6 +5832,22 @@ async function configCommand(positional, flags, context) {
         }
         write("  set one with: toolroll config set <phase> --tier strong --provider <p> --model <m> --as <you> --token <t>");
         write("");
+        write("  light tier (small changes build on this, with no plan):");
+        const light = candidates.ok ? candidates.candidates.build.light ?? null : null;
+        write(`  ${"build".padEnd(8)} ${light === null ? "none configured — small changes keep the default above and say so" : `${light.provider} · ${light.model}  [${light.source}]`}`);
+        for (const one of unusedLight)
+            write(`  ${"plan".padEnd(8)} not used — a small change makes no plan; \`config clear plan --tier light${one === INSTALLATION_SCOPE ? "" : ` --repo ${one}`}\` removes it`);
+        write("  set one with: toolroll config set build --tier light --provider <p> --model <m> --as <you> --token <t>");
+        write("");
+        if (candidates.ok) {
+            const also = ["plan", "build"].flatMap(one => Object.entries(candidates.candidates[one].alternates ?? {}).flatMap(([tier, list]) => (list ?? []).map(spec => `  ${one.padEnd(8)} ${tier.padEnd(8)} also ${spec.provider} · ${spec.model}  [${spec.source}]`)));
+            if (also.length > 0 || alsoRows.length > 0) {
+                write("  other providers on a tier (each task runs the one whose plan has more room):");
+                for (const line of also)
+                    write(line);
+                write("");
+            }
+        }
         write("  repair note: the repair PROVIDER always inherits the build it mends — only its model is configurable.");
         if (fallback.length > 0) {
             write("");
@@ -6046,11 +6087,57 @@ async function configCommand(positional, flags, context) {
     // reaches for when risk, quality, evidence, or publication demand it.
     // Authenticated and audited exactly like the routine row; existing
     // approvals are untouched — a sealed route never re-resolves.
+    // The LIGHT tier (v2): the fast agent a small change builds on.
     const tierGiven = text(flags, "tier");
-    if (tierGiven !== undefined && tierGiven !== "strong") {
-        return fail(write, json, `config ${action}`, "usage", "--tier is `strong` — the routine tier is the plain phase row", EXIT.usage);
+    if (tierGiven !== undefined && tierGiven !== "strong" && tierGiven !== "light") {
+        return fail(write, json, `config ${action}`, "usage", "--tier is `light` or `strong` — the routine tier is the plain phase row", EXIT.usage);
+    }
+    // A light planner would never run (a small change makes no plan): refused rather than kept and ignored.
+    // Clearing one left from before stays possible.
+    if (tierGiven === "light" && phase !== "build" && !(action === "clear" && phase === "plan" && !flag(flags, "also"))) {
+        return fail(write, json, `config ${action}`, "usage", "--tier light is for build only — a small change makes no plan, and repairs resume the builder's session", EXIT.usage);
+    }
+    // Another provider's candidate on the same tier (`--also`): one per provider, and at filing the one whose plan
+    // has more room runs.
+    if (flag(flags, "also")) {
+        if (phase !== "plan" && phase !== "build") {
+            return fail(write, json, `config ${action}`, "usage", "--also is for plan or build — repairs follow the build's provider", EXIT.usage);
+        }
+        const tier = (tierGiven ?? "routine");
+        const alsoProvider = text(flags, "provider");
+        if (alsoProvider !== undefined && !isProviderId(alsoProvider)) {
+            return fail(write, json, `config ${action}`, "usage", `--provider is one of ${PROVIDER_IDS.join(", ")}`, EXIT.usage);
+        }
+        if (action === "clear") {
+            const removed = store.clearPhaseTierAlternates(scope, phase, tier, alsoProvider ?? null);
+            return succeed(write, json, "config clear", { scope, phase, tier, also: true, provider: alsoProvider ?? null, cleared: removed }, () => [
+                removed > 0 ? `Removed ${removed} other-provider ${tier} ${phase} agent${removed === 1 ? "" : "s"} at ${scope}; sealed routes are untouched.` : `No other-provider ${tier} ${phase} agent${alsoProvider === undefined ? "" : ` on ${alsoProvider}`} was configured at ${scope}.`,
+            ]);
+        }
+        const alsoModel = text(flags, "model");
+        if (alsoProvider === undefined || alsoModel === undefined) {
+            return fail(write, json, "config set", "usage", "--also names an exact --provider and --model — approvals bind exact routing", EXIT.usage);
+        }
+        const alsoValid = validateSpec({ provider: alsoProvider, model: alsoModel });
+        if (!alsoValid.ok)
+            return fail(write, json, "config set", "invalid", alsoValid.problem, EXIT.usage);
+        store.setPhaseTierAlternate(scope, phase, tier, alsoProvider, alsoModel, acting.name, clock());
+        const resolvedNow = resolveRouteCandidates(store, scope === INSTALLATION_SCOPE ? null : scope);
+        const own = !resolvedNow.ok ? null : tier === "routine" ? resolvedNow.candidates[phase].routine : tier === "light" ? resolvedNow.candidates[phase].light ?? null : resolvedNow.candidates[phase].strong;
+        return succeed(write, json, "config set", { scope, phase, tier, also: true, provider: alsoProvider, model: alsoModel }, () => [
+            `${tier} ${phase} at ${scope === INSTALLATION_SCOPE ? "the installation" : scope} can also run ${alsoProvider} · ${alsoModel}, set by ${acting.name}.`,
+            own !== null && own.provider === alsoProvider && !own.source.includes("also")
+                ? `  ! the ${tier} ${phase} agent already runs ${alsoProvider} (${own.model}) — this one is not used while it does.`
+                : "  tasks filed from now on run on whichever provider's plan has more room; sealed routes are untouched.",
+        ]);
     }
     if (action === "clear") {
+        if (tierGiven === "light") {
+            const clearedLight = store.clearPhaseTierConfig(scope, phase, "light");
+            return succeed(write, json, "config clear", { scope, phase, tier: "light", cleared: clearedLight }, () => [
+                clearedLight ? `Cleared the light ${phase} agent at ${scope} — small changes keep the default and say so; sealed routes are untouched.` : `No light ${phase} agent was configured at ${scope}.`,
+            ]);
+        }
         if (tierGiven === "strong") {
             const clearedStrong = store.clearPhaseTierConfig(scope, phase, "strong");
             return succeed(write, json, "config clear", { scope, phase, tier: "strong", cleared: clearedStrong }, () => [
@@ -6071,6 +6158,16 @@ async function configCommand(positional, flags, context) {
     if (!valid.ok) {
         return fail(write, json, "config set", "invalid", valid.problem, EXIT.usage);
     }
+    if (tierGiven === "light") {
+        if (modelGiven === null) {
+            return fail(write, json, "config set", "usage", `a light ${phase} agent names an exact --model — approvals bind exact routing`, EXIT.usage);
+        }
+        store.setPhaseTierConfig(scope, phase, "light", providerGiven, modelGiven, acting.name, clock());
+        return succeed(write, json, "config set", { scope, phase, tier: "light", provider: providerGiven, model: modelGiven }, () => [
+            `light ${phase} at ${scope === INSTALLATION_SCOPE ? "the installation" : scope} is ${providerGiven} · ${modelGiven}, set by ${acting.name}.`,
+            "  small changes filed from now on build on it with no plan; sealed routes are untouched.",
+        ]);
+    }
     if (tierGiven === "strong") {
         if (phase === "review" && providerGiven === "gemini") {
             return fail(write, json, "config set", "invalid", "gemini has no isolation posture for the review phase yet — name claude or codex as the strong reviewer", EXIT.usage);
@@ -11013,7 +11110,7 @@ async function syncCommand(flags, context) {
  * separate acts by, usually, separate parties: an agent may draft a scope, and
  * only a person may agree to it.
  */
-function scopeTask(positional, flags, context) {
+async function scopeTask(positional, flags, context) {
     const { store, write, json, now } = context;
     const id = positional[0];
     const goal = text(flags, "goal");
@@ -11168,6 +11265,27 @@ function scopeTask(positional, flags, context) {
     const actor = asGiven !== undefined && tokenGiven !== undefined && authenticateApprover(store, asGiven, tokenGiven).ok
         ? asGiven
         : null;
+    // Size the new goal before filing its route. A replay must not classify
+    // again or change the task behind the original answer. This probe does
+    // not record a result; the composite filing below still owns the receipt.
+    let refinement = null;
+    store.replay(mutationFrom(flags, now), "task-scope-filed", () => {
+        const ref = store.lookupRef(id);
+        const previous = store.getScope(id);
+        if (ref === null || ref.deliverable === "report" || candidateGiven !== undefined ||
+            ref.sizing?.source === "person" || approvalOf(previous).approved ||
+            previous?.proposedVia === "coordinator" || store.filedViaOf(id)?.startsWith("mcp:") ||
+            ((plannedRace !== null || plannedComparison !== null) && store.openAuthorizationFor(ref.id) !== null))
+            return null;
+        const input = { title: store.getTask(id).title, goal, outOfScope: text(flags, "not") ?? null, touches };
+        const sized = store.applySizing(id, heuristicSizing(input), { followPlanning: true }, now);
+        if (sized.ok)
+            refinement = refineFiledSizing(store, id, input, true, context.clock);
+        return null;
+    }, () => false);
+    // Wait for bounded classification before filing so any approval in the
+    // transaction below binds the final size and route.
+    await refinement;
     // ONE replayed composite (surfaces round 1, finding 3): the filing, any
     // race/comparison terms, AND the mode seal record as a single operation —
     // a replayed key returns the FIRST answer whole instead of re-sealing
@@ -11348,7 +11466,9 @@ async function routeTaskCommand(positional, flags, context) {
     const providerGiven = text(flags, "provider");
     const modelGiven = text(flags, "model");
     const digestGiven = text(flags, "digest");
-    const editing = riskGiven !== undefined || phaseGiven !== undefined || clearGiven !== undefined;
+    const sizeGiven = text(flags, "size");
+    const riskyGiven = text(flags, "risky");
+    const editing = riskGiven !== undefined || phaseGiven !== undefined || clearGiven !== undefined || sizeGiven !== undefined || riskyGiven !== undefined;
     const show = () => {
         const scope = store.getScope(id);
         const current = store.refFor(BUILT_IN, id);
@@ -11356,7 +11476,7 @@ async function routeTaskCommand(positional, flags, context) {
         const readiness = store.readinessLookupFor(ref.repo, ref.assignedRunner, clock());
         const view = taskRouteView(routed, readiness);
         const projection = routed !== null && routed.kind === "route" ? projectRoute(routed.route, readiness) : null;
-        return succeed(write, json, "task route", { id, risk: current.riskLevel ?? scope?.riskLevel ?? "routine", riskConsequence: riskConsequence(current.riskLevel ?? scope?.riskLevel ?? "routine"), source: routed !== null && routed.kind === "route" ? routed.source : routed?.kind ?? null, route: view, overrides: current.routeOverrides ?? [], digest: scope?.digest ?? null, approval: approvalOf(scope) }, () => routed === null
+        return succeed(write, json, "task route", { id, risk: current.riskLevel ?? scope?.riskLevel ?? "routine", riskConsequence: riskConsequence(current.riskLevel ?? scope?.riskLevel ?? "routine"), size: current.sizing ?? null, source: routed !== null && routed.kind === "route" ? routed.source : routed?.kind ?? null, route: view, overrides: current.routeOverrides ?? [], digest: scope?.digest ?? null, approval: approvalOf(scope) }, () => routed === null
             ? [`${id}: no route can be recommended yet — ${scope === null ? "place the task in a repository and file a scope" : scope.unresolvedReason ?? "the phase configuration cannot resolve"}`]
             : [
                 ...(projection === null
@@ -11393,6 +11513,17 @@ async function routeTaskCommand(positional, flags, context) {
     if (riskGiven !== undefined && !isRiskLevel(riskGiven)) {
         return fail(write, json, "task route", "usage", `--risk is one of ${RISK_LEVELS.join(", ")}`, EXIT.usage);
     }
+    if (sizeGiven !== undefined && !isTaskSize(sizeGiven)) {
+        return fail(write, json, "task route", "usage", `--size is one of ${TASK_SIZES.join(", ")}`, EXIT.usage);
+    }
+    if (riskyGiven !== undefined && riskyGiven !== "yes" && riskyGiven !== "no") {
+        return fail(write, json, "task route", "usage", "--risky is yes or no", EXIT.usage);
+    }
+    // A person's size outranks the classifier's; an unnamed half keeps what the task has.
+    const sizeEdit = sizeGiven === undefined && riskyGiven === undefined ? undefined : {
+        size: sizeGiven ?? ref.sizing?.size ?? "medium",
+        risky: riskyGiven === undefined ? ref.sizing?.risky ?? false : riskyGiven === "yes",
+    };
     if (phaseGiven !== undefined && clearGiven !== undefined) {
         return fail(write, json, "task route", "usage", "say --phase … --provider … --model … OR --clear-phase …, not both", EXIT.usage);
     }
@@ -11420,6 +11551,7 @@ async function routeTaskCommand(positional, flags, context) {
             return authenticated.ok ? { ok: true } : { ok: false, reason: authenticated.reason };
         },
         ...(riskGiven === undefined ? {} : { risk: riskGiven }),
+        ...(sizeEdit === undefined ? {} : { size: sizeEdit }),
         ...(phase === undefined
             ? {}
             : { override: phaseGiven !== undefined ? { phase: phase, provider: providerGiven, model: modelGiven } : { phase: phase, clear: true } }),
@@ -12215,11 +12347,14 @@ function spendCommand(flags, context) {
     // v105: subscription work is $0; what binds it is its plan's windows, as the provider last said.
     const limits = context.store.providerLimits();
     const windows = limitsView(limits, [], { project: repo => basename(repo), teammate: id => String(id) }, context.clock())?.tiles ?? [];
-    return succeed(context.write, context.json, command, { month: month.name, totalMicrousd: total, unpriced, items: items.length, budgets, limits }, () => [
+    // Sized routing: each tier's tasks, time to a result and plan use, and what the tiers saved.
+    const tiers = tierReport(context.store.handle, month.from, month.to, items);
+    return succeed(context.write, context.json, command, { month: month.name, totalMicrousd: total, unpriced, items: items.length, budgets, limits, tiers: { rows: tiers.rows, saved: tiers.saved } }, () => [
         `${month.name}: ${spendUsd(total)} (${items.length} pieces of work${unpriced > 0 ? `, ${unpriced} unpriced` : ""}; subscription work is $0)`,
         ...windows.map(tile => `  ${`${tile.name} ${tile.window}`.padEnd(24)} ${tile.value}% · ${tile.detail}`),
         ...[...byProject.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([repo, microusd]) => `  ${basename(repo).padEnd(24)} ${spendUsd(microusd)}`),
         ...budgets.map(one => `  budget ${budgetLabel(one, names.get(Number(one.key))).replace(/'s$/, "").padEnd(24)} ${spendUsd(one.spentMicrousd)} of ${spendUsd(one.limitMicrousd)} (${one.percent}%)${one.hardStop ? "" : " alerts only"}`),
+        ...tierLines(tiers, spendUsd),
     ]);
 }
 /** `backup now | list` (sprint 8): back the database up now, or list backups and how the latest ones went. */