toolroll 0.9.51 → 0.9.53

package/dist/phase-routing.d.ts

@@ -1,12 +1,12 @@
 /**
- * Explainable, risk-aware phase routing (v47).
+ * 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:
  *
- *   risk         — the task's declared risk (routine / elevated / high)
+ *   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
@@ -35,8 +35,11 @@
  * 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, and only an
- * already-approved explicit fallback entry may ever run instead.
+ * 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
@@ -69,8 +72,8 @@ 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. */
 export declare const ACTIVE_PHASES: readonly Phase[];
+/** The risk words a route sealed before v115 may carry (history); every route since says `routine`. */
 export type RiskLevel = (typeof RISKS)[number];
-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). */
@@ -78,26 +81,14 @@ export type TaskSize = TaskSizing["size"];
 export declare const TASK_SIZES: readonly TaskSize[];
 export type SizeSource = TaskSizing["source"];
 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. */
+/** 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 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 (the route contract's): 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
- * from the tiering table below, so the explanation a form or a chat gives
- * can never drift from the policy that acts on it. The same words on
- * every surface: the task page's risk control, the chat's answer, the CLI.
- */
-export declare function riskConsequence(risk: RiskLevel): string;
-export declare const RISK_CHOICES: readonly {
-    risk: RiskLevel;
-    title: string;
-    consequence: string;
-}[];
 /** A runner's non-spending observation of one provider. `unknown` is a
  * real answer (claude has no login probe that does not spend) and is never
  * upgraded to ready. */
@@ -184,7 +175,6 @@ export declare function headroomFrom(limits: readonly {
     observedAt: string;
 }[], now: Date): ProviderRoom[];
 export type RouteInput = {
-    risk: RiskLevel;
     qualityMode: QualityMode;
     evidence: readonly RouteEvidenceKind[];
     publication: PublicationAuthority;
@@ -308,9 +298,9 @@ export declare function routeWords(projection: RouteProjection, indent?: string)
 /** The empty readiness lookup: every provider unknown. */
 export declare const NO_READINESS: ReadinessLookup;
 /** How a run's provenance names the leg it spent as: the frozen leg's own
- * word, `legacy` for a run governed by a pre-routing approval, a contest
- * lane, or an attended session, and `fallback` for an approved fallback
- * entry (and every repair of one). */
+ * word, and `legacy` for a run governed by a pre-routing approval. Before
+ * v115, `legacy` also named a watched session's run, and `fallback` an
+ * approved fallback entry's; those rows still read back. */
 export type RouteChosen = RouteLeg["chosen"] | "legacy" | "fallback";
 export declare const ROUTE_CHOSEN: readonly RouteChosen[];
 /** One run's route provenance: the exact provider and model that ran,

package/dist/phase-routing.js

@@ -1,12 +1,12 @@
 /**
- * Explainable, risk-aware phase routing (v47).
+ * 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:
  *
- *   risk         — the task's declared risk (routine / elevated / high)
+ *   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
@@ -35,8 +35,11 @@
  * 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, and only an
- * already-approved explicit fallback entry may ever run instead.
+ * 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
@@ -77,7 +80,6 @@ export const ROUTE_ERA = 1;
 export const PHASES = ROUTE_PHASES;
 /** The review leg remains readable in signed history but is no longer scheduled. */
 export const ACTIVE_PHASES = ["plan", "build", "repair"];
-export const RISK_LEVELS = RISKS;
 export function isRiskLevel(value) {
     return value === "routine" || value === "elevated" || value === "high";
 }
@@ -85,8 +87,8 @@ 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, at
- * routine risk. Elevated or high risk always plans, whatever the size. */
+/** 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";
 }
@@ -102,20 +104,6 @@ export function parseSizing(raw) {
 export function riskTitle(risk) {
     return risk === "high" ? "High risk" : risk === "elevated" ? "Elevated risk" : "Routine";
 }
-/**
- * What declaring each risk level DOES, in one plain sentence — derived
- * from the tiering table below, so the explanation a form or a chat gives
- * can never drift from the policy that acts on it. The same words on
- * every surface: the task page's risk control, the chat's answer, the CLI.
- */
-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 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
@@ -171,16 +159,6 @@ export function specWords(spec) {
     return `${spec.provider} · ${spec.model}`;
 }
 const DEMANDS = [
-    {
-        when: input => input.risk === "high",
-        phases: ["plan", "build", "repair", "review"],
-        reason: "risk is high — every role uses the strongest configured agent",
-    },
-    {
-        when: input => input.risk === "elevated",
-        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"],
@@ -218,7 +196,8 @@ function demandedTier(input, phase) {
 }
 function economyReason(input, phase) {
     const facts = [
-        `risk is ${input.risk}`,
+        // 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"] : []),
     ];
@@ -242,7 +221,6 @@ 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);
@@ -405,7 +383,7 @@ export function recommendRoute(input) {
     }
     return {
         version: ROUTE_VERSION,
-        risk: input.risk,
+        risk: "routine",
         qualityMode: input.qualityMode,
         publication: input.publication,
         evidence: [...new Set(input.evidence)].sort(),
@@ -616,7 +594,7 @@ export function sizeWords(route) {
     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.
+    // (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";

package/dist/plan-auto.js

@@ -12,7 +12,7 @@ export const PLAN_AUTO_SCHEMA = `CREATE TABLE IF NOT EXISTS plan_authorization (
 function plainPlan(store, taskId) {
     const ref = store.lookupRef(taskId);
     return ref !== null && ref.deliverable === "branch" && ref.coordinatorCid === null &&
-        store.activeTournamentTerms(ref.id) === null && store.openAuthorizationFor(ref.id) === null && store.mirrorByTask(taskId) === 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. */
@@ -24,7 +24,7 @@ export function applyModeToNewFiling(store, taskId, actor, now) {
         return;
     const filed = propose(store, { taskId, goal: scope.goal, outOfScope: scope.outOfScope, touches: scope.touches, acceptance: scope.acceptance,
         budgetMicrousd: scope.budgetMicrousd ?? coverage.defaultBudgetMicrousd,
-        qualityMode: scope.qualityMode ?? "default", riskLevel: scope.riskLevel ?? "routine",
+        qualityMode: scope.qualityMode ?? "default",
         ...(coverage.escalated ? { posture: "escalated" } : {}), now });
     if (ref.plan === "requested")
         authorizePlanUnderMode(store, taskId, actor, now);

package/dist/planner-source.js

@@ -128,7 +128,8 @@ export function plannerContractOf(store, taskId) {
                 agentPin: { provider: ref.agentProvider, model: ref.agentModel },
                 planPin: { provider: ref.planProvider, model: ref.planModel },
                 deliverable: ref.deliverable,
-                riskLevel: ref.riskLevel ?? null,
+                // The declared risk level was removed in v115; the field stays in the recorded shape.
+                riskLevel: null,
                 qualityMode: ref.qualityMode ?? null,
                 permissionMode: ref.permissionMode ?? null,
             },

package/dist/policy.d.ts

@@ -15,8 +15,7 @@
  * (lowered), or, when there is none, doesn't run (refused); the words say which.
  *
  * Every road that admits work asks here: scope approval, the tick before a
- * run starts (and build() as the last look), fallback entries, race lanes,
- * attended sessions, the lead and project chats, teammates and flow steps.
+ * run starts (and build() as the last look), the lead and project chats, teammates and flow steps.
  */
 import type { Database } from "./store.js";
 import type { ExecutionProfile } from "./scope.js";
@@ -87,8 +86,6 @@ export declare function underCeiling(policy: OrgPolicy, profile: ExecutionProfil
 export declare function sessionCeilingRefusal(policy: OrgPolicy, provider: string, what: string): string | null;
 /** Everything the policy says about a profile before it runs: refused (words), or what runs and any lowering. */
 export declare function profileVerdict(policy: OrgPolicy, profile: ExecutionProfile): CeilingVerdict;
-/** An attended session runs at exactly what the person signed, so nothing is lowered: it runs as signed, or is refused. */
-export declare function attendedRefusal(policy: OrgPolicy, profile: ExecutionProfile): string | null;
 /** At approval, a person signs exact terms: anything above the ceiling is refused with words (a new filing is lowered). */
 export declare function approvalRefusal(policy: OrgPolicy, profiles: readonly ExecutionProfile[], legs?: readonly {
     provider: string;

package/dist/policy.js

@@ -166,14 +166,6 @@ export function profileVerdict(policy, profile) {
         return { ok: false, message: `Its repairs: ${repair.charAt(0).toLowerCase()}${repair.slice(1)}` };
     return underCeiling(policy, profile);
 }
-/** An attended session runs at exactly what the person signed, so nothing is lowered: it runs as signed, or is refused. */
-export function attendedRefusal(policy, profile) {
-    const verdict = profileVerdict(policy, profile);
-    if (!verdict.ok)
-        return verdict.message;
-    return verdict.lowered === null ? null
-        : `This session asks for ${levelWords(profile)}, above the organisation policy's permission ceiling (${LEVEL_NAMES[policy.ceiling]}). Authorise it again with a lower permission, or ${WHERE.charAt(0).toLowerCase()}${WHERE.slice(1)}`;
-}
 /** At approval, a person signs exact terms: anything above the ceiling is refused with words (a new filing is lowered). */
 export function approvalRefusal(policy, profiles, legs = []) {
     for (const profile of profiles) {

package/dist/process-recovery-eligibility.js

@@ -46,7 +46,7 @@ export function preparedCandidateObserverGapEligibility(store, input) {
                 !instant(run.startedAt) || !instant(run.finishedAt) || Date.parse(run.finishedAt) < Date.parse(run.startedAt) ||
                 Date.parse(run.finishedAt) > now.getTime())
                 return refuse("not-terminal-prepared-builder");
-            if (run.providerStartedAt !== null || run.sessionId !== null || run.attendedAuthorization != null || run.contestant !== null ||
+            if (run.providerStartedAt !== null || run.sessionId !== null ||
                 !commit(run.baseRevision) || !commit(run.headRevision) || !run.branch || !run.worktree)
                 return refuse("provider-or-run-identity-unproven");
             const ref = store.refById(run.taskRef);
@@ -79,8 +79,7 @@ export function preparedCandidateObserverGapEligibility(store, input) {
                 if (!one || one.outcome === null || !instant(one.startedAt) || !instant(one.finishedAt) ||
                     Date.parse(one.finishedAt) < Date.parse(one.startedAt) || Date.parse(one.finishedAt) > Date.parse(run.finishedAt) ||
                     one.providerStartedAt !== null || one.sessionId !== null ||
-                    store.applicableStopFor(id) !== null || ownedProcessCount(runOwnerTag(store, id)) > 0 ||
-                    store.heldSessionOf(id)?.endedAt === null)
+                    store.applicableStopFor(id) !== null || ownedProcessCount(runOwnerTag(store, id)) > 0)
                     return refuse("owned-run-not-settled");
                 ownedRuns.push({ id, taskRef: one.taskRef, leaseId: one.leaseId, parentRun: one.parentRun, role: one.role,
                     outcome: one.outcome, startedAt: one.startedAt, finishedAt: one.finishedAt, providerStartedAt: one.providerStartedAt, sessionId: one.sessionId });

package/dist/process-recovery-settlement.js

@@ -123,6 +123,7 @@ export async function recoverPreparedObserverGap(store, input) {
             const actionId = store.recordAction({ at: new Date().toISOString(), actor: "system", repo: current.binding.run.repo,
                 taskId: current.binding.run.taskId, runId: receipt.targetRun, action: "process absence recovered",
                 outcome: digest, source: "work" });
+            store.compactRunProcesses(new Date(), receipt.targetRun);
             return { ok: true, recorded: true, ...result, actionId, certificatePath };
         }));
     }

package/dist/project-delete.js

@@ -48,7 +48,7 @@ function doomed(db, repo) {
 const SETTINGS = [
     ["approval_policy", "repo"], ["verify_command", "repo"], ["worktree_setup", "repo"], ["backend_grant", "repo"], ["publication_grant", "repo"],
     ["intake_grant", "repo"], ["capability", "repo"], ["project_tool", "repo"], ["phase_config", "scope"], ["phase_tier_config", "scope"],
-    ["fallback_config", "scope"], ["learning_policy", "repo"], ["operating_mode", "repo"], ["routine", "repo"], ["project_knowledge", "repo"],
+    ["learning_policy", "repo"], ["operating_mode", "repo"], ["project_knowledge", "repo"],
     ["project_decision", "repo"], ["flow_script", "repo"], ["workflow_recipe", "repo"], ["team_lead_project", "project"],
 ];
 /** What Toolroll holds for a project, counted. */
@@ -84,7 +84,6 @@ export function projectRunning(store, repo, now) {
     const at = now.toISOString();
     const count = (sql, ...params) => Number(db.prepare(sql).get(...params)?.["n"] ?? 0);
     const building = count(`SELECT COUNT(DISTINCT task_ref) AS n FROM claim WHERE released_at IS NULL AND expires_at > ? AND task_ref IN (SELECT value FROM json_each(?))`, at, json(d.refs));
-    const sessions = count("SELECT COUNT(*) AS n FROM held_session WHERE ended_at IS NULL AND run IN (SELECT value FROM json_each(?))", json(d.runs));
     const slots = count("SELECT COUNT(*) AS n FROM execution_slot WHERE state IN ('reserved','running') AND run IN (SELECT value FROM json_each(?))", json(d.runs));
     const chats = count("SELECT COUNT(*) AS n FROM mate_turn WHERE state IN ('queued','running') AND id IN (SELECT value FROM json_each(?))", json(d.turns));
     const steps = count("SELECT COUNT(*) AS n FROM flow_step_run WHERE state = 'running' AND card IN (SELECT value FROM json_each(?))", json(d.cards));
@@ -93,7 +92,7 @@ export function projectRunning(store, repo, now) {
     const checkouts = count("SELECT COUNT(*) AS n FROM worktree WHERE repo = ? AND runner IS NOT NULL AND released_at IS NULL", repo);
     return [
         ...(building > 0 ? [`${plural(building, "task")} ${building === 1 ? "is" : "are"} being built`] : []),
-        ...(sessions > 0 || slots > 0 ? ["an agent is working"] : []),
+        ...(slots > 0 ? ["an agent is working"] : []),
         ...(chats > 0 ? ["a chat is answering"] : []),
         ...(steps > 0 ? ["a flow step is running"] : []),
         ...(calls > 0 ? ["a teammate is working"] : []),
@@ -117,7 +116,6 @@ async function removeCheckoutsAndBranches(store, repo, d, git, poolRoot) {
     const named = [
         ...d.tasks.flatMap(id => OWN_BRANCHES.map(prefix => `${prefix}${id}`)), ...recorded.map(row => row.branch),
         ...list(db, "SELECT DISTINCT branch FROM run WHERE branch IS NOT NULL AND id IN (SELECT value FROM json_each(?))", json(d.runs)),
-        ...list(db, "SELECT DISTINCT c.branch FROM contestant c JOIN contest k ON k.id = c.contest WHERE c.branch IS NOT NULL AND k.task_ref IN (SELECT value FROM json_each(?))", json(d.refs)),
         ...list(db, "SELECT DISTINCT head FROM publication WHERE head IS NOT NULL AND task_ref IN (SELECT value FROM json_each(?))", json(d.refs)),
     ].map(String).filter(isOwnBranch);
     const ours = new Set(named);
@@ -263,7 +261,7 @@ function deleteRows(store, repo, d, now) {
     del("diff_comment", `${IN("run")} OR ${IN("reviewer_run")} OR ${IN("artifact")}`, R, R, A);
     del("review_request", `${IN("run")} OR ${IN("reviewer_run")}`, R, R);
     del("repair_chain", IN("source_run"), R);
-    for (const table of ["incident", "held_session", "proof_acceptance", "proof_verdict", "run_process", "run_route", "run_spend", "run_tool", "run_note", "run_stop", "run_checkpoint", "session_turn", "execution_slot"])
+    for (const table of ["incident", "proof_acceptance", "proof_verdict", "run_process", "run_route", "run_spend", "run_tool", "run_note", "run_stop", "run_checkpoint", "execution_slot"])
         del(table, IN("run"), R);
     del("knowledge_snapshot", `repo = ? OR ${IN("run")}`, repo, R);
     del("learning_snapshot", `repo = ? OR ${IN("run")}`, repo, R);
@@ -277,19 +275,10 @@ function deleteRows(store, repo, d, now) {
     del("publication", IN("id"), publications);
     del("artifact", IN("id"), A);
     // Tasks and their versions.
-    const cycles = json(ids(db, `SELECT id FROM fallback_cycle WHERE ${IN("task_ref")}`, T));
-    del("fallback_transition", `${IN("cycle")} OR ${IN("predecessor_run")} OR ${IN("consumed_by")}`, cycles, R, R);
-    del("fallback_cycle", IN("id"), cycles);
-    const contests = json(ids(db, `SELECT id FROM contest WHERE ${IN("task_ref")}`, T));
-    del("contestant", IN("contest"), contests);
-    del("contest", IN("id"), contests);
-    del("tournament_terms", IN("task_ref"), T);
-    del("attended_authorization", IN("task_ref"), T);
     del("run", IN("id"), R);
     del("plan_revision", IN("task_ref"), T);
     for (const table of ["claim", "hold", "task_steer"])
         del(table, IN("task_ref"), T);
-    del("routine_fire", IN("instance_task_ref"), T);
     const mirrors = json(list(db, `SELECT local_task_id FROM external_mirror WHERE ${IN("local_task_id")}`, K));
     del("external_intent", IN("mirror"), mirrors);
     del("external_mirror", IN("local_task_id"), mirrors);
@@ -323,7 +312,6 @@ function deleteRows(store, repo, d, now) {
     del("operating_mode_event", "mode IN (SELECT id FROM operating_mode WHERE repo = ?)", repo);
     del("decision_change", "decision IN (SELECT id FROM project_decision WHERE repo = ?)", repo);
     del("memory_sighting", "gap IN (SELECT id FROM memory_gap WHERE repo = ?) OR session IN (SELECT id FROM memory_session WHERE repo = ?)", repo, repo);
-    del("routine_fire", "routine_id IN (SELECT id FROM routine WHERE repo = ?)", repo);
     for (const [table, column] of SETTINGS)
         del(table, `${column} = ?`, repo);
     del("project_mute", "repo = ?", repo);

package/dist/proposal.d.ts

@@ -1,7 +1,7 @@
 import type { Filer } from "./approval-policy.js";
 export { validateTaskText } from "./task-text.js";
 import type { Store } from "./store.js";
-import { type UnattendedPermissionMode } from "./scope.js";
+import type { UnattendedPermissionMode } from "./scope.js";
 import type { QualityMode } from "./quality.js";
 import type { TaskSizing } from "./phase-routing.js";
 export type ProposalRefusal = {
@@ -48,6 +48,9 @@ export type TaskProposalInput = {
      * which is the fail-closed reading of an empty ceiling (finding 4).
      */
     admittedRepos?: readonly string[];
+    /** A per-task dollar cap in micro-USD, bound into the scope's digest (a
+     * scheduled flow's standing order carries one, v115). */
+    budgetMicrousd?: number | null;
     /** 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. */
@@ -59,32 +62,9 @@ export type TaskProposalInput = {
  * 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). */
-    createdBy?: string | null;
-    repo: string;
-    goal: string;
-    outOfScope: string | null;
-    touches: string[];
-    /** v39: the signed rubric every instance's scope copies forward. */
-    acceptance: unknown;
-    requirements: string[];
-    schedule: string;
-    costCeilingUsd: number | null;
-    /** Per-instance dollar cap in micro-USD (v16); optional, digest-bound. */
-    budgetPerRunMicrousd?: number | null;
-    filedVia: string;
-    admittedRepos?: readonly string[];
-};
 export declare function fileTaskProposal(store: Store, input: TaskProposalInput, now: Date): {
     ok: true;
     id: string;
     planning: boolean;
     sizing: TaskSizing;
 } | ProposalRefusal;
-export declare function fileRoutineProposal(store: Store, input: RoutineProposalInput, now: Date): {
-    ok: true;
-    id: number;
-    digest: string;
-} | ProposalRefusal;

package/dist/proposal.js

@@ -5,8 +5,8 @@ export { validateTaskText } from "./task-text.js";
  *
  * Before this module, each filing surface — CLI, console, intake — validated
  * what it happened to think of: createConsoleTask checked title and goal but
- * not disguised text, the routine command checked terms but nothing checked a
- * repo against the caller's ceiling, and nothing stamped who filed what. The
+ * not disguised text, nothing checked a repo against the caller's ceiling,
+ * and nothing stamped who filed what. The
  * review's ruling: one canonical service that every filer calls, with an
  * exact field allowlist, so a careless caller CANNOT spread a template or
  * model object into scope rows and smuggle approval metadata.
@@ -27,12 +27,8 @@ export { validateTaskText } from "./task-text.js";
  * Filing carries NO authority. Everything this module creates is unapproved
  * and stays inert until the operator's own ceremony says otherwise.
  */
-import { resolveRoutineAuthority } from "./agentconfig.js";
 import { resolve } from "node:path";
-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. */
@@ -65,18 +61,6 @@ export function shouldPlanTask(input, sizing) {
 function refuse(reason, message) {
     return { ok: false, reason, message };
 }
-/** The fields an approver reads must BE what they appear to be: no control
- * characters anywhere, no invisible or direction-override text either. */
-function dishonest(text) {
-    return hasForbiddenControls(text) || hasDisguisedText(text);
-}
-/** Byte caps beside the character caps (Codex v3 review, change 8): a
- * 2000-character goal of astral-plane text is 8000 bytes — model-authored
- * fields must bound STORAGE, not just what a screen shows. */
-const BYTE_CAPS = { title: 800, name: 200, text: 8_000, path: 800, requirement: 400 };
-function overBytes(text, cap) {
-    return Buffer.byteLength(text, "utf8") > cap;
-}
 function checkRepo(given, admitted) {
     if (given === undefined || given === "") {
         // A ceiling names the ONLY repos this surface may file into. Filing
@@ -119,6 +103,7 @@ export function fileTaskProposal(store, input, now) {
         ...(input.goal === undefined ? {} : { goal: input.goal }),
         ...(input.permissionMode === undefined ? {} : { permissionMode: input.permissionMode }),
         ...(input.qualityMode === undefined ? {} : { qualityMode: input.qualityMode }),
+        ...(input.budgetMicrousd == null ? {} : { budgetMicrousd: input.budgetMicrousd }),
         outOfScope,
         touches,
         acceptance: input.acceptance,
@@ -153,73 +138,3 @@ export function fileTaskProposal(store, input, now) {
     }
     return { ok: true, id: made.id, planning, sizing };
 }
-export function fileRoutineProposal(store, input, now) {
-    if (!FILED_VIA.test(input.filedVia)) {
-        return refuse("bad-provenance", "filedVia is an audit token: lowercase letters, digits, dashes, colons");
-    }
-    const repo = checkRepo(input.repo, input.admittedRepos);
-    if (!repo.ok)
-        return repo;
-    if (repo.repo === undefined)
-        return refuse("bad-repo", "a routine needs the repository it runs in");
-    const acceptanceParse = parseAcceptanceCriteria(input.acceptance);
-    const terms = {
-        repo: repo.repo,
-        goal: input.goal,
-        outOfScope: input.outOfScope,
-        touches: input.touches,
-        acceptance: acceptanceParse.criteria,
-        requirements: input.requirements,
-        schedule: input.schedule,
-        // v1 routines run one instance at a time, period — hardcoded, not accepted.
-        singleFlight: true,
-        costCeilingUsd: input.costCeilingUsd,
-        ...(input.budgetPerRunMicrousd == null ? {} : { budgetPerRunMicrousd: input.budgetPerRunMicrousd }),
-    };
-    // EVERY problem at once — an operator fixing a form deserves the whole
-    // list, not one complaint per submission.
-    const problems = validateRoutineTerms(terms);
-    if (acceptanceParse.problems.length > 0) {
-        problems.push({ field: "acceptance", problem: acceptanceParse.problems.map(p => p.message).join("; ") });
-    }
-    if (!ROUTINE_NAME.test(input.name)) {
-        problems.unshift({ field: "name", problem: "lowercase letters, digits, and dashes — it becomes each instance's id" });
-    }
-    if (dishonest(input.goal) ||
-        overBytes(input.goal, BYTE_CAPS.text) ||
-        (input.outOfScope !== null && (dishonest(input.outOfScope) || overBytes(input.outOfScope, BYTE_CAPS.text)))) {
-        problems.push({ field: "goal", problem: "no control or disguised text, bounded bytes" });
-    }
-    // The v3 review, change 8: touches and requirements are approver-read
-    // text too — the door holds them to the same honesty everywhere.
-    if (input.touches.some(one => dishonest(one) || overBytes(one, BYTE_CAPS.path))) {
-        problems.push({ field: "touches", problem: "no control or disguised text, bounded bytes" });
-    }
-    if (input.requirements.some(one => dishonest(one) || overBytes(one, BYTE_CAPS.requirement))) {
-        problems.push({ field: "requirements", problem: "no control or disguised text, bounded bytes" });
-    }
-    if (problems.length > 0) {
-        const named = problems.map(one => `${one.field}: ${one.problem}`).join("; ");
-        return refuse(problems.some(one => one.field === "name") ? "bad-name" : "bad-terms", named);
-    }
-    // v24 filing invariant, routine flavor — since v48 the whole four-role
-    // ROUTE: resolve which agents plan, build, repair, and review a firing
-    // once, here, from the configuration of this moment, and bind route and
-    // profile into the digest a person will sign. Unresolved saves too
-    // (finding 19) — approval then refuses until the routine is restated.
-    const authority = resolveRoutineAuthority(store, repo.repo, terms.acceptance, now);
-    const routineProfile = authority.ok ? authority.profile : null;
-    const routineRoute = authority.ok ? authority.route : null;
-    const created = store.createRoutine({
-        name: input.name,
-        ...terms,
-        digest: routineDigestOf(terms, routineProfile, routineRoute),
-        filedVia: input.filedVia,
-        createdBy: input.createdBy ?? null,
-        ...(routineProfile === null ? {} : { profile: routineProfile }),
-        ...(routineRoute === null ? {} : { route: routineRoute }),
-    }, now);
-    if (!created.ok)
-        return refuse("duplicate", `a routine named ${input.name} already exists`);
-    return { ok: true, id: created.id, digest: routineDigestOf(terms, routineProfile, routineRoute) };
-}

package/dist/provider-auth.d.ts

@@ -45,7 +45,7 @@ export declare function authPauseOf(store: Store, provider: string): AuthPause |
 /**
  * SQL: whether the pause `pause` (a provider_auth_pause alias) is on one of
  * the task_ref `taskRef`'s current providers — its pins, its working profile,
- * route legs and fallback entries — so a task re-routed to another provider
+ * and route legs — so a task re-routed to another provider
  * stops saying it waits on the old one. A task that names none yet (an
  * unpinned planner, whose agent comes from configuration) keeps what the gate
  * found.
@@ -118,8 +118,8 @@ export type SignInGate = {
 };
 /**
  * The sign-in gate every road that starts an agent asks before it claims
- * anything: the tick's queue, and the roads beside it (fallback entries,
- * attended continuations, contest resumes). Waits when a provider is paused,
+ * anything: the tick's queue and the roads beside it.
+ * Waits when a provider is paused,
  * unless this is the pause's one trial. A waiting task is noted on its
  * task_ref, so the work index says exactly what the gate decided; a task let
  * through is un-noted. A road whose claim fails after a trial calls giveBack.

package/dist/provider-auth.js

@@ -72,7 +72,7 @@ export function authPauseOf(store, provider) {
 /**
  * SQL: whether the pause `pause` (a provider_auth_pause alias) is on one of
  * the task_ref `taskRef`'s current providers — its pins, its working profile,
- * route legs and fallback entries — so a task re-routed to another provider
+ * and route legs — so a task re-routed to another provider
  * stops saying it waits on the old one. A task that names none yet (an
  * unpinned planner, whose agent comes from configuration) keeps what the gate
  * found.
@@ -83,9 +83,7 @@ export function pauseOnTaskProviders(pause, taskRef) {
     UNION ALL SELECT json_extract(ts.profile_json, '$.provider') FROM task_ref r JOIN task_scope ts ON ts.task_id = r.external_id
       WHERE r.id = ${taskRef} AND json_valid(ts.profile_json)
     UNION ALL SELECT json_extract(leg.value, '$.provider') FROM task_ref r JOIN task_scope ts ON ts.task_id = r.external_id,
-      json_each(CASE WHEN json_valid(ts.proposed_route_json) THEN ts.proposed_route_json ELSE '{}' END, '$.legs') leg WHERE r.id = ${taskRef}
-    UNION ALL SELECT json_extract(entry.value, '$.profile.provider') FROM task_ref r JOIN task_scope ts ON ts.task_id = r.external_id,
-      json_each(CASE WHEN json_valid(ts.proposed_chain_json) THEN ts.proposed_chain_json ELSE '{}' END, '$.chain') entry WHERE r.id = ${taskRef}`;
+      json_each(CASE WHEN json_valid(ts.proposed_route_json) THEN ts.proposed_route_json ELSE '{}' END, '$.legs') leg WHERE r.id = ${taskRef}`;
     return `(${pause}.provider IN (SELECT provider FROM (${providers}) WHERE provider IS NOT NULL)
     OR NOT EXISTS (SELECT 1 FROM (${providers}) WHERE provider IS NOT NULL))`;
 }
@@ -227,8 +225,8 @@ export function giveBackAuthTrial(store, trial) {
 }
 /**
  * The sign-in gate every road that starts an agent asks before it claims
- * anything: the tick's queue, and the roads beside it (fallback entries,
- * attended continuations, contest resumes). Waits when a provider is paused,
+ * anything: the tick's queue and the roads beside it.
+ * Waits when a provider is paused,
  * unless this is the pause's one trial. A waiting task is noted on its
  * task_ref, so the work index says exactly what the gate decided; a task let
  * through is un-noted. A road whose claim fails after a trial calls giveBack.