toolroll 0.9.27 → 0.9.29

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.9.29 — 2026-10-04
+
+- **Tasks filed from the command line get sized too.** `task scope` now sizes
+  the task from its goal before the plan is sealed, so work the lead files
+  gets the same fast-or-strong model choice as work filed in the console.
+- **A reused process ID no longer blocks finishing a release.** Once
+  Toolroll has recorded that a process exited, a new program taking its
+  number doesn't count as the old one. Leftover process records close when the
+  run ends, and a wait that clears by itself says so instead of asking you to
+  confirm.
+- **Status shows each task once.** A task that is building appears only under
+  Building, an approved plan no longer reads as waiting for review, and risky
+  routes say "Risky" instead of "routine".
+
+## 0.9.28 — 2026-10-04
+
+- **Each task gets the right model.** When a task is filed, a fast
+  classifier on your own subscription sizes it as small, medium or large and
+  flags risky work. Small changes build on a fast model with no plan. Large or
+  risky ones get your strong models for planning and building. The choice is
+  sealed into the plan you approve, with the reason, and you can override it.
+  Where a tier has both Claude and Codex, it picks the one with more of its
+  plan left. `toolroll spend` shows what each tier took.
+- **Nothing gets cut off.** Task goals hold 8,000 characters (up from 2,000),
+  notes 4,000 (up from 500) and flow instructions 8,000. Agents are told each
+  limit before they write and get one chance to shorten. Anything still over
+  is kept whole and linked. Chat messages split instead of cutting.
+
 ## 0.9.27 — 2026-10-04
 
 - **Integrations show their real logos.** Every integration has its own mark

package/dist/agentconfig.js

@@ -234,6 +234,39 @@ export function resolveScopeChain(store, repo, ref, flags, baseAuthMode) {
 }
 const PHASE_NOUN = { plan: "planner", build: "builder", repair: "repair", review: "reviewer" };
 export function resolveRouteCandidates(store, repo, pins = {}) {
+    // The LIGHT tier (v2): the operator's named fast builder, project over
+    // installation, never inherited and never inferred. Only the build phase
+    // has one: a small change makes no plan, and repairs resume the builder.
+    const lightOf = (phase) => {
+        const project = repo === null ? null : store.phaseTierConfig(repo, phase, "light");
+        const row = project ?? store.phaseTierConfig(INSTALLATION_SCOPE, phase, "light");
+        if (row === null)
+            return { ok: true, light: null };
+        const source = project !== null ? "project (light)" : "installation (light)";
+        if (!isProviderId(row.provider) || row.model === null || row.model === "") {
+            return { ok: false, problem: `the ${source} ${PHASE_NOUN[phase]} names ${row.provider}${row.model === null || row.model === "" ? " with no model" : ` · ${row.model}`} — a light agent is an exact pair: \`config set ${phase} --tier light --provider … --model …\`, or \`--clear\` it` };
+        }
+        const valid = validateSpec({ provider: row.provider, model: row.model });
+        if (!valid.ok)
+            return { ok: false, problem: `the ${source} ${PHASE_NOUN[phase]}: ${valid.problem}` };
+        return { ok: true, light: { provider: row.provider, model: row.model, source } };
+    };
+    // Alternates (v2): one more candidate per provider on a tier, project over installation.
+    const alternatesOf = (phase, tier) => {
+        const project = repo === null ? [] : store.phaseTierAlternates(repo, phase, tier);
+        const rows = project.length > 0 ? project : store.phaseTierAlternates(INSTALLATION_SCOPE, phase, tier);
+        const source = `${project.length > 0 ? "project" : "installation"} (${tier}, also)`;
+        const alternates = [];
+        for (const row of rows) {
+            if (!isProviderId(row.provider))
+                return { ok: false, problem: `the ${source} ${PHASE_NOUN[phase]} names unknown provider ${row.provider} — \`config clear ${phase} --also --provider ${row.provider}\`` };
+            const valid = validateSpec({ provider: row.provider, model: row.model });
+            if (!valid.ok)
+                return { ok: false, problem: `the ${source} ${PHASE_NOUN[phase]}: ${valid.problem}` };
+            alternates.push({ provider: row.provider, model: row.model, source });
+        }
+        return { ok: true, alternates };
+    };
     const strongOf = (phase) => {
         const strongProject = repo === null ? null : store.phaseTierConfig(repo, phase, "strong");
         const strongInstallation = store.phaseTierConfig(INSTALLATION_SCOPE, phase, "strong");
@@ -284,7 +317,34 @@ export function resolveRouteCandidates(store, repo, pins = {}) {
             return { ok: false, phase, problem: routine.problem };
         if (!strong.ok)
             return { ok: false, phase, problem: strong.problem };
-        out[phase] = { routine: routine.routine, strong: strong.strong };
+        const light = phase === "build" ? lightOf(phase) : { ok: true, light: null };
+        if (!light.ok)
+            return { ok: false, phase, problem: light.problem };
+        if (phase === "review") {
+            out.review = { routine: routine.routine, strong: strong.strong };
+            continue;
+        }
+        // A tier's candidates on other providers (`--also`), one per provider.
+        const alternates = {};
+        let primary = { light: light.light, strong: strong.strong };
+        for (const tier of (phase === "build" ? ["light", "routine", "strong"] : ["routine", "strong"])) {
+            const read = alternatesOf(phase, tier);
+            if (!read.ok)
+                return { ok: false, phase, problem: read.problem };
+            const own = tier === "routine" ? routine.routine : primary[tier];
+            // With no candidate of its own, a tier's first alternate stands as it.
+            const list = own === null ? read.alternates.slice(1) : read.alternates.filter(one => one.provider !== own.provider);
+            if (own === null && read.alternates[0] !== undefined)
+                primary = { ...primary, [tier]: read.alternates[0] };
+            if (list.length > 0)
+                alternates[tier] = list;
+        }
+        out[phase] = {
+            routine: routine.routine,
+            strong: primary.strong,
+            ...(primary.light === null ? {} : { light: primary.light }),
+            ...(Object.keys(alternates).length === 0 ? {} : { alternates }),
+        };
     }
     // Repair: the configured row is optional (inherit is the law when none
     // exists), but a row that EXISTS must be exact — a provider the policy
@@ -364,6 +424,8 @@ export function routeOfTask(store, taskId, ref, now) {
         candidates: candidates.candidates,
         overrides,
         pins: { plan: planPin.pin, build: buildPin.pin },
+        size: ref?.sizing ?? null,
+        headroom: store.planHeadroom(now),
     });
     return { kind: "route", route, source: "live" };
 }
@@ -424,9 +486,15 @@ export function agentChoicesFor(store, repo, route) {
     const buildProvider = route === null ? candidates.candidates.build.routine.provider : legOf(route, "build").provider;
     const configuredFor = (phase) => {
         const tiers = candidates.candidates[phase];
+        const everyOf = (one) => [
+            one.light ?? null,
+            one.routine,
+            one.strong,
+            ...Object.values(one.alternates ?? {}).flatMap(list => [...(list ?? [])]),
+        ];
         const own = phase === "repair"
-            ? [tiers.routine, tiers.strong, candidates.candidates.build.routine, candidates.candidates.build.strong]
-            : [tiers.routine, tiers.strong];
+            ? [tiers.routine, tiers.strong, ...everyOf(candidates.candidates.build)]
+            : phase === "review" ? [tiers.routine, tiers.strong] : everyOf(candidates.candidates[phase]);
         const out = [];
         for (const one of own) {
             if (one === null || out.some(seen => sameSpec(seen, one)))