toolroll 0.9.103 → 0.9.105

package/dist/phase-routing.js

@@ -1,62 +1,8 @@
-/**
- * Explainable phase routing (v47), sized since v2.
- *
- * WHICH agent plans, builds, repairs, and reviews a task is decided here,
- * once, from signed facts — never guessed from a model's name and never
- * re-decided behind an approval's back. The policy is a small table over
- * explicit inputs:
- *
- *   size         — how big a change the task is (small / medium / large, risky or not)
- *   quality      — the evidence policy the scope signs (default / strict)
- *   evidence     — what the acceptance rubric demands (screenshots, …)
- *   publication  — how far the plane may carry the result unattended
- *   candidates   — the operator's CONFIGURED routine and strong agents
- *   overrides    — an approver's explicit per-phase choice, recorded
- *   pins         — a routine firing's or plan request's pinned pair
- *
- * and its output is one canonical ROUTE: four legs, each with an exact
- * provider AND an exact model id, which tier it came from, whether a
- * person overrode it, and plain-English reasons. The same inputs always
- * yield the same route and the same words — `recommendRoute` is pure, so
- * the surfaces (CLI, task page, chat) render one projection rather than
- * three.
- *
- * EXACTNESS is the law of this module: a candidate, an override, a pin,
- * and every frozen leg name an exact model id — "the harness default"
- * is not a term an approval can bind. A configuration that cannot make a
- * leg exact (no model configured, a cross-provider repair row, gemini on
- * the review phase) becomes a stated PROBLEM on that leg, and the scope
- * files unresolved with those words; nothing is guessed or substituted.
- *
- * Strength is never inferred: "strong" means the operator named a strong
- * candidate for that phase (`config set <phase> --tier strong …`). With
- * none configured, a demanding task still routes to the configured
- * default and SAYS so — and its posture reads as economical, because that
- * is what actually runs. Provider readiness is a runner's observation,
- * not a term — it rides beside the route (ready / unavailable / unknown),
- * it is stated wherever the route is shown, and an unavailable provider
- * is never substituted: admission halts with the reason.
- *
- * Every route carries `risk: "routine"`: the declared risk level was
- * removed in v115 (size does that job), and older sealed routes keep
- * whatever risk they were recommended for, read back exactly.
- *
- * Approval seals the route (`approvedRouteJson`); its digest folds into
- * the scope digest of EVERY route filed since v47 — routine-shaped routes
- * included — so a task-level route edit stales the approval exactly as a
- * goal edit does, while a global configuration change can never rewrite a
- * sealed route. Only a row proven to predate v47 (no route era) reads as
- * a legacy approval governed by its sealed profile alone.
- */
 import { ACP_AGENTS, isAcpProvider } from "./acp-agents.js";
 import { createHash } from "node:crypto";
 import { MODEL_ID_SHAPE, postureOf, readRouteOverrides, PLAIN_ROUTE_VERSION, readSealedRoute, RISKS, ROUTE_PHASES, ROUTE_PROVIDERS, ROUTE_VERSION, TASK_SIZE_WORDS, } from "./contracts/route.js";
 import { canonicalJson } from "./canonical-json.js";
 export { MODEL_ID_SHAPE };
-// Type-only imports from provider.ts: it sits under evidence.ts and scope.ts
-// in the module graph, and this policy is imported by scope.ts — a value
-// import would be a cycle at load time. The route contract restates the id
-// list, pinned to provider.ts's by the test suite.
 export const PROVIDER_ID_LIST = ROUTE_PROVIDERS;
 function isProviderId(value) {
     return PROVIDER_ID_LIST.includes(value);
@@ -64,20 +10,10 @@ function isProviderId(value) {
 function exactModel(v) {
     return typeof v === "string" && MODEL_ID_SHAPE.test(v);
 }
-/** The same exactness for callers outside this policy (the profile
- * rehydrator): one shape, one definition. */
 export function exactModelId(v) {
     return exactModel(v);
 }
-/** 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 { PLAIN_ROUTE_VERSION, ROUTE_VERSION };
-/** 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. The era marks a ROUTED
- * row; which route version it holds rides in the snapshot itself. */
 export const ROUTE_ERA = 1;
 export const PHASES = ROUTE_PHASES;
 export function isRiskLevel(value) {
@@ -87,12 +23,9 @@ export const TASK_SIZES = TASK_SIZE_WORDS;
 export function isTaskSize(value) {
     return value === "small" || value === "medium" || value === "large";
 }
-/** Whether a task makes no plan: a small change that is not risky (on an
- * older route sealed at elevated or high risk, it always planned). */
 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";
 }
@@ -100,15 +33,8 @@ export function riskTitle(risk) {
     return risk === "high" ? "High risk" : risk === "elevated" ? "Elevated risk" : "Routine";
 }
 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) => {
@@ -132,7 +58,6 @@ export function headroomFrom(limits, now) {
             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);
@@ -191,7 +116,6 @@ function demandedTier(input, phase) {
 }
 function economyReason(input, phase) {
     const facts = [
-        // Said as it always was, so a route's words (and its digest) stay the same.
         "risk is routine",
         `quality is ${input.qualityMode === "strict" ? "strict" : "default"}`,
         ...(input.publication === "notify" ? ["publication waits for a person"] : []),
@@ -205,16 +129,9 @@ function reviewProblem(spec) {
         ? "gemini has no isolation posture for the review phase yet — configure or override the reviewer to claude or codex"
         : null;
 }
-/** ACP agents run with full access inside the fence; a plan is read-only work, which they can't be held to. */
 function planProblem(spec) {
     return isAcpProvider(spec.provider) ? `${ACP_AGENTS[spec.provider].name} builds and repairs only — configure or override the planner to claude, codex or gemini` : null;
 }
-/**
- * The recommendation: pure, deterministic, table-driven. Same inputs,
- * same route, same words. Every leg it returns is exact; a leg the
- * configuration cannot make runnable carries a `problem` instead of a
- * guess.
- */
 export function recommendRoute(input) {
     const demands = DEMANDS.filter(one => one.when(input)).map(one => one.reason);
     const overrides = [...input.overrides]
@@ -254,7 +171,6 @@ export function recommendRoute(input) {
         }
         return { spec: candidates.routine, tier: "routine", reasons: [economyReason(input, phase), `configured ${PHASE_NOUN[phase]} from ${candidates.routine.source}`] };
     };
-    // plan — pin > override > recommendation.
     {
         const rec = pick("plan");
         const pin = input.pins?.plan ?? null;
@@ -270,7 +186,6 @@ export function recommendRoute(input) {
             legs.push({ phase: "plan", provider: rec.spec.provider, model: rec.spec.model, tier: rec.tier, chosen: "recommended", recommended, reasons: rec.reasons, problem: planProblem(rec.spec) });
         }
     }
-    // build — one precedence order (selectBuildLeg): pin > override > trial > earned rule > configured > headroom.
     let buildMoved = false;
     const build = (() => {
         const chosen = selectBuildLeg(input, pickTier("build"));
@@ -278,11 +193,6 @@ export function recommendRoute(input) {
         legs.push(chosen.leg);
         return chosen.leg;
     })();
-    // repair — ALWAYS the build provider (repair resumes the builder's
-    // session; cross-provider repair does not exist). Only the model routes:
-    // the same-provider strong row when demanded, else the same-provider
-    // configured row, else the build's own exact model (inherit). A
-    // configured row on ANOTHER provider is a stated problem, never skipped.
     {
         const demanded = demandedTier(input, "repair");
         const candidates = input.candidates.repair;
@@ -291,8 +201,6 @@ export function recommendRoute(input) {
         let tier;
         let reasons;
         let problem = 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;
@@ -360,7 +268,6 @@ export function recommendRoute(input) {
             legs.push({ phase: "repair", provider: build.provider, model, tier, chosen: "recommended", recommended, reasons: [...reasons, `same provider as the build (${build.provider}) — repairs resume the builder's session`], problem });
         }
     }
-    // review — override > recommendation; gemini cannot run it at all.
     {
         const rec = pick("review");
         const override = overrideFor("review");
@@ -373,15 +280,11 @@ export function recommendRoute(input) {
         }
     }
     return {
-        // Version 3 only for a build leg that carries a selection: every other route's bytes stay version 2's.
         version: build.selection !== undefined ? ROUTE_VERSION : PLAIN_ROUTE_VERSION,
         risk: "routine",
         qualityMode: input.qualityMode,
         publication: input.publication,
         evidence: [...new Set(input.evidence)].sort(),
-        // The posture is what RUNS, not what was wanted: only a leg that
-        // actually draws from a configured strong agent makes the route strong
-        // — an overridden or pinned leg runs the person's choice, not a tier.
         posture: drawsStrong(legs) ? "strong" : "economy",
         demands,
         legs,
@@ -389,25 +292,10 @@ export function recommendRoute(input) {
         size: input.size ?? null,
     };
 }
-/**
- * THE BUILD LEG'S ONE PRECEDENCE ORDER (results routing, docs/plans/results-routing.md slice 2), pure:
- *
- *   pin > person override > trial > earned rule > configured row (light / routine / strong by size)
- *   > headroom move
- *
- * Headroom moves only a configured leg, never a rule's or a trial's: their evidence is about one exact model. A rule
- * or trial whose provider is past the headroom limits is skipped for this filing, and its reason says so. A trial
- * applies only with a place reserved for this task (slice 3). A rule or trial applies only to an
- * eligible task — small or medium, not risky, default quality, no screenshot or manual-review evidence, not a
- * merging mode, not a release or candidate, nothing protected declared — and only over the configured builder it was
- * earned against. Its leg says how it was selected (`selection`), so the route seals as version 3 and every later
- * check reads the sealed selection, never the current rules or the reason text.
- */
 export function selectBuildLeg(input, configured) {
     const pin = input.pins?.build ?? null;
     const override = input.overrides.find(one => one.phase === "build") ?? null;
     if (pin !== null || override !== null) {
-        // What would have run otherwise is said as it always was: the configured leg after headroom.
         const rec = withHeadroom(input, "build", configured);
         const recommended = { provider: rec.spec.provider, model: rec.spec.model, tier: rec.tier };
         const leg = pin !== null
@@ -452,8 +340,6 @@ export function selectBuildLeg(input, configured) {
         moved: rec.moved,
     };
 }
-/** The earned rule this task's build takes (pure): null when none could apply (no rule for its size, or the task
- * isn't eligible), or a rule skipped for this filing with the words why. */
 export function earnedRuleFor(input, configured) {
     const earned = input.earned ?? null;
     const size = input.size ?? null;
@@ -468,7 +354,6 @@ export function earnedRuleFor(input, configured) {
         return null;
     if (demandedTier(input, "build").tier !== "routine")
         return null;
-    // Only Claude reports the model it ran, so only a Claude cohort can earn a rule.
     if (rule.provider !== "claude" || !exactModel(rule.model))
         return null;
     if (configured.spec.provider !== rule.configured.provider || configured.spec.model !== rule.configured.model) {
@@ -480,9 +365,6 @@ export function earnedRuleFor(input, configured) {
         return { kind: "skipped", reason: `earned rule skipped for this filing: ${tight} — the configured builder runs it` };
     return { kind: "rule", rule };
 }
-/** The trial this task's build takes (pure, results routing slice 3): null when none could apply (no live trial for
- * its size, or the task isn't eligible: the same facts an earned rule needs), a trial with this task's place, or a
- * trial skipped for this filing with the words why (another configured builder, no place left, no headroom). */
 export function trialFor(input, configured) {
     const trial = input.earned?.trial ?? null;
     const size = input.size ?? null;
@@ -494,7 +376,6 @@ export function trialFor(input, configured) {
         return null;
     if (demandedTier(input, "build").tier !== "routine")
         return null;
-    // Only Claude reports the model it ran, so only a Claude cohort runs a trial.
     if (trial.provider !== "claude" || !exactModel(trial.model) || !Number.isSafeInteger(trial.limit) || trial.limit < 1)
         return null;
     const words = size.size === "small" ? "small" : "routine";
@@ -510,21 +391,6 @@ export function trialFor(input, configured) {
     }
     return { kind: "trial", trial: { ...trial, reservation: trial.reservation } };
 }
-/**
- * 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) => {
@@ -542,7 +408,6 @@ function withHeadroom(input, phase, chosen) {
         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 });
@@ -567,7 +432,6 @@ function withHeadroom(input, phase, chosen) {
         moved: true,
     };
 }
-/** Whether any leg actually runs a configured strong agent. */
 function drawsStrong(legs) {
     return postureOf(legs) === "strong";
 }
@@ -577,17 +441,12 @@ export function legOf(route, phase) {
         throw new Error(`route has no ${phase} leg`);
     return leg;
 }
-/** Every stated problem on the route, in phase order — a non-empty list
- * means the scope files unresolved with these words. */
 export function routeProblems(route) {
     return route.legs.filter(leg => leg.phase !== "review").flatMap(leg => (leg.problem === null ? [] : [`${leg.phase}: ${leg.problem}`]));
 }
-/** Whether two exact pairs are the same agent. */
 export function sameSpec(a, b) {
     return a.provider === b.provider && a.model === b.model;
 }
-// ---- canonical bytes, digest, strict rehydration ---------------------------
-/** The stored snapshot bytes: the version rides IN the snapshot. */
 export function canonicalRouteJson(route) {
     return canonicalJson({
         version: route.version,
@@ -606,17 +465,12 @@ export function canonicalRouteJson(route) {
             recommended: leg.recommended,
             reasons: leg.reasons,
             problem: leg.problem,
-            // v3 (results routing): the build leg's selection is in the bytes, so in the digest; v1 and v2 bytes never change.
             ...(route.version === 3 && leg.selection !== undefined ? { selection: leg.selection } : {}),
         })),
         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
- * same 128 bits every other safety digest here uses. Its own domain, so a
- * 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")
@@ -626,19 +480,12 @@ export function routeDigestOf(route) {
 function str(v) {
     return typeof v === "string" && v !== "";
 }
-/** Strict rehydration of a stored route through the route contract — every
- * field type-proved, every model an exact non-empty string, nothing unknown;
- * anything unexpected is null, never a guess. A null from a row that carries
- * a route era is a corrupt seal. */
-// Recovery and normal admission share this strict decoder; neither may replace
-// unreadable signed routing with a convenient current default.
 export function routeFromJson(json) {
     if (json === null)
         return null;
     const read = readRouteJson(json);
     return read.ok ? read.route : null;
 }
-/** Why a stored route does not read, as path-named lines (`legs[1].model: …`); null when it reads. */
 export function routeJsonProblem(json) {
     const read = readRouteJson(json);
     return read.ok ? null : read.lines.join("; ");
@@ -654,15 +501,10 @@ function readRouteJson(json) {
     const read = readSealedRoute(parsed);
     return read.ok ? { ok: true, route: read.value } : { ok: false, lines: read.issues.map(one => one.line) };
 }
-/** Strict parse of an override list (the route contract's): one per phase,
- * every field proved, every model exact, in phase order. */
 export function parseOverrides(raw) {
     const read = readRouteOverrides(raw);
     return read.ok ? read.value : null;
 }
-/** The stored override list (a task-level column). Malformed reads as
- * null — the caller files the scope unresolved rather than routing as if
- * nobody had overridden anything. */
 export function overridesFromJson(json) {
     if (json === null)
         return [];
@@ -680,23 +522,19 @@ export function canonicalOverridesJson(overrides) {
         .sort((a, b) => PHASES.indexOf(a.phase) - PHASES.indexOf(b.phase))
         .map(one => ({ phase: one.phase, provider: one.provider, model: one.model, by: one.by, at: one.at })));
 }
-/** What actually runs: stronger agents only when a leg draws from one. */
 export function postureWords(route) {
     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`;
-    // (A route sealed at elevated or high risk planned 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";
@@ -712,15 +550,8 @@ export function readinessWords(state, reason) {
 export function chosenWords(leg) {
     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:
- * agents grouped by identical pair, in phase order — "claude · sonnet
- * plans, builds, and repairs; claude · opus reviews" — with the posture
- * said honestly (stronger agents only when one is actually selected).
- */
 export function agentsSummary(route) {
     const groups = [];
-    // 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);
@@ -736,7 +567,6 @@ export function agentsSummary(route) {
 export function legLine(leg) {
     return `${leg.phase.padEnd(7)}${specWords(leg)}  [${chosenWords(leg)}] — ${readinessWords(leg.readiness, leg.readinessReason)}${leg.problem === null ? "" : ` — ${leg.problem}`}`;
 }
-/** The one projection CLI, task page, and chat all render from. */
 export function projectRoute(route, readiness) {
     const legs = route.legs.filter(leg => leg.phase !== "review").map(leg => {
         const seen = readiness(leg.provider);
@@ -766,12 +596,9 @@ export function projectRoute(route, readiness) {
         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
- * reasons indented — identical bytes on every text surface. */
 export function routeWords(projection, indent = "  ") {
     const pad = `${indent}             `;
     return [
@@ -782,21 +609,11 @@ export function routeWords(projection, indent = "  ") {
         ...(projection.halted ? [`${pad}HALTED: a provider on this route is reported unavailable — nothing substitutes; override the phase or restore the provider`] : []),
     ];
 }
-/** The empty readiness lookup: every provider unknown. */
 export const NO_READINESS = () => null;
 export const ROUTE_CHOSEN = ["recommended", "override", "pinned", "legacy", "fallback"];
-/** A run's role, as the route phase it spends as: a scout runs the build
- * leg's agent (the same sealed profile a build proves against). */
 export function phaseOfRole(role) {
     return role === "planner" ? "plan" : role === "repair" ? "repair" : role === "reviewer" ? "review" : "build";
 }
-/**
- * Strict proof of a route stamp's SHAPE, before anything about it is
- * believed: a known phase and provenance word, a known provider, a
- * non-empty digest, and an exact model on every stamp except a legacy
- * one (a pre-routing profile may carry no model). Anything else is the
- * words for why — admission refuses on them, never coerces.
- */
 export function routeStampProblem(stamp) {
     if (stamp === null || typeof stamp !== "object")
         return "the route stamp is not an object";
@@ -818,3 +635,11 @@ export function routeStampProblem(stamp) {
         return `a ${String(s["chosen"])} leg names an exact model — the stamp carries none`;
     return null;
 }
+export const LOGIN_PROBE = "login";
+export const PATH_PROBE = "path";
+export const IDENTITY_FAILED_PROBE = "identity-failed";
+export function readinessRefuses(observation, authMode) {
+    if (observation === null || observation.state !== "unavailable")
+        return false;
+    return !(observation.probe === LOGIN_PROBE && authMode !== "subscription");
+}

package/dist/plain-schema.js

@@ -1,6 +1,3 @@
-/** v153 (docs/plans/plain-toolroll.md Phase 2): the tables the authority slices own, new tables only. Kept apart so
- * store.ts loads them without loading the roads that use them. */
-/** A vanished build's one charge per run, and the episode its automatic retries stay inside (vanished-retry.ts). */
 export const VANISHED_SCHEMA = `
 CREATE TABLE IF NOT EXISTS vanished_charge (
   run        INTEGER PRIMARY KEY REFERENCES run(id),
@@ -19,9 +16,6 @@ CREATE TABLE IF NOT EXISTS retry_episode (
   updated_at        TEXT NOT NULL
 );
 `;
-/** A check-only authorization (check-only.ts): one automatic run of the approved check on one exact commit. The unique
- * key is the cap: one per (commit, command digest), however many workers race. Written only from the approval that
- * built that commit; it seals nothing and starts no agent. */
 export const CHECK_ONLY_SCHEMA = `
 CREATE TABLE IF NOT EXISTS check_authorization (
   id             INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -41,8 +35,6 @@ CREATE TABLE IF NOT EXISTS check_authorization (
 );
 CREATE INDEX IF NOT EXISTS check_authorization_open ON check_authorization (expires_at) WHERE used_at IS NULL AND closed_at IS NULL;
 `;
-/** Whether this computer's own builder is meant to be running, and with what (builder-restart.ts): set by `background
- * on` and `up`, cleared by `background off` and `stop`. `builder_restart` is every automatic restart Toolroll tried. */
 export const BUILDER_SERVICE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS builder_service (
   id             INTEGER PRIMARY KEY CHECK (id = 1),
@@ -57,8 +49,6 @@ CREATE TABLE IF NOT EXISTS builder_restart (
   at TEXT NOT NULL
 );
 `;
-/** A fast start's form as it was rendered (fast-start.ts): what the person typed and what the classifier said, kept here
- * so Build files exactly that, whatever a form posts. Used once. */
 export const FAST_PREVIEW_SCHEMA = `
 CREATE TABLE IF NOT EXISTS fast_preview (
   id          TEXT PRIMARY KEY,
@@ -75,8 +65,6 @@ CREATE TABLE IF NOT EXISTS fast_preview (
   consumed_at TEXT
 );
 `;
-/** The one new route Toolroll proposed for a task whose sealed one no longer matches (route-change.ts): the line a person
- * reads, bound to the exact route digest it describes. */
 export const ROUTE_CHANGE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS route_change (
   task_ref        INTEGER PRIMARY KEY REFERENCES task_ref(id),
@@ -86,8 +74,6 @@ CREATE TABLE IF NOT EXISTS route_change (
   created_at      TEXT NOT NULL
 );
 `;
-/** v153's columns: a fast start's marker and start window on the task (both NULL on saved rows) and the project setting
- * Small tasks start right away (NULL: the default). */
 export const V153_ADDED_COLUMNS = Object.freeze({
     task_ref: { fast_start_at: { definition: "TEXT", saved: "NULL" }, fast_start_until: { definition: "TEXT", saved: "NULL" } },
     project: { fast_start: { definition: "INTEGER CHECK (fast_start IS NULL OR fast_start IN (0, 1))", saved: "NULL" } },

package/dist/plain-words.js

@@ -1,14 +1,7 @@
-/** One vocabulary for the words Toolroll writes (docs/plans/plain-toolroll.md, "The words"): each row is a word or
- * phrase product copy never says, and what it says instead. Matching is by whole word and ignores case.
- *
- * Product copy is the text Toolroll writes. Preserved content (goals, requirements, notes, agent reports, issue text,
- * commit messages and the exact terms a consent shows) is never rewritten to satisfy this table. Code, the database,
- * `--json`, the agent contract and the audit page's hash detail keep their own words. */
 const row = (never, pattern, say) => ({ never, pattern: new RegExp(`(?<![\\w-])(?:${pattern})(?![\\w-])`, "i"), say });
 export const PLAIN_WORDS = [
     row("scope", "scopes?|scoped", "plan"),
     row("contract", "contracts?", "plan"),
-    // "Sign in", "signed in" and "signed out" are a person signing in, not an approval.
     row("signs", "signs|signed(?!\\s+(?:in|out|into)\\b)", "Approved by …"),
     row("sealed", "seal|seals|sealed|sealing", "approved"),
     row("binds", "binds?", "approved"),
@@ -51,16 +44,29 @@ export const PLAIN_WORDS = [
     row("quiescence", "quiescen(?:ce|t)", "Waiting: Toolroll is …"),
     row("witness", "witness(?:es|ed)?", "Waiting: Toolroll is …"),
     row("unproven", "unproven", "Waiting: Toolroll is …"),
-    // A plan version or digest written out: twelve or more hex characters. A short commit (seven) is fine.
     row("version hex", "(?=[0-9a-f]*\\d)(?=[0-9a-f]*[a-f])[0-9a-f]{12,64}", "(the plan version, in Details)"),
 ];
-/** The words, for messages and tests. */
 export const BANNED_WORDS = PLAIN_WORDS.map(one => one.never);
-/** Every banned word in `text`, as the table names it. */
 export function bannedWordsIn(text) {
     return PLAIN_WORDS.filter(one => one.pattern.test(text)).map(one => one.never);
 }
-/** Whether `text` says any word product copy never says. */
 export const hasInternalWords = (text) => PLAIN_WORDS.some(one => one.pattern.test(text));
-/** A plan's version as Details shows it: a short handle, never the whole digest. */
 export const planVersionWords = (digest) => `Plan version ${digest.slice(0, 8)}`;
+export const FIRST_HOUR_WORDS = [
+    row("lead", "lead", "Toolroll, or Chat"),
+    row("crew", "crew", "Toolroll"),
+    row("scope", "scopes?|scoped", "plan"),
+    row("mode", "modes?", "(Settings)"),
+    row("flow", "flows?", "(Settings)"),
+    row("fleet", "fleet", "(Settings)"),
+    row("fallback", "fallbacks?", "(Settings)"),
+    row("routing", "routing|routed", "(Settings)"),
+    row("spend", "spend|spends|spending|spent", "cost"),
+    row("MCP", "mcp", "(Settings)"),
+    row("password", "passwords?|passwordless", "(only where one is asked for)"),
+    row("token", "tokens?", "(Settings)"),
+    row("builder", "builders?", "taking work"),
+];
+export function firstHourWordsIn(text) {
+    return FIRST_HOUR_WORDS.filter(one => one.pattern.test(text)).map(one => one.never);
+}

package/dist/plan-auto.js

@@ -1,5 +1,6 @@
 import { releaseUnattendedRun, reserveUnattendedRun, unattendedGrantStands } from "./flow-unattended.js";
 import { modeTermsFromJson } from "./modes.js";
+import { currentLocalOwner } from "./local-owner.js";
 import { plannerContractOf, plannerSourceDigest } from "./planner-source.js";
 import { modeFilingCoverage, propose, quarantinedAuthor } from "./scope.js";
 export const PLAN_AUTO_SCHEMA = `CREATE TABLE IF NOT EXISTS plan_authorization (
@@ -15,8 +16,6 @@ function plainPlan(store, taskId) {
     return ref !== null && ref.deliverable === "branch" && ref.coordinatorCid === null &&
         store.mirrorByTask(taskId) === null;
 }
-/** Join the console's authority-free proposal to the authenticated filing
- * road in one transaction. Planning defers the seal until verified ingestion. */
 export function applyModeToNewFiling(store, taskId, actor, now) {
     const ref = store.lookupRef(taskId);
     const scope = store.getScope(taskId);
@@ -32,11 +31,10 @@ export function applyModeToNewFiling(store, taskId, actor, now) {
     else if (filed.profileState === "resolved")
         store.sealScopeApproval(taskId, actor, now, {}, { kind: "mode", modeDigest: coverage.digest });
 }
-/** Called only by credentialed operator roads, never by proposal/intake
- * code. This authorizes the exact filed contract, not arbitrary future
- * planner text. Rewrites, mode renewal, expiry and revocation fail closed. */
 export function authorizePlanUnderMode(store, taskId, actor, now) {
     return store.transact(() => {
+        if (currentLocalOwner() !== null)
+            return false;
         const ref = store.lookupRef(taskId);
         if (ref === null || ref.repo === null || ref.plan !== "requested" || !plainPlan(store, taskId) || store.hasLiveClaim(ref.id, now))
             return false;
@@ -57,18 +55,11 @@ export function authorizePlanUnderMode(store, taskId, actor, now) {
         return true;
     });
 }
-/** A scope whose resolved profile or route runs with full permissions: a flow grant never seals one. */
 function escalatedPosture(store, taskId) {
     const row = store.raw().prepare("SELECT profile_json, proposed_route_json FROM task_scope WHERE task_id = ?").get(taskId);
     const text = `${row?.["profile_json"] ?? ""} ${row?.["proposed_route_json"] ?? ""}`;
     return /"(?:bypassPermissions|danger-full-access|yolo)"/.test(text);
 }
-/**
- * A flow card's new filing under its flow's "runs on its own" grant (flow-unattended.ts), inside the engine's filing
- * transaction, which has just proved the grant covers this card. A plain build that plans is pre-authorized for an
- * unchanged plan only; anything else is sealed now, under a distinct `grant` basis. False (the filing then waits for a
- * person, as it always did) when the filed terms aren't the safe, fixed ones the grant was signed for.
- */
 export function sealFlowFilingUnderGrant(store, taskId, grant, card, now) {
     const ref = store.lookupRef(taskId);
     const scope = store.getScope(taskId);
@@ -76,7 +67,6 @@ export function sealFlowFilingUnderGrant(store, taskId, grant, card, now) {
         return false;
     if (!unattendedGrantStands(store, grant.digest, grant.signedBy, ref.repo, scope.touches, now))
         return false;
-    // The day's run is taken first, in one capped statement; a filing that then can't be sealed gives it back.
     if (!reserveUnattendedRun(store, grant, taskId, now))
         return false;
     let done = false;
@@ -100,7 +90,6 @@ export function sealFlowFilingUnderGrant(store, taskId, grant, card, now) {
         action: ref.plan === "requested" ? "flow ran on its own: unchanged plan pre-authorized" : "flow ran on its own: approved", outcome: "authorized", detail: `flow #${card.flow} · card ${card.id}` });
     return true;
 }
-/** Whether the authority that armed this plan authorization still stands (read side and finalization alike). */
 function armedAuthorityStands(store, row, repo, now) {
     const by = String(row["signed_by"]), digest = String(row["mode_digest"]);
     if (row["basis"] === "grant") {
@@ -112,7 +101,6 @@ function armedAuthorityStands(store, row, repo, now) {
     return mode !== null && terms?.planAuto === true && terms.autoApproveFiling && mode.digest === digest && mode.signedBy === by && store.accountCanAccess(by, repo)
         ? { basis: "mode", digest } : null;
 }
-/** Read-side status only; finalization still proves the authority anew. */
 export function planAutoPending(store, taskId, now) {
     const ref = store.lookupRef(taskId);
     if (ref?.repo == null || ref.plan !== "requested" || !plainPlan(store, taskId))
@@ -123,13 +111,10 @@ export function planAutoPending(store, taskId, now) {
     const source = plannerContractOf(store, taskId);
     return armedAuthorityStands(store, row, ref.repo, now) !== null && source.ok && plannerSourceDigest(source.contract) === row["source_digest"];
 }
-/** Inside the verified planner finalization transaction, after the source,
- * artifact, contract changes and lease fence have all been checked. */
 export function sealUnchangedPlanUnderMode(store, taskId, sourceDigest, runId, eligible, now) {
     const authorization = store.raw().prepare("SELECT * FROM plan_authorization WHERE task_id = ?").get(taskId);
     if (authorization === undefined)
         return false;
-    // One conclusion consumes the authorization even when it needs a human.
     store.raw().prepare("DELETE FROM plan_authorization WHERE task_id = ?").run(taskId);
     const ref = store.lookupRef(taskId);
     const scope = store.getScope(taskId);