toolroll 0.9.27 → 0.9.29

package/dist/phase-routing.d.ts

@@ -56,11 +56,16 @@ export declare const MODEL_ID_SHAPE: RegExp;
 /** The same exactness for callers outside this policy (the profile
  * rehydrator): one shape, one definition. */
 export declare function exactModelId(v: unknown): v is string;
-export declare 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 declare const ROUTE_VERSION = 2;
+export type RouteVersion = 1 | 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. */
+ * 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 declare const ROUTE_ERA = 1;
 export declare const PHASES: readonly Phase[];
 /** The review leg remains readable in signed history but is no longer scheduled. */
@@ -68,6 +73,25 @@ export declare const ACTIVE_PHASES: readonly Phase[];
 export type RiskLevel = "routine" | "elevated" | "high";
 export declare const RISK_LEVELS: readonly RiskLevel[];
 export declare function isRiskLevel(value: unknown): value is RiskLevel;
+/** How big a change the task is, sized once at filing (by the classifier,
+ * by the description when it cannot answer, or by a person). */
+export type TaskSize = "small" | "medium" | "large";
+export declare const TASK_SIZES: readonly TaskSize[];
+export type SizeSource = "classifier" | "heuristic" | "person";
+export type TaskSizing = {
+    size: TaskSize;
+    risky: boolean;
+    source: SizeSource;
+    reason: string;
+};
+export declare function isTaskSize(value: unknown): value is TaskSize;
+/** 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 declare function makesNoPlan(size: TaskSizing | null | undefined, risk: RiskLevel): boolean;
+/** Where a size came from, in words. */
+export declare function sizeSourceWords(source: SizeSource): string;
+/** Strict read of a stored sizing: exact keys, known words, bounded reason. */
+export declare function parseSizing(raw: unknown): TaskSizing | null;
 export declare function riskTitle(risk: RiskLevel): string;
 /**
  * What declaring each risk level DOES, in one plain sentence — derived
@@ -95,7 +119,7 @@ export type ReadinessObservation = {
     observedAt: string;
     runner: string;
 };
-export type CandidateTier = "routine" | "strong";
+export type CandidateTier = "light" | "routine" | "strong";
 /** An exact agent: provider and model id, both required. */
 export type ExactSpec = {
     provider: ProviderId;
@@ -106,10 +130,21 @@ export type RouteCandidate = ExactSpec & {
     source: string;
 };
 export type PhaseCandidates = {
+    /** The operator's named LIGHT (fast) builder (`config set build --tier
+     * light …`), or null/absent when none is configured. A small change
+     * builds on it. Never inferred; the plan phase has none (a small change
+     * makes no plan). */
+    light?: RouteCandidate | null;
     routine: RouteCandidate;
     /** The operator's named strong agent for this phase, or null when none
      * is configured. Never inferred. */
     strong: RouteCandidate | null;
+    /** v2: a tier may hold one more candidate per OTHER provider (`config
+     * set <phase> [--tier …] --also --provider … --model …`) — e.g. a
+     * routine builder on claude and on codex. At filing the one whose
+     * provider has more plan room runs. Each list holds providers other
+     * than its tier's own candidate, at most one each. */
+    alternates?: Partial<Record<CandidateTier, readonly RouteCandidate[]>>;
 };
 /** The repair phase's candidates: with no repair row configured the
  * routine candidate is null and the leg INHERITS the build leg's exact
@@ -138,6 +173,30 @@ export type RouteEvidenceKind = "check" | "screenshot" | "changed-path" | "manua
  * grant at all, a grant whose merges wait for a human (notify), or a live
  * mode that merges by itself (automerge). */
 export type PublicationAuthority = "none" | "notify" | "automerge";
+/** How much of one provider's plan is used, as it last said: the 5-hour
+ * window and the weekly window, in percent; null when unknown. */
+export type ProviderRoom = {
+    provider: ProviderId;
+    fiveHour: number | null;
+    weekly: number | null;
+};
+/** 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 declare const HEADROOM_FIVE_HOUR_LIMIT = 80;
+export declare 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 declare function headroomFrom(limits: readonly {
+    provider: string;
+    window: string;
+    usedPercent: number;
+    windowMinutes: number | null;
+    resetsAt: string | null;
+    observedAt: string;
+}[], now: Date): ProviderRoom[];
 export type RouteInput = {
     risk: RiskLevel;
     qualityMode: QualityMode;
@@ -153,6 +212,13 @@ export type RouteInput = {
         build?: ExactSpec | null;
         repair?: ExactSpec | null;
     };
+    /** How big the change is (v2): small builds on the light tier with no
+     * plan; large or risky plans and builds on the strong tier. */
+    size?: TaskSizing | null;
+    /** Each provider's plan headroom at filing (v2): when a tier has
+     * candidates on more than one provider, the one with more room runs; a
+     * provider past its limits gives way even to a stronger tier. */
+    headroom?: readonly ProviderRoom[];
 };
 export type RouteLeg = {
     phase: Phase;
@@ -178,7 +244,7 @@ export type RouteLeg = {
     problem: string | null;
 };
 export type PhaseRoute = {
-    version: typeof ROUTE_VERSION;
+    version: RouteVersion;
     risk: RiskLevel;
     qualityMode: QualityMode;
     publication: PublicationAuthority;
@@ -192,6 +258,9 @@ export type PhaseRoute = {
     demands: string[];
     legs: RouteLeg[];
     overrides: RouteOverride[];
+    /** The task's size as it was routed (v2); null on a v1 route or an
+     * unsized task. */
+    size: TaskSizing | null;
 };
 export declare function specWords(spec: {
     provider: string;
@@ -259,9 +328,18 @@ export type RouteProjection = {
     halted: boolean;
     /** Every stated leg problem, phase-prefixed. */
     problems: string[];
+    /** The size the route was made for (v2), or null. */
+    size: TaskSizing | null;
+    /** The plain line an approval card leads with — "Small change: fast
+     * model, no plan" — or null on an unsized route. */
+    sizeWords: string | null;
+    /** Why it was sized so, and by whom, or null. */
+    sizeReason: string | null;
 };
 /** What actually runs: stronger agents only when a leg draws from one. */
 export declare function postureWords(route: Pick<PhaseRoute, "legs">): string;
+/** The size line, plainly: what the size does to this route. */
+export declare function sizeWords(route: Pick<PhaseRoute, "legs" | "size" | "risk">): string | null;
 export declare function readinessWords(state: ReadinessState, reason: string | null): string;
 export declare function chosenWords(leg: Pick<RouteLeg, "chosen" | "tier">): string;
 /**
@@ -270,7 +348,10 @@ export declare function chosenWords(leg: Pick<RouteLeg, "chosen" | "tier">): str
  * plans, builds, and repairs; claude · opus reviews" — with the posture
  * said honestly (stronger agents only when one is actually selected).
  */
-export declare function agentsSummary(route: Pick<PhaseRoute, "legs">): string;
+export declare function agentsSummary(route: Pick<PhaseRoute, "legs"> & {
+    size?: TaskSizing | null;
+    risk?: RiskLevel;
+}): string;
 export declare function legLine(leg: RouteLegProjection): string;
 /** The one projection CLI, task page, and chat all render from. */
 export declare function projectRoute(route: PhaseRoute, readiness: ReadinessLookup): RouteProjection;

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)
@@ -599,7 +806,7 @@ export function projectRoute(route, readiness) {
     return {
         digest: routeDigestOf(route),
         risk: route.risk,
-        riskTitle: riskTitle(route.risk),
+        riskTitle: route.risk === "routine" && route.size?.risky ? "Risky" : riskTitle(route.risk),
         posture: drawsStrong(legs) ? "strong" : "economy",
         postureWords: postureWords(route),
         demands: route.demands.filter(reason => !/review/i.test(reason)),
@@ -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/process-liveness.d.ts

@@ -1,6 +1,7 @@
 type HistoricalWitness = {
     observedAt: unknown;
     finishedAt: unknown;
+    exitedAt?: unknown;
 };
 /** Read-only checks of retained process witnesses. Saved PIDs authorize no
  * signal. ESRCH or proven macOS PID reuse establishes absence; everything

package/dist/process-liveness.js

@@ -43,6 +43,11 @@ function newerMacProcess(pid, witness) {
  * unknown stays occupied. This concerns the historical identity, not whether
  * the numeric PID/PGID is currently populated by unrelated processes. */
 export function processMayBeAlive(pid, group, witness) {
+    // A recorded single-process exit is final: this number can now belong to
+    // someone else, even before the run ends. A leader's exit proves nothing
+    // about its group's remaining members, so groups keep the OS probe.
+    if (!group && witness?.exitedAt != null)
+        return false;
     if (!Number.isSafeInteger(pid) || pid <= 0)
         return true;
     if (group && process.platform !== "win32") {

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;