toolroll 0.9.27 → 0.9.28

package/dist/phase-routing.js

@@ -67,12 +67,16 @@ function exactModel(v) {
 export function exactModelId(v) {
     return exactModel(v);
 }
-export const ROUTE_VERSION = 1;
+/** v2 adds the task's size (small / medium / large, risky or not), the
+ * light tier, and plan headroom. A v1 route — sealed before sizing — still
+ * reads back exactly and keeps its own digest domain. */
+export const ROUTE_VERSION = 2;
 /** The durable route ERA a scope row carries once it was filed under this
  * policy: NULL on a row proven to predate v47 (legacy — the sealed profile
  * alone governs), this value on every row filed since. A row with an era
- * and no readable route is corrupt and fails closed. */
-export const ROUTE_ERA = ROUTE_VERSION;
+ * and no readable route is corrupt and fails closed. The era marks a ROUTED
+ * row; which route version it holds rides in the snapshot itself. */
+export const ROUTE_ERA = 1;
 export const PHASES = ["plan", "build", "repair", "review"];
 /** The review leg remains readable in signed history but is no longer scheduled. */
 export const ACTIVE_PHASES = ["plan", "build", "repair"];
@@ -80,6 +84,34 @@ export const RISK_LEVELS = ["routine", "elevated", "high"];
 export function isRiskLevel(value) {
     return value === "routine" || value === "elevated" || value === "high";
 }
+export const TASK_SIZES = ["small", "medium", "large"];
+export function isTaskSize(value) {
+    return value === "small" || value === "medium" || value === "large";
+}
+/** Whether a task makes no plan: a small change that is not risky, at
+ * routine risk. Elevated or high risk always plans, whatever the size. */
+export function makesNoPlan(size, risk) {
+    return size != null && size.size === "small" && !size.risky && risk === "routine";
+}
+/** Where a size came from, in words. */
+export function sizeSourceWords(source) {
+    return source === "classifier" ? "sized automatically" : source === "person" ? "set by a person" : "sized from the description";
+}
+/** Strict read of a stored sizing: exact keys, known words, bounded reason. */
+export function parseSizing(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const v = raw;
+    if (!exactKeysOf(v, ["size", "risky", "source", "reason"]))
+        return null;
+    if (!isTaskSize(v["size"]) || typeof v["risky"] !== "boolean")
+        return null;
+    if (v["source"] !== "classifier" && v["source"] !== "heuristic" && v["source"] !== "person")
+        return null;
+    if (typeof v["reason"] !== "string" || v["reason"].length > 300)
+        return null;
+    return { size: v["size"], risky: v["risky"], source: v["source"], reason: v["reason"] };
+}
 export function riskTitle(risk) {
     return risk === "high" ? "High risk" : risk === "elevated" ? "Elevated risk" : "Routine";
 }
@@ -93,10 +125,59 @@ export function riskConsequence(risk) {
     if (risk === "high")
         return "every active role — planner, builder, and repair — uses the strongest agent you have configured";
     if (risk === "elevated")
-        return "planning and building keep the everyday agents unless the work itself asks for more (strict quality or screenshots)";
+        return "planning and building use the strongest agent you have configured";
     return "every role uses the everyday configured agent unless the work itself asks for more (strict quality, screenshots, or a self-merging mode)";
 }
 export const RISK_CHOICES = RISK_LEVELS.map(risk => ({ risk, title: riskTitle(risk), consequence: riskConsequence(risk) }));
+const TIER_RANK = { light: 0, routine: 1, strong: 2 };
+/** Above these a provider has no headroom: even a candidate one tier
+ * stronger on another provider takes the phase. Below them, a tier's
+ * candidates on different providers still go to the one with more room. */
+export const HEADROOM_FIVE_HOUR_LIMIT = 80;
+export const HEADROOM_WEEKLY_LIMIT = 90;
+/** The latest plan-window readings as headroom: a window whose reset time
+ * has passed counts as empty; a reading older than its own window is
+ * unknown. Weekly is the plan-wide week (`seven_day`), else the fullest
+ * model-specific week. */
+export function headroomFrom(limits, now) {
+    const out = new Map();
+    const value = (one) => {
+        if (one.resetsAt !== null && Date.parse(one.resetsAt) <= now.getTime())
+            return 0;
+        const age = now.getTime() - Date.parse(one.observedAt);
+        if (!Number.isFinite(age) || (one.windowMinutes !== null && age > one.windowMinutes * 60_000))
+            return null;
+        return one.usedPercent;
+    };
+    for (const one of limits) {
+        if (!isProviderId(one.provider))
+            continue;
+        const room = out.get(one.provider) ?? { provider: one.provider, fiveHour: null, weekly: null };
+        const used = value(one);
+        if (one.window === "five_hour")
+            room.fiveHour = used;
+        else if (one.window === "seven_day")
+            room.weekly = used;
+        else if (/^seven_day_/.test(one.window) && used !== null && room.weekly === null)
+            room.weekly = used;
+        out.set(one.provider, room);
+    }
+    // A plan-wide week beats a model's week: re-read seven_day last.
+    for (const one of limits)
+        if (isProviderId(one.provider) && one.window === "seven_day")
+            out.get(one.provider).weekly = value(one);
+    return [...out.values()].sort((a, b) => PROVIDER_ID_LIST.indexOf(a.provider) - PROVIDER_ID_LIST.indexOf(b.provider));
+}
+function tightWords(room) {
+    if (room.fiveHour !== null && room.fiveHour > HEADROOM_FIVE_HOUR_LIMIT)
+        return `${room.provider} has used ${room.fiveHour}% of its 5-hour window`;
+    if (room.weekly !== null && room.weekly > HEADROOM_WEEKLY_LIMIT)
+        return `${room.provider} has used ${room.weekly}% of its weekly window`;
+    return null;
+}
+function usedOf(room) {
+    return Math.max(room.fiveHour ?? 0, room.weekly ?? 0);
+}
 const PHASE_NOUN = { plan: "planner", build: "builder", repair: "repair", review: "reviewer" };
 const PHASE_VERB = { plan: "plans", build: "builds", repair: "repairs", review: "reviews" };
 export function specWords(spec) {
@@ -110,8 +191,18 @@ const DEMANDS = [
     },
     {
         when: input => input.risk === "elevated",
-        phases: ["review"],
-        reason: "risk is elevated — the review runs on the strongest configured reviewer",
+        phases: ["plan", "build", "repair", "review"],
+        reason: "risk is elevated — planning and building use the strongest configured agent",
+    },
+    {
+        when: input => input.size?.size === "large",
+        phases: ["plan", "build", "repair"],
+        reason: "a large change — planning and building use the strongest configured agent",
+    },
+    {
+        when: input => input.size?.risky === true,
+        phases: ["plan", "build", "repair"],
+        reason: "a risky change — planning and building use the strongest configured agent",
     },
     {
         when: input => input.qualityMode === "strict",
@@ -164,9 +255,24 @@ export function recommendRoute(input) {
         .sort((a, b) => PHASES.indexOf(a.phase) - PHASES.indexOf(b.phase));
     const overrideFor = (phase) => overrides.find(one => one.phase === phase) ?? null;
     const legs = [];
+    // Elevated or high risk lifts both legs through the table, so it never reaches the small branches.
+    const small = input.size?.size === "small";
     const pick = (phase) => {
+        const chosen = pickTier(phase);
+        return phase === "review" ? { ...chosen, moved: false } : withHeadroom(input, phase, chosen);
+    };
+    const pickTier = (phase) => {
         const demanded = demandedTier(input, phase);
         const candidates = input.candidates[phase];
+        if (demanded.tier === "routine" && small && phase === "build") {
+            const light = candidates.light ?? null;
+            if (light !== null)
+                return { spec: light, tier: "light", reasons: ["small change — a fast model builds it and no plan is made", `light builder from ${light.source}`] };
+            return { spec: candidates.routine, tier: "routine", reasons: ["small change — no plan is made; no light builder is configured, so the configured builder runs it", `configured builder from ${candidates.routine.source}`] };
+        }
+        if (demanded.tier === "routine" && small && phase === "plan") {
+            return { spec: candidates.routine, tier: "routine", reasons: ["small change — no plan is made", `configured planner from ${candidates.routine.source}`] };
+        }
         if (demanded.tier === "strong") {
             if (candidates.strong !== null) {
                 return { spec: candidates.strong, tier: "strong", reasons: [...demanded.reasons, `strong ${PHASE_NOUN[phase]} from ${candidates.strong.source}`] };
@@ -199,11 +305,15 @@ export function recommendRoute(input) {
         }
     }
     // build — pin > override > recommendation.
+    let buildMoved = false;
     const build = (() => {
         const rec = pick("build");
+        buildMoved = rec.moved;
         const pin = input.pins?.build ?? null;
         const override = overrideFor("build");
         const recommended = { provider: rec.spec.provider, model: rec.spec.model, tier: rec.tier };
+        if (pin !== null || override !== null)
+            buildMoved = false;
         const leg = pin !== null
             ? { phase: "build", provider: pin.provider, model: pin.model, tier: rec.tier, chosen: "pinned", recommended, reasons: [`pinned to ${specWords(pin)} by the firing that filed this task — nothing overrides a pin`], problem: null }
             : override !== null
@@ -225,7 +335,15 @@ export function recommendRoute(input) {
         let tier;
         let reasons;
         let problem = null;
-        if (demanded.tier === "strong" && candidates.strong !== null) {
+        // A build moved to another provider for headroom takes its repairs
+        // with it: repair rows on the provider it left cannot resume its session.
+        const usedRow = demanded.tier === "strong" && candidates.strong !== null ? candidates.strong : candidates.routine;
+        if (buildMoved && usedRow !== null && usedRow.provider !== build.provider) {
+            model = build.model;
+            tier = "routine";
+            reasons = [`the build moved to ${build.provider} for plan headroom — repairs resume its session with the build model (${build.model})`];
+        }
+        else if (demanded.tier === "strong" && candidates.strong !== null) {
             if (candidates.strong.provider === build.provider) {
                 model = candidates.strong.model;
                 tier = "strong";
@@ -311,6 +429,64 @@ export function recommendRoute(input) {
         demands,
         legs,
         overrides,
+        size: input.size ?? null,
+    };
+}
+/**
+ * PLAN HEADROOM (v2), at filing:
+ *
+ *   - a tier with candidates on more than one provider (`--also`) runs on
+ *     the provider with more plan room — the lower window use — so work
+ *     spreads across plans before either fills;
+ *   - a chosen provider past its limits (80% of the 5-hour window, 90% of
+ *     the weekly) gives way to the roomiest other provider at the same
+ *     tier or one tier stronger, never weaker.
+ *
+ * Readings are the providers' own; a provider with no reading is unknown,
+ * never "empty", so nothing moves toward or away from it on a guess. Ties
+ * keep the tier's own candidate. The choice and its reason are sealed with
+ * the route.
+ */
+function withHeadroom(input, phase, chosen) {
+    const rooms = input.headroom ?? [];
+    const roomOf = (provider) => {
+        const room = rooms.find(one => one.provider === provider) ?? null;
+        return room !== null && (room.fiveHour !== null || room.weekly !== null) ? room : null;
+    };
+    const current = roomOf(chosen.spec.provider);
+    if (current === null)
+        return { ...chosen, moved: false };
+    const tight = tightWords(current);
+    const candidates = input.candidates[phase];
+    const pool = [];
+    for (const tier of ["light", "routine", "strong"]) {
+        const own = tier === "light" ? candidates.light ?? null : tier === "routine" ? candidates.routine : candidates.strong;
+        for (const spec of [own, ...(candidates.alternates?.[tier] ?? [])]) {
+            if (spec === null || spec.provider === chosen.spec.provider || pool.some(one => one.spec.provider === spec.provider && one.tier === tier))
+                continue;
+            // Not tight: only the same tier competes on room. Tight: one tier stronger may take it too.
+            if (tight === null ? tier !== chosen.tier : TIER_RANK[tier] < TIER_RANK[chosen.tier] || TIER_RANK[tier] > TIER_RANK[chosen.tier] + 1)
+                continue;
+            pool.push({ spec, tier });
+        }
+    }
+    if (pool.length === 0)
+        return { ...chosen, moved: false };
+    const open = pool
+        .map(one => ({ ...one, room: roomOf(one.spec.provider) }))
+        .filter((one) => one.room !== null && tightWords(one.room) === null)
+        .filter(one => tight !== null || usedOf(one.room) < usedOf(current))
+        .sort((a, b) => usedOf(a.room) - usedOf(b.room) || TIER_RANK[a.tier] - TIER_RANK[b.tier]);
+    const best = open[0];
+    if (best === undefined) {
+        return tight === null ? { ...chosen, moved: false } : { ...chosen, reasons: [...chosen.reasons, `plan headroom: ${tight}, and no other configured ${PHASE_NOUN[phase]} has room — kept`], moved: false };
+    }
+    const why = tight ?? `${chosen.spec.provider} has used ${usedOf(current)}% of its plan`;
+    return {
+        spec: best.spec,
+        tier: best.tier,
+        reasons: [...chosen.reasons.slice(0, -1), `plan headroom: ${why} — ${best.spec.provider} has more room (${usedOf(best.room)}% used), so its ${best.tier} ${PHASE_NOUN[phase]} from ${best.spec.source} runs it`],
+        moved: true,
     };
 }
 /** Whether any leg actually runs a configured strong agent. */
@@ -367,6 +543,8 @@ export function canonicalRouteJson(route) {
             problem: leg.problem,
         })),
         overrides: route.overrides.map(one => ({ phase: one.phase, provider: one.provider, model: one.model, by: one.by, at: one.at })),
+        // v2 carries the size it was routed for; a v1 snapshot's bytes never change.
+        ...(route.version === 1 ? {} : { size: route.size === null ? null : { size: route.size.size, risky: route.size.risky, source: route.size.source, reason: route.size.reason } }),
     });
 }
 /** sha256 over a domain-separated canonical encoding, truncated to the
@@ -374,7 +552,7 @@ export function canonicalRouteJson(route) {
  * route digest can never collide with a profile or chain digest. */
 export function routeDigestOf(route) {
     return createHash("sha256")
-        .update(`standing-orders:route:v${ROUTE_VERSION}:${canonicalRouteJson(route)}`, "utf8")
+        .update(`standing-orders:route:v${route.version}:${canonicalRouteJson(route)}`, "utf8")
         .digest("hex")
         .slice(0, 32);
 }
@@ -413,9 +591,17 @@ export function routeFromJson(json) {
     // Exact keys (v48 integrity): the snapshot carries what canonicalRouteJson
     // writes and nothing else — on the route, on every leg, on every leg's
     // recommendation, and on every override.
-    if (!exactKeysOf(r, ["version", "risk", "qualityMode", "publication", "evidence", "posture", "demands", "legs", "overrides"]))
+    // A v1 route (sealed before sizing) reads back exactly as it was written:
+    // no size, routine and strong tiers only.
+    const version = r["version"];
+    if (version !== 1 && version !== 2)
+        return null;
+    const v1Keys = ["version", "risk", "qualityMode", "publication", "evidence", "posture", "demands", "legs", "overrides"];
+    if (!exactKeysOf(r, version === 1 ? v1Keys : [...v1Keys, "size"]))
         return null;
-    if (r["version"] !== ROUTE_VERSION)
+    const tierOk = (tier) => tier === "routine" || tier === "strong" || (version === 2 && tier === "light");
+    const size = version === 1 || r["size"] === null ? null : parseSizing(r["size"]);
+    if (version === 2 && r["size"] !== null && size === null)
         return null;
     if (!isRiskLevel(r["risk"]))
         return null;
@@ -445,7 +631,7 @@ export function routeFromJson(json) {
             return null;
         if (!exactModel(leg["model"]))
             return null;
-        if (leg["tier"] !== "routine" && leg["tier"] !== "strong")
+        if (!tierOk(leg["tier"]))
             return null;
         if (leg["chosen"] !== "recommended" && leg["chosen"] !== "override" && leg["chosen"] !== "pinned")
             return null;
@@ -459,7 +645,7 @@ export function routeFromJson(json) {
             return null;
         if (!exactModel(recommended["model"]))
             return null;
-        if (recommended["tier"] !== "routine" && recommended["tier"] !== "strong")
+        if (!tierOk(recommended["tier"]))
             return null;
         if (!stringList(leg["reasons"]))
             return null;
@@ -484,7 +670,7 @@ export function routeFromJson(json) {
     if (overrides === null)
         return null;
     return {
-        version: ROUTE_VERSION,
+        version,
         risk: r["risk"],
         qualityMode: r["qualityMode"],
         publication: r["publication"],
@@ -493,6 +679,7 @@ export function routeFromJson(json) {
         demands: [...r["demands"]],
         legs,
         overrides,
+        size,
     };
 }
 /** Strict parse of an override list: one per phase, every field proved,
@@ -545,7 +732,25 @@ export function canonicalOverridesJson(overrides) {
 }
 /** What actually runs: stronger agents only when a leg draws from one. */
 export function postureWords(route) {
-    return drawsStrong(route.legs.filter(leg => leg.phase !== "review")) ? "stronger configured agents" : "everyday configured agents";
+    const active = route.legs.filter(leg => leg.phase !== "review");
+    if (drawsStrong(active))
+        return "stronger configured agents";
+    return active.some(leg => leg.phase === "build" && leg.chosen === "recommended" && leg.tier === "light") ? "a fast configured agent" : "everyday configured agents";
+}
+/** The size line, plainly: what the size does to this route. */
+export function sizeWords(route) {
+    if (route.size === null)
+        return null;
+    const build = route.legs.find(leg => leg.phase === "build");
+    // Said from the build leg that actually runs: another demand (strict quality, screenshots) can lift it.
+    const model = build?.tier === "light" ? "fast model" : build?.tier === "strong" ? "strongest model" : "everyday model";
+    if (makesNoPlan(route.size, route.risk))
+        return `Small change: ${model}, no plan`;
+    // Elevated or high risk plans a small change too.
+    const label = route.size.size === "large" ? "Large change" : route.size.size === "small" ? (route.size.risky ? "Small but risky change" : "Small change") : route.size.risky ? "Risky change" : "Medium change";
+    if (route.size.size !== "large" && !route.size.risky && route.risk === "routine")
+        return build?.tier === "strong" ? "Medium change: strongest agents" : "Medium change: everyday agents";
+    return build?.tier === "strong" ? `${label}: strongest agents plan and build` : `${label}: planned first, everyday agents (no stronger agent is configured)`;
 }
 export function readinessWords(state, reason) {
     if (state === "ready")
@@ -555,7 +760,7 @@ export function readinessWords(state, reason) {
     return `readiness unknown${reason === null ? "" : ` — ${reason}`}`;
 }
 export function chosenWords(leg) {
-    return leg.chosen === "override" ? "overridden" : leg.chosen === "pinned" ? "pinned" : leg.tier === "strong" ? "recommended · strong" : "recommended";
+    return leg.chosen === "override" ? "overridden" : leg.chosen === "pinned" ? "pinned" : leg.tier === "strong" ? "recommended · strong" : leg.tier === "light" ? "recommended · fast" : "recommended";
 }
 /**
  * The one-line Agents summary every surface can show above the details:
@@ -565,7 +770,9 @@ export function chosenWords(leg) {
  */
 export function agentsSummary(route) {
     const groups = [];
-    for (const leg of route.legs.filter(leg => leg.phase !== "review")) {
+    // A small change makes no plan: its planner is not one of the agents that work on it.
+    const unplanned = makesNoPlan(route.size, route.risk ?? "routine");
+    for (const leg of route.legs.filter(leg => leg.phase !== "review" && !(unplanned && leg.phase === "plan" && leg.chosen === "recommended"))) {
         const spec = specWords(leg);
         const group = groups.find(one => one.spec === spec);
         if (group === undefined)
@@ -607,6 +814,10 @@ export function projectRoute(route, readiness) {
         summary: agentsSummary(route),
         halted: legs.some(leg => leg.readiness === "unavailable"),
         problems: routeProblems(route),
+        size: route.size,
+        sizeWords: sizeWords(route),
+        // A person's size already says who set it.
+        sizeReason: route.size === null ? null : route.size.source === "person" && route.size.reason !== "" ? route.size.reason : `${route.size.reason === "" ? "" : `${route.size.reason} · `}${sizeSourceWords(route.size.source)}`,
     };
 }
 /** The approval-card lines: one route header, one line per leg, then the
@@ -615,6 +826,7 @@ export function routeWords(projection, indent = "  ") {
     const pad = `${indent}             `;
     return [
         `${indent}route        ${projection.riskTitle.toLowerCase()} · ${projection.postureWords} · ${projection.digest}`,
+        ...(projection.sizeWords === null ? [] : [`${indent}size         ${projection.sizeWords} — ${projection.sizeReason}`]),
         `${pad}${projection.summary}`,
         ...projection.legs.flatMap(leg => [`${pad}${leg.words}`, ...leg.reasons.map(reason => `${pad}    ${reason}`)]),
         ...(projection.halted ? [`${pad}HALTED: a provider on this route is reported unavailable — nothing substitutes; override the phase or restore the provider`] : []),

package/dist/project-skills.d.ts

@@ -123,6 +123,11 @@ export declare function testSkill(store: Store, args: {
     ok: true;
     id: string;
     planning: boolean;
+    sizing: import("./phase-routing.js").TaskSizing;
+} | {
+    ok: true;
+    id: string;
+    planning: boolean;
 };
 /** Exact finished test result; report feedback never pretends a code diff exists. */
 export declare function skillTestResult(store: Store, runId: number, actor: string): {
@@ -143,6 +148,11 @@ export declare function reviseSkillTest(store: Store, args: {
     ok: true;
     id: string;
     planning: boolean;
+    sizing: import("./phase-routing.js").TaskSizing;
+} | {
+    ok: true;
+    id: string;
+    planning: boolean;
 };
 /** Public GitHub folders only, pinned to a commit before reading any package bytes. */
 export declare function githubSkill(url: string, fetcher?: typeof fetch): Promise<{

package/dist/proposal.d.ts

@@ -3,6 +3,7 @@ export { validateTaskText } from "./task-text.js";
 import type { Store } from "./store.js";
 import { type UnattendedPermissionMode } from "./scope.js";
 import type { QualityMode } from "./quality.js";
+import type { TaskSizing } from "./phase-routing.js";
 export type ProposalRefusal = {
     ok: false;
     /** Stable, machine-readable — joins the envelope like every reason. */
@@ -47,11 +48,17 @@ export type TaskProposalInput = {
      * which is the fail-closed reading of an empty ceiling (finding 4).
      */
     admittedRepos?: readonly string[];
+    /** v2 routing: the task's size when the caller already knows it (a
+     * person's choice). Absent, filing sizes it from the description at
+     * once and the process's classifier refines it within five seconds. */
+    sizing?: TaskSizing;
 };
 /** One deterministic planning policy for console, chat, MCP, and sync
  * filings. A planner needs a repository to inspect; report/scout work is
- * already the discovery phase and never recursively plans itself. */
-export declare function shouldPlanTask(input: TaskProposalInput): boolean;
+ * already the discovery phase and never recursively plans itself. With a
+ * size (v2 routing), a small change is not planned and a large or risky
+ * one is; a medium one keeps the description's signals. */
+export declare function shouldPlanTask(input: TaskProposalInput, sizing?: TaskSizing): boolean;
 export type RoutineProposalInput = {
     name: string;
     /** v102: who is making it (its instances are filed as theirs). */
@@ -74,6 +81,7 @@ export declare function fileTaskProposal(store: Store, input: TaskProposalInput,
     ok: true;
     id: string;
     planning: boolean;
+    sizing: TaskSizing;
 } | ProposalRefusal;
 export declare function fileRoutineProposal(store: Store, input: RoutineProposalInput, now: Date): {
     ok: true;

package/dist/proposal.js

@@ -33,14 +33,16 @@ import { hasForbiddenControls, hasDisguisedText } from "./decision.js";
 import { canonicalProject } from "./project.js";
 import { ROUTINE_NAME, routineDigestOf, validateRoutineTerms, } from "./routine.js";
 import { parseAcceptanceCriteria } from "./scope.js";
+import { heuristicSizing, planningSignals, refineFiledSizing } from "./task-sizing.js";
 /** Provenance tokens are part of the audit surface: lowercase, bounded,
  * nothing that could render as anything but itself. */
 const FILED_VIA = /^[a-z][a-z0-9:-]{0,63}$/;
-const SUBSTANTIAL_WORK = /\b(?:architecture|end[- ]to[- ]end|migrat(?:e|ion)|moderni[sz]e|redesign|refactor|rework|workflow|navigation|accessibility|responsive|performance|security|unif(?:y|ied)|multi[- ](?:step|project|service))\b/i;
 /** One deterministic planning policy for console, chat, MCP, and sync
  * filings. A planner needs a repository to inspect; report/scout work is
- * already the discovery phase and never recursively plans itself. */
-export function shouldPlanTask(input) {
+ * already the discovery phase and never recursively plans itself. With a
+ * size (v2 routing), a small change is not planned and a large or risky
+ * one is; a medium one keeps the description's signals. */
+export function shouldPlanTask(input, sizing) {
     if (input.deliverable === "report" || input.planning === "skip")
         return false;
     // Remote coordinators only propose work. Keep their submissions quarantined
@@ -52,11 +54,13 @@ export function shouldPlanTask(input) {
         return false;
     if (input.planning === "required")
         return true;
-    const goal = input.goal ?? "";
-    const descriptionSize = input.title.length + goal.length + (input.outOfScope?.length ?? 0);
-    return ((input.touches?.length ?? 0) >= 2 ||
-        descriptionSize >= 280 ||
-        SUBSTANTIAL_WORK.test(`${input.title}\n${goal}`));
+    if (sizing !== undefined) {
+        if (sizing.size === "small" && !sizing.risky)
+            return false;
+        if (sizing.size === "large" || sizing.risky)
+            return true;
+    }
+    return planningSignals(input);
 }
 function refuse(reason, message) {
     return { ok: false, reason, message };
@@ -100,6 +104,8 @@ export function fileTaskProposal(store, input, now) {
     const badText = validateTaskText(input);
     if (badText !== null)
         return badText;
+    // Sized at once from the description; filing never waits for a model.
+    const sizing = input.sizing ?? heuristicSizing(input);
     const outOfScope = input.outOfScope ?? null;
     const touches = input.touches ?? [];
     const repo = checkRepo(input.repo, input.admittedRepos);
@@ -120,6 +126,7 @@ export function fileTaskProposal(store, input, now) {
         ...(input.filedBy === undefined ? {} : { filedBy: input.filedBy }),
         proposedVia: input.proposedVia ?? null,
         ...(input.deliverable === undefined ? {} : { deliverable: input.deliverable }),
+        sizing,
     }, now);
     if (!made.ok) {
         return refuse(made.reason, made.reason === "backlog-full"
@@ -131,12 +138,20 @@ export function fileTaskProposal(store, input, now) {
                     : `the store refused the filing: ${made.reason}`);
     }
     let planning = false;
-    if (shouldPlanTask({ ...input, ...(repo.repo === undefined ? {} : { repo: repo.repo }) })) {
+    const placed = { ...input, ...(repo.repo === undefined ? {} : { repo: repo.repo }) };
+    if (shouldPlanTask(placed, sizing)) {
         const ref = store.lookupRef(made.id);
         if (ref !== null)
             planning = store.requestPlan(ref.id, now).ok;
     }
-    return { ok: true, id: made.id, planning };
+    // The classifier (when this process has one) answers within five seconds
+    // and re-files the still-unapproved scope with its size. Never for work
+    // that builds nothing, or for an untrusted remote proposal.
+    if (input.sizing === undefined && repo.repo !== undefined && input.goal !== undefined && input.deliverable !== "report" &&
+        input.proposedVia !== "coordinator" && !input.filedVia.startsWith("mcp:")) {
+        void refineFiledSizing(store, made.id, placed, input.planning === undefined || input.planning === "auto");
+    }
+    return { ok: true, id: made.id, planning, sizing };
 }
 export function fileRoutineProposal(store, input, now) {
     if (!FILED_VIA.test(input.filedVia)) {

package/dist/recipe-ui.js

@@ -1,3 +1,4 @@
+import { TASK_TEXT_LIMITS } from "./task-text.js";
 import { composerSchedule, scheduleEditorHtml, scheduleEditorScript } from "./task-composer.js";
 import { parseRecipe, workflowSteps, recipeScheduleWords, RecipeError, RECIPE_INPUT_LIMIT } from "./recipes.js";
 import { ACCEPTANCE_LIMITS } from "./scope.js";
@@ -76,7 +77,7 @@ export function recipeEditorHtml(recipe, repo, csrf, revision, problem = null, v
     return `<a href="/recipes" class="meta">← All recipes</a><div class="recipe-heading"><p class="recipe-kicker">${creator ? "1 · Describe → 2 · Preview → 3 · Save" : "1 · Choose → 2 · Customize → 3 · Preview"}</p><h1>${creator ? "Create a reusable recipe" : "Make this workflow yours"}</h1><p class="hint">${e(repo.split(/[\\/]/).pop() || repo)} · Choose the outcome, boundaries, and proof you want back.</p></div>` +
         (problem === null ? "" : `<p role="alert" class="card recipe-error">${e(problem)}</p>`) +
         `<form method="post" action="/recipes/preview" class="recipe-editor">${hidden("csrf", csrf)}${hidden("repo", repo)}${hidden("projectRevision", String(revision))}${hidden("source", recipe.id)}${hidden("sourceRevision", String(recipe.revision))}${hidden("sourceFormat", value("sourceFormat", String(d.version)))}` +
-        `<section class="card"><h2>The outcome</h2><label>${creator ? "Recipe name" : "Workflow name"}<input type="text" name="name" value="${e(value("name", d.name))}" maxlength="200" required></label><label>Short description<input type="text" name="description" value="${e(value("description", d.description))}" maxlength="400"></label><label>What should the agent do?<textarea name="goal" rows="5" maxlength="2000" required>${e(value("goal", d.goal))}</textarea></label><label>What should it leave alone?<textarea name="not" rows="3" maxlength="2000">${e(value("not", d.outOfScope ?? ""))}</textarea></label><label>Allowed files or folders <span class="meta">optional; one per line</span><textarea name="touches" rows="2" placeholder="src/&#10;tests/">${e(value("touches", d.touches.join("\n")))}</textarea></label><p class="meta">Blank allows work across this project. Add paths to keep the workflow focused.</p></section>` +
+        `<section class="card"><h2>The outcome</h2><label>${creator ? "Recipe name" : "Workflow name"}<input type="text" name="name" value="${e(value("name", d.name))}" maxlength="200" required></label><label>Short description<input type="text" name="description" value="${e(value("description", d.description))}" maxlength="400"></label><label>What should the agent do?<textarea name="goal" rows="5" maxlength="${TASK_TEXT_LIMITS.text}" required>${e(value("goal", d.goal))}</textarea></label><label>What should it leave alone?<textarea name="not" rows="3" maxlength="${TASK_TEXT_LIMITS.text}">${e(value("not", d.outOfScope ?? ""))}</textarea></label><label>Allowed files or folders <span class="meta">optional; one per line</span><textarea name="touches" rows="2" placeholder="src/&#10;tests/">${e(value("touches", d.touches.join("\n")))}</textarea></label><p class="meta">Blank allows work across this project. Add paths to keep the workflow focused.</p></section>` +
         recipeQuestionsHtml(d, values) +
         `<section class="card"><h2>What does success look like?</h2><p class="hint">Give each outcome the evidence you want to see. The workflow checks these before calling the work done.</p><div data-recipe-criteria>${Array.from({ length: count }, (_, i) => criterionHtml(i, d.acceptance[i], values)).join("")}</div><button type="button" data-add-criterion hidden>Add another success check</button><template data-criterion-template>${criterionHtml(11).replaceAll("criterion-11-", "criterion-INDEX-").replaceAll('value="c12"', 'value="cNEXT"')}</template></section>` +
         `<section class="card"><h2>How it should run</h2><div class="recipe-options"><label>Result<select name="deliverable"><option value="branch"${deliverable === "branch" ? " selected" : ""}>Code change with evidence</option><option value="report"${deliverable === "report" ? " selected" : ""}>Report without code changes</option></select></label><label>Planning<select name="planning">${[["auto", "Plan when helpful"], ["required", "Always plan first"], ["skip", "Use this scope directly"]].map(([id, label]) => `<option value="${id}"${planning === id ? " selected" : ""}>${label}</option>`).join("")}</select></label></div><p class="meta">Report work investigates directly. Repeating work reuses its approved scope; plan-first workflows run once.</p><label>Frequency<select name="cadence" data-recipe-cadence><option value="once"${cadence === "once" ? " selected" : ""}>Run once</option><option value="repeat"${cadence === "repeat" ? " selected" : ""}>Repeat on a schedule</option></select></label><div data-recipe-recurring>${scheduleEditorHtml(d.schedule, values)}<label>Weekly spending limit <span class="meta">optional, USD</span><input type="number" name="ceiling" min="0.01" step="0.01" value="${e(value("ceiling", d.costCeilingUsd === null ? "" : String(d.costCeilingUsd)))}"></label><p class="meta">One instance at a time. A spending limit requires an agent that reports dollar costs; approval checks this.</p></div></section>` +

package/dist/scout-report.d.ts

@@ -47,15 +47,17 @@ export type ReportParseResult = {
     problems: ReportProblem[];
 };
 /** Caps are BYTES of UTF-8 (v4 review, finding 11): a 64 KiB report is
- * 64 KiB whatever script it is written in. */
+ * 64 KiB whatever script it is written in. They hold what a scout writes;
+ * a stored report is read without them (parseReport's `stored`). */
 export declare const REPORT_LIMITS: {
     readonly payload: number;
     readonly title: 200;
-    readonly summary: 1000;
+    readonly summary: 2500;
     readonly document: number;
     readonly followUps: 5;
     readonly followUpTitle: 200;
-    readonly followUpGoal: 2000;
+    /** A follow-up files as a task: its goal is held to the task goal limit, in bytes of the same count. */
+    readonly followUpGoal: 8000;
     readonly items: 6;
     readonly itemTitle: 200;
     readonly itemWhy: 1000;
@@ -199,4 +201,8 @@ export declare const SCOUT_OUTPUT_JSON_SCHEMA: {
     readonly required: readonly ["kind"];
     readonly additionalProperties: false;
 };
-export declare function parseReport(raw: string): ReportParseResult;
+/** A report, checked. `stored`: one already kept as evidence, read without the length caps (a report written under
+ * higher limits stays readable); every other check still holds. */
+export declare function parseReport(raw: string, options?: {
+    stored?: boolean;
+}): ReportParseResult;

package/dist/scout-report.js

@@ -7,16 +7,20 @@
  * the park discipline exactly as the plan does.
  */
 import { hasForbiddenControls } from "./decision.js";
+import { TASK_TEXT_LIMITS } from "./task-text.js";
+import { TEXT_LIMITS } from "./text-limits.js";
 /** Caps are BYTES of UTF-8 (v4 review, finding 11): a 64 KiB report is
- * 64 KiB whatever script it is written in. */
+ * 64 KiB whatever script it is written in. They hold what a scout writes;
+ * a stored report is read without them (parseReport's `stored`). */
 export const REPORT_LIMITS = {
     payload: 96 * 1024,
     title: 200,
-    summary: 1_000,
+    summary: TEXT_LIMITS.reportSummary,
     document: 64 * 1024,
     followUps: 5,
     followUpTitle: 200,
-    followUpGoal: 2_000,
+    /** A follow-up files as a task: its goal is held to the task goal limit, in bytes of the same count. */
+    followUpGoal: TASK_TEXT_LIMITS.text,
     items: 6,
     itemTitle: 200,
     itemWhy: 1_000,
@@ -128,7 +132,7 @@ function prose(value, field, cap, problems) {
         problems.push({ reason: `bad-${field}`, message: `${field} must be a string (got ${describe(value)})` });
         return null;
     }
-    if (Buffer.byteLength(value, "utf8") > cap) {
+    if (!readingStored && Buffer.byteLength(value, "utf8") > cap) {
         problems.push({ reason: `${field}-too-long`, message: `${field} is over ${cap} bytes` });
         return null;
     }
@@ -138,8 +142,21 @@ function prose(value, field, cap, problems) {
     }
     return value;
 }
-export function parseReport(raw) {
-    if (Buffer.byteLength(raw, "utf8") > REPORT_LIMITS.payload) {
+/** True while a stored report is read: a limit is for writing, and reading never re-checks a text's length. */
+let readingStored = false;
+/** A report, checked. `stored`: one already kept as evidence, read without the length caps (a report written under
+ * higher limits stays readable); every other check still holds. */
+export function parseReport(raw, options = {}) {
+    readingStored = options.stored === true;
+    try {
+        return parseReportBody(raw);
+    }
+    finally {
+        readingStored = false;
+    }
+}
+function parseReportBody(raw) {
+    if (!readingStored && Buffer.byteLength(raw, "utf8") > REPORT_LIMITS.payload) {
         return refuse("too-large", `the payload is over ${REPORT_LIMITS.payload} bytes`);
     }
     let parsed;