toolroll 0.9.51 → 0.9.53

package/dist/cli.d.ts

@@ -80,6 +80,8 @@ export declare function extractOutputFlag(argv: readonly string[]): {
     error: string;
 };
 export declare function main(argv: readonly string[], write?: Write, mainOptions?: MainOptions): Promise<number>;
+/** What every former `toolroll routine …` command says now (v115; kept for this release only). */
+export declare const ROUTINES_MOVED = "Routines are now scheduled flows: see `toolroll flows list` (your routines were moved there).";
 export declare function partitionRoots(roots: readonly string[], exists: (path: string) => boolean): {
     present: string[];
     missing: string[];

package/dist/cli.js

@@ -255,7 +255,6 @@ export const OPERATE_COMMANDS = new Set([
     "publish",
     "reconcile",
     "run",
-    "routine",
     "flows",
     "config", "chat", "proposals", "mode", "chat-approval", "people", "tokens", "keys",
     "setup",
@@ -263,7 +262,6 @@ export const OPERATE_COMMANDS = new Set([
     "intake",
     "providers",
     "template",
-    "contest",
     "webhook",
     "sync",
 ]);
@@ -383,7 +381,17 @@ export async function main(argv, write = line => console.log(line), mainOptions
     }
     return code;
 }
+/** What every former `toolroll routine …` command says now (v115; kept for this release only). */
+export const ROUTINES_MOVED = "Routines are now scheduled flows: see `toolroll flows list` (your routines were moved there).";
+function routinesMoved(argv, write) {
+    write(argv.includes("--json") ? envelopeJson({ ok: true, command: "routine", message: ROUTINES_MOVED }) : ROUTINES_MOVED);
+    return 0;
+}
 async function dispatch(argv, write, mainOptions) {
+    // v115: routines became scheduled flows. Every old `routine …` invocation answers with one line pointing there —
+    // hidden from help and the contract, before anything remote or local opens, changing nothing.
+    if (argv[0] === "routine")
+        return routinesMoved(argv, write);
     // A saved API token sends commands marked remote to the central server, before anything local opens.
     if (argv[0] === 'health')
         return runHealthCommand(argv.slice(1), write, mainOptions.team ?? mainOptions.remote);

package/dist/contracts/cli.d.ts

@@ -563,7 +563,6 @@ export declare const COMMAND_OUTPUTS: {
         approval: z.ZodObject<{
             approved: z.ZodBoolean;
         }, z.core.$loose>;
-        risk: z.ZodString;
         route: z.ZodUnknown;
         runs: z.ZodArray<z.ZodUnknown>;
         deliverable: z.ZodString;
@@ -684,18 +683,6 @@ export declare const COMMAND_OUTPUTS: {
         reason: z.ZodString;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>], "ok">;
-    readonly "routine list": z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"routine list">;
-        routines: z.ZodArray<z.ZodUnknown>;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"routine list">;
-        reason: z.ZodString;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>], "ok">;
     readonly "incident list": z.ZodDiscriminatedUnion<[z.ZodObject<{
         envelopeVersion: z.ZodLiteral<1>;
         ok: z.ZodLiteral<true>;

package/dist/contracts/cli.js

@@ -140,7 +140,6 @@ const taskShowOutput = answers("task show", {
     position: z.unknown(),
     reservedFor: nullable(str),
     approval: z.looseObject({ approved: z.boolean() }),
-    risk: str,
     route: z.unknown(),
     runs: list,
     deliverable: str,
@@ -188,7 +187,6 @@ export const COMMAND_OUTPUTS = {
     "flows show": answers("flows show", { flow: z.looseObject({ id: int, name: str, repo: str, project: str, readable: z.boolean(), zones: list, triggers: list }) }),
     grants: answers("grants", { count: int, grants: list }),
     "runner list": answers("runner list", { count: int, runners: list }),
-    "routine list": answers("routine list", { routines: list }),
     "incident list": answers("incident list", { incidents: list }),
     "outbox list": answers("outbox list", { notifications: rows({ id: int, kind: str, subject: str, createdAt: str }) }),
     // A pass with failed deliveries answers ok: false with its counts and no reason.

package/dist/contracts/console-api.d.ts

@@ -123,15 +123,13 @@ export declare const CONSOLE_FORMS: {
     readonly tasksAdd: FormContract<"acceptance" | "after" | "goal" | "id" | "not" | "permission-mode" | "plan-first" | "planning-policy" | "projectRevision" | "quality-mode" | "repo" | "scout" | "title" | "touches">;
     readonly queue: FormContract<"before" | "column" | "from" | "note" | "projectRevision" | "queueRevision" | "respond" | "runner" | "task">;
     readonly runnerRegister: FormContract<"capacity" | "name" | "token">;
-    readonly mode: FormContract<"allow-paid-fallback" | "auto-approve" | "chat-approve" | "days" | "digest" | "expiry" | "name" | "nonce" | "plan-auto" | "publication" | "repair-auto" | "review-auto" | "review-retry-auto" | "token">;
+    readonly mode: FormContract<"auto-approve" | "chat-approve" | "days" | "digest" | "expiry" | "name" | "nonce" | "plan-auto" | "publication" | "repair-auto" | "review-auto" | "review-retry-auto" | "token">;
     readonly peopleProjects: FormContract<"access" | "name" | "projects" | "token">;
     readonly peopleInvite: FormContract<"access" | "projects" | "role" | "token">;
     readonly peopleInviteRevoke: FormContract<"id" | "token">;
     readonly peopleRevoke: FormContract<"name" | "token">;
     readonly runnerRetire: FormContract<"name" | "token">;
     readonly decisionAnswer: FormContract<"choice" | "confirm" | "note" | "return">;
-    readonly contest: FormContract<"act" | "choice" | "nonce" | "token">;
-    readonly attend: FormContract<"budget" | "digest" | "expiry" | "followup" | "minutes" | "model" | "nonce" | "parent" | "posture" | "token" | "turns">;
     readonly confirmStopped: FormContract<"checked" | "return" | "run" | "token">;
     readonly merge: FormContract<"anyway" | "run" | "token">;
     readonly onboard: FormContract<"big-ok" | "nonce" | "repo" | "root" | "token">;
@@ -152,12 +150,9 @@ export declare const CONSOLE_FORMS: {
     readonly chatFile: FormContract<"token">;
     readonly chatAck: FormContract<"nonce" | "token">;
     readonly recipes: FormContract<"document" | "next" | "preview" | "projectRevision" | "purpose" | "recipe" | "recipeRevision" | "repo" | "source" | "sourceRevision">;
-    readonly routinesAdd: FormContract<"acceptance" | "ceiling" | "goal" | "interval" | "interval-unit" | "name" | "not" | "projectRevision" | "repeat" | "schedule" | "time" | "timezone" | "touches" | "weekday">;
-    readonly routine: FormContract<"digest" | "nonce" | "token">;
     readonly runNote: FormContract<"note">;
     readonly diffComment: FormContract<"batch" | "intent" | "line" | "note" | "path" | "request" | "return" | "source" | "tab">;
     readonly editorLinks: FormContract<"on" | "return">;
-    readonly turn: FormContract<"text">;
     readonly revise: FormContract<"batch" | "return" | "source">;
     readonly followUp: FormContract<"level" | "return">;
     readonly resolveIncident: FormContract<"return">;
@@ -172,8 +167,8 @@ export declare const CONSOLE_FORMS: {
     readonly taskPlanEdit: FormContract<"plan-document" | "saw-plan">;
     readonly taskRevision: FormContract<"revision-id" | "token">;
     readonly taskCancel: FormContract<"reason">;
-    readonly taskRoute: FormContract<"agent" | "clear-phase" | "model" | "phase" | "provider" | "return" | "risk" | "risky" | "sawDigest" | "size">;
-    readonly taskScope: FormContract<"acceptance" | "budget-microusd" | "budget-usd" | "goal" | "goal-brief" | "not" | "permission-mode" | "quality-mode" | "race-count" | "race-model" | "race-per-usd" | "race-total-usd" | "requirement" | "requirement-new" | "sawDigest" | "touches" | `compare-model-${string}` | `compare-provider-${string}`>;
+    readonly taskRoute: FormContract<"agent" | "clear-phase" | "model" | "phase" | "provider" | "return" | "risky" | "sawDigest" | "size">;
+    readonly taskScope: FormContract<"acceptance" | "budget-microusd" | "budget-usd" | "goal" | "goal-brief" | "not" | "permission-mode" | "quality-mode" | "requirement" | "requirement-new" | "sawDigest" | "touches">;
     readonly taskApprove: FormContract<"digest" | "nonce" | "return" | "token">;
     readonly taskAcceptProof: FormContract<"note" | "return" | "run">;
     readonly taskComplete: FormContract<"accept" | "note" | "publish" | "receipt" | "return" | "run">;
@@ -181,8 +176,8 @@ export declare const CONSOLE_FORMS: {
     readonly taskResume: FormContract<"nonce" | "return" | "run" | "token">;
 };
 export type ConsoleFormName = keyof typeof CONSOLE_FORMS;
-/** The console POSTs whose handlers read no field (sign-out and the attended beat not even the shared guard): their contract is the empty form. */
-export declare const BODILESS_POSTS: readonly ["POST /settings/lead/on", "POST /r/<run>/draft-repair", "POST /ledger/checkpoint", "POST /settings/backups/now", "POST /mode/revoke", "POST /settings/telegram/retry", "POST /providers/<provider>/resume", "POST /session/attended-beats", "POST /logout", "POST /t/<task>/unhold", "POST /t/<task>/plan", "POST /t/<task>/retry-review"];
+/** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */
+export declare const BODILESS_POSTS: readonly ["POST /settings/lead/on", "POST /r/<run>/draft-repair", "POST /ledger/checkpoint", "POST /settings/backups/now", "POST /mode/revoke", "POST /settings/telegram/retry", "POST /providers/<provider>/resume", "POST /logout", "POST /t/<task>/unhold", "POST /t/<task>/plan", "POST /t/<task>/retry-review"];
 /** The field names a console form's handler may read. */
 export type FormFieldOf<N extends ConsoleFormName> = (typeof CONSOLE_FORMS)[N] extends FormContract<infer K> ? K : never;
 /** `GET /ledger?format=json`: the chain's state, a page of entries (newest first) and the cursor for the next. */

package/dist/contracts/console-api.js

@@ -132,15 +132,13 @@ export const CONSOLE_FORMS = {
     tasksAdd: formContract("POST /tasks/add", ["projectRevision", "id", "title", "repo", "goal", "not", "touches", "scout", "permission-mode", "quality-mode", "after", "acceptance", "planning-policy", "plan-first"]),
     queue: formContract("POST /queue/move, /queue/note", ["runner", "note", "from", "projectRevision", "respond", "task", "column", "before", "queueRevision"]),
     runnerRegister: formContract("POST /fleet/runner/register", ["token", "name", "capacity"]),
-    mode: formContract("POST /mode/confirm, /mode/sign", ["name", "days", "auto-approve", "plan-auto", "allow-paid-fallback", "chat-approve", "publication", "expiry", "nonce", "digest", "token", "review-auto", "review-retry-auto", "repair-auto"]),
+    mode: formContract("POST /mode/confirm, /mode/sign", ["name", "days", "auto-approve", "plan-auto", "chat-approve", "publication", "expiry", "nonce", "digest", "token", "review-auto", "review-retry-auto", "repair-auto"]),
     peopleProjects: formContract("POST /people/projects", ["token", "name", "access", "projects"]),
     peopleInvite: formContract("POST /people/invite", ["token", "role", "access", "projects"]),
     peopleInviteRevoke: formContract("POST /people/invite-revoke", ["token", "id"]),
     peopleRevoke: formContract("POST /people/revoke", ["token", "name"]),
     runnerRetire: formContract("POST /fleet/runner/retire", ["token", "name"]),
     decisionAnswer: formContract("POST /d/<id>/answer", ["return", "choice", "confirm", "note"]),
-    contest: formContract("POST /contest/<id>/arm|pick|abandon", ["act", "choice", "token", "nonce"]),
-    attend: formContract("POST /t/<task>/attend|attend-preview|attend-revoke", ["parent", "followup", "minutes", "turns", "budget", "expiry", "model", "posture", "nonce", "digest", "token"]),
     confirmStopped: formContract("POST /t/<task>/confirm-stopped", ["run", "token", "checked", "return"]),
     merge: formContract("POST /t/<task>/merge", ["run", "token", "anyway"]),
     onboard: formContract("POST /projects/onboard-preview, /projects/onboard-confirm", ["repo", "root", "token", "nonce", "big-ok"]),
@@ -162,12 +160,9 @@ export const CONSOLE_FORMS = {
     chatAck: formContract("POST /chat/ack/<id>", ["token", "nonce"]),
     // A recipe's own answers and editor fields are read by recipes.ts from the whole form (`sent`; item 17).
     recipes: formContract("POST /recipes/prepare, /recipes/preview, /recipes/import, /recipes/launch, /recipes/save", ["repo", "projectRevision", "recipe", "recipeRevision", "document", "purpose", "source", "sourceRevision", "preview", "next"]),
-    routinesAdd: formContract("POST /routines/add", ["projectRevision", "name", "ceiling", "repeat", "interval", "interval-unit", "time", "timezone", "weekday", "schedule", "goal", "not", "touches", "acceptance"]),
-    routine: formContract("POST /routines/<id>/approve|refresh|pause|resume|run-now", ["digest", "nonce", "token"]),
     runNote: formContract("POST /r/<run>/note", ["note"]),
     diffComment: formContract("POST /r/<run>/comment", ["return", "tab", "intent", "batch", "source", "note", "path", "line", "request"]),
     editorLinks: formContract("POST /session/editor-links", ["on", "return"]),
-    turn: formContract("POST /r/<run>/turn", ["text"]),
     revise: formContract("POST /r/<run>/revise", ["return", "batch", "source"]),
     followUp: formContract("POST /r/<run>/checks|add-tests", ["return", "level"]),
     resolveIncident: formContract("POST /i/<id>/resolve", ["return"]),
@@ -183,15 +178,15 @@ export const CONSOLE_FORMS = {
     taskPlanEdit: formContract("POST /t/<task>/plan-edit", ["saw-plan", "plan-document"]),
     taskRevision: formContract("POST /t/<task>/accept-revision|reject-revision", ["revision-id", "token"]),
     taskCancel: formContract("POST /t/<task>/cancel", ["reason"]),
-    taskRoute: formContract("POST /t/<task>/route", ["risk", "size", "risky", "phase", "clear-phase", "agent", "provider", "model", "sawDigest", "return"]),
-    taskScope: formContract("POST /t/<task>/scope", ["sawDigest", "permission-mode", "quality-mode", "budget-usd", "budget-microusd", "requirement", "requirement-new", "race-count", "race-model", "race-per-usd", "race-total-usd", "goal-brief", "goal", "not", "touches", "acceptance"], { prefixes: ["compare-provider-", "compare-model-"] }),
+    taskRoute: formContract("POST /t/<task>/route", ["size", "risky", "phase", "clear-phase", "agent", "provider", "model", "sawDigest", "return"]),
+    taskScope: formContract("POST /t/<task>/scope", ["sawDigest", "permission-mode", "quality-mode", "budget-usd", "budget-microusd", "requirement", "requirement-new", "goal-brief", "goal", "not", "touches", "acceptance"]),
     taskApprove: formContract("POST /t/<task>/approve", ["return", "digest", "token", "nonce"]),
     taskAcceptProof: formContract("POST /t/<task>/accept-proof", ["run", "note", "return"]),
     taskComplete: formContract("POST /t/<task>/complete", ["receipt", "run", "accept", "note", "publish", "return"]),
     taskStop: formContract("POST /t/<task>/stop", ["run", "return"]),
     taskResume: formContract("POST /t/<task>/resume|resume-arm", ["run", "token", "nonce", "return"]),
 };
-/** The console POSTs whose handlers read no field (sign-out and the attended beat not even the shared guard): their contract is the empty form. */
+/** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */
 export const BODILESS_POSTS = [
     "POST /settings/lead/on",
     "POST /r/<run>/draft-repair",
@@ -200,7 +195,6 @@ export const BODILESS_POSTS = [
     "POST /mode/revoke",
     "POST /settings/telegram/retry",
     "POST /providers/<provider>/resume",
-    "POST /session/attended-beats",
     "POST /logout",
     "POST /t/<task>/unhold",
     "POST /t/<task>/plan",

package/dist/contracts/flow.d.ts

@@ -10964,6 +10964,36 @@ export declare const leadTriggerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
     timeZone: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>], "kind">;
+/**
+ * v115: the exact task a schedule files each time — what a routine was before routines became scheduled flows. Its
+ * terms are copied into each firing's scope unchanged; `costCeilingUsd` caps what its tasks spend in a rolling 7 days
+ * and a firing waits while the last task is unfinished. `approval` is a routine's approval carried over whole (the
+ * digest the approver signed over these terms, this schedule and project, and the agents it froze): while it still
+ * verifies, each firing is approved as the routine's were; otherwise each firing is an ordinary proposal under the
+ * project's approval rules. Only the v115 migration carries an approval; a template or a recipe makes one with none
+ * (createScheduledFlow), and no trigger settings a person or a flow file gives can carry one.
+ */
+export declare const standingOrderSchema: z.ZodObject<{
+    stem: z.ZodString;
+    goal: z.ZodString;
+    outOfScope: z.ZodNullable<z.ZodString>;
+    touches: z.ZodArray<z.ZodString>;
+    requirements: z.ZodArray<z.ZodString>;
+    acceptance: z.ZodArray<z.ZodUnknown>;
+    budgetPerRunMicrousd: z.ZodNullable<z.ZodInt>;
+    costCeilingUsd: z.ZodNullable<z.ZodNumber>;
+    singleFlight: z.ZodLiteral<true>;
+    filedBy: z.ZodNullable<z.ZodString>;
+    routine: z.ZodNullable<z.ZodInt>;
+    approval: z.ZodNullable<z.ZodObject<{
+        digest: z.ZodString;
+        by: z.ZodNullable<z.ZodString>;
+        at: z.ZodString;
+        profileJson: z.ZodString;
+        routeJson: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StandingOrder = z.infer<typeof standingOrderSchema>;
 /** A trigger as it is saved (`configJson`), one schema per kind. */
 export declare const triggerConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     zone: z.ZodNullable<z.ZodString>;
@@ -10978,6 +11008,26 @@ export declare const triggerConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     description: z.ZodNullable<z.ZodString>;
     script: z.ZodOptional<z.ZodString>;
     secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    order: z.ZodOptional<z.ZodObject<{
+        stem: z.ZodString;
+        goal: z.ZodString;
+        outOfScope: z.ZodNullable<z.ZodString>;
+        touches: z.ZodArray<z.ZodString>;
+        requirements: z.ZodArray<z.ZodString>;
+        acceptance: z.ZodArray<z.ZodUnknown>;
+        budgetPerRunMicrousd: z.ZodNullable<z.ZodInt>;
+        costCeilingUsd: z.ZodNullable<z.ZodNumber>;
+        singleFlight: z.ZodLiteral<true>;
+        filedBy: z.ZodNullable<z.ZodString>;
+        routine: z.ZodNullable<z.ZodInt>;
+        approval: z.ZodNullable<z.ZodObject<{
+            digest: z.ZodString;
+            by: z.ZodNullable<z.ZodString>;
+            at: z.ZodString;
+            profileJson: z.ZodString;
+            routeJson: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{
     zone: z.ZodNullable<z.ZodString>;
     kind: z.ZodLiteral<"github">;

package/dist/contracts/flow.js

@@ -309,11 +309,36 @@ export const leadTriggerSchema = z.discriminatedUnion("kind", [
     TRIGGER_INPUTS.flow.omit({ flow: true }).extend({ follow: z.int().min(1).describe("The other flow's id (get_flows).") }), TRIGGER_INPUTS.email, TRIGGER_INPUTS["plane-review"],
 ]);
 const ZONE_OR_NULL = { zone: zoneId.nullable() };
+/**
+ * v115: the exact task a schedule files each time — what a routine was before routines became scheduled flows. Its
+ * terms are copied into each firing's scope unchanged; `costCeilingUsd` caps what its tasks spend in a rolling 7 days
+ * and a firing waits while the last task is unfinished. `approval` is a routine's approval carried over whole (the
+ * digest the approver signed over these terms, this schedule and project, and the agents it froze): while it still
+ * verifies, each firing is approved as the routine's were; otherwise each firing is an ordinary proposal under the
+ * project's approval rules. Only the v115 migration carries an approval; a template or a recipe makes one with none
+ * (createScheduledFlow), and no trigger settings a person or a flow file gives can carry one.
+ */
+export const standingOrderSchema = z.strictObject({
+    stem: z.string().regex(/^[a-z0-9][a-z0-9-]{0,40}$/),
+    // The terms exactly as they were approved: each firing's filing checks them again, as every filing is checked.
+    goal: z.string().max(8_000),
+    outOfScope: z.string().max(8_000).nullable(),
+    touches: z.array(z.string().max(800)).max(200),
+    requirements: z.array(z.string().max(400)).max(100),
+    acceptance: z.array(z.unknown()),
+    budgetPerRunMicrousd: z.int().nullable(),
+    costCeilingUsd: z.number().nullable(),
+    singleFlight: z.literal(true),
+    filedBy: z.string().min(1).nullable(),
+    /** The routine it came from: that routine's earlier tasks still count toward one-at-a-time and the ceiling. */
+    routine: z.int().nullable(),
+    approval: z.strictObject({ digest: z.string().min(1), by: z.string().nullable(), at: z.string().min(1), profileJson: z.string().min(1), routeJson: z.string().min(1) }).nullable(),
+});
 /** A trigger as it is saved (`configJson`), one schema per kind. */
 export const triggerConfigSchema = z.discriminatedUnion("kind", [
     z.strictObject({ kind: z.literal("button"), label: z.string().min(1).max(TEXT_LIMITS.triggerButton), questions: z.array(z.string().min(1).max(TEXT_LIMITS.triggerQuestion)).min(1).max(6), ...ZONE_OR_NULL }),
     /** `script`: run this project script on the schedule and make a card of each item it prints, instead of one card titled `title`. */
-    z.strictObject({ kind: z.literal("schedule"), schedule: z.string().min(1), title: z.string().min(1).max(TEXT_LIMITS.triggerTitle), description: z.string().max(TEXT_LIMITS.triggerDescription).nullable(), ...ZONE_OR_NULL, script: scriptName.optional(), secrets: z.array(secretName).min(1).max(SECRETS_MAX).optional() }),
+    z.strictObject({ kind: z.literal("schedule"), schedule: z.string().min(1), title: z.string().min(1).max(TEXT_LIMITS.triggerTitle), description: z.string().max(TEXT_LIMITS.triggerDescription).nullable(), ...ZONE_OR_NULL, script: scriptName.optional(), secrets: z.array(secretName).min(1).max(SECRETS_MAX).optional(), order: standingOrderSchema.optional() }),
     z.strictObject({ kind: z.literal("github"), repo: z.string().min(1).max(TEXT_LIMITS.triggerGithubRepo), watch: z.enum(["issues", "pulls", "checks"]), label: z.string().max(TEXT_LIMITS.triggerLabel).nullable(), branch: z.string().max(TEXT_LIMITS.triggerBranch).nullable(), from: z.enum(["team", "anyone"]), delivery, ...ZONE_OR_NULL }),
     z.strictObject({ kind: z.literal("linear"), team: z.string().max(TEXT_LIMITS.triggerTeam).nullable(), state: z.string().max(TEXT_LIMITS.triggerState).nullable(), label: z.string().max(TEXT_LIMITS.triggerLabel).nullable(), delivery, ...ZONE_OR_NULL }),
     z.strictObject({ kind: z.literal("flow"), flow: z.int().min(1), when: zoneId, ...ZONE_OR_NULL }),

package/dist/contracts/lead-tools.d.ts

@@ -686,11 +686,6 @@ export declare const LEAD_TOOL_INPUTS: {
     }, z.core.$strict>;
     readonly propose_agents: z.ZodObject<{
         task: z.ZodString;
-        risk: z.ZodOptional<z.ZodEnum<{
-            elevated: "elevated";
-            high: "high";
-            routine: "routine";
-        }>>;
         size: z.ZodOptional<z.ZodEnum<{
             large: "large";
             medium: "medium";
@@ -1388,11 +1383,6 @@ export declare const LEAD_TOOL_READ_INPUTS: {
     }, z.core.$strict>;
     readonly propose_agents: z.ZodObject<{
         task: z.ZodString;
-        risk: z.ZodOptional<z.ZodEnum<{
-            elevated: "elevated";
-            high: "high";
-            routine: "routine";
-        }>>;
         size: z.ZodOptional<z.ZodEnum<{
             large: "large";
             medium: "medium";
@@ -1811,9 +1801,6 @@ export declare const LEAD_TOOL_OUTPUTS: {
     readonly get_agents: z.ZodObject<{
         repo: z.ZodString;
         task: z.ZodString;
-        risk: z.ZodObject<{
-            level: z.ZodString;
-        }, z.core.$loose>;
         standing: z.ZodString;
         agents: z.ZodArray<z.ZodUnknown>;
         choices: z.ZodObject<{}, z.core.$loose>;

package/dist/contracts/lead-tools.js

@@ -16,7 +16,7 @@ import { CHAT_TASK_ACTIONS } from "../chat-task-actions.js";
 import { LIMITS } from "../decision.js";
 import { CHECK_RESULTS, RUN_OUTCOMES, TASK_STATES } from "../lead-commitments.js";
 import { PERSON_ID } from "../lead-people.js";
-import { RISK_LEVELS, TASK_SIZES } from "../phase-routing.js";
+import { TASK_SIZES } from "../phase-routing.js";
 import { ACCEPTANCE_LIMITS } from "../scope.js";
 import { TEAMMATE_TEMPLATES } from "../teammates.js";
 import { TEXT_LIMITS } from "../text-limits.js";
@@ -134,7 +134,7 @@ export const LEAD_TOOL_INPUTS = {
     propose_dependency_repair: z.strictObject({ task: taskRef, blocker: taskRef, operation: z.enum(["retry", "unlink", "replace"]), replacement: taskRef.optional() }),
     propose_scope: z.strictObject({ task: taskRef, goal: scopeText, not: scopeText.nullable().optional(), touches: touches.optional(), acceptance }),
     propose_agents: z.strictObject({
-        task: taskRef, risk: z.enum(RISK_LEVELS).optional(),
+        task: taskRef,
         size: z.enum(TASK_SIZES).optional(), risky: z.boolean().optional(),
         role: z.enum(["planner", "builder", "repair"]).optional(),
         agent: z.strictObject({ provider: text("agentProvider"), model: text("agentModel") }).optional(),
@@ -238,7 +238,7 @@ export const LEAD_TOOL_OUTPUTS = {
         repo: str, task: str, root: str, currentExecution: str, title: str, state: str, deliverable: str, scope: str,
         queue: nullable(z.looseObject({ position: int, of: int, column: str })), holds: list, attempts: int, decisionsOpen: int, dependencies: list,
     }),
-    get_agents: z.looseObject({ repo: str, task: str, risk: z.looseObject({ level: str }), standing: str, agents: list, choices: z.looseObject({}), approval: str, organisationPolicy: z.looseObject({}) }),
+    get_agents: z.looseObject({ repo: str, task: str, standing: str, agents: list, choices: z.looseObject({}), approval: str, organisationPolicy: z.looseObject({}) }),
     list_decisions: decisionsOutput,
     get_decision: decisionOutput,
     queue: z.looseObject({ repo: str, queueRevision: int, ...queueColumnsOutput }),

package/dist/contracts/store-json.d.ts

@@ -115,11 +115,7 @@ declare const STORE_COLUMN_VALUES: {
         quickMint: z.ZodOptional<z.ZodBoolean>;
         publication: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>;
-    readonly "attended_authorization.terms_json": z.ZodObject<{
-        profileJson: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$loose>;
     readonly "approval_policy.protected_paths": z.ZodArray<z.ZodUnknown>;
-    readonly "fallback_config.entries_json": z.ZodArray<z.ZodUnknown>;
     readonly "runner.repos": z.ZodArray<z.ZodUnknown>;
     readonly "runner.agents": z.ZodArray<z.ZodUnknown>;
     readonly "decision.options": z.ZodArray<z.ZodObject<{
@@ -169,26 +165,6 @@ declare const STORE_COLUMN_VALUES: {
     }>>;
     readonly "task_ref.zones": z.ZodArray<z.ZodUnknown>;
     readonly "task_ref.capability_requirements": z.ZodArray<z.ZodUnknown>;
-    readonly "routine.touches": z.ZodArray<z.ZodUnknown>;
-    readonly "routine.requirements": z.ZodArray<z.ZodUnknown>;
-    /** Read by `parseAcceptanceCriteria`, as `task_scope.acceptance_json`. */
-    readonly "routine.acceptance_json": z.ZodLazy<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        statement: z.ZodString;
-        how: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        evidence: z.ZodArray<z.ZodEnum<{
-            "changed-path": "changed-path";
-            check: "check";
-            "manual-review": "manual-review";
-            screenshot: "screenshot";
-        }>>;
-    }, z.core.$strict>>>;
-    readonly "tournament_terms.agents": z.ZodArray<z.ZodObject<{
-        provider: z.ZodString;
-        model: z.ZodString;
-        repairModel: z.ZodString;
-        permissionMode: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
     readonly "coordinator_proposal.payload_json": z.ZodObject<{}, z.core.$loose>;
     readonly "coordinator_proposal.outcome_json": z.ZodObject<{}, z.core.$loose>;
     readonly "mate_proposal.payload_json": z.ZodUnion<readonly [z.ZodObject<{
@@ -278,7 +254,7 @@ declare const STORE_COLUMN_VALUES: {
 export type StoreColumn = keyof typeof STORE_COLUMN_VALUES;
 export type StoreColumnValue<C extends StoreColumn> = z.infer<(typeof STORE_COLUMN_VALUES)[C]>;
 /** Every JSON column the store reads itself, by `table.column`. */
-export declare const STORE_COLUMNS: ("approval_policy.protected_paths" | "attended_authorization.terms_json" | "backend_grant.mutations" | "backend_grant.paths" | "coordinator_proposal.outcome_json" | "coordinator_proposal.payload_json" | "criterion_review.screenshots_json" | "decision.options" | "fallback_config.entries_json" | "flow_card.source_json" | "flow_comment.mentions_json" | "lead_config.about_json" | "mate_ask.options_json" | "mate_proposal.outcome_json" | "mate_proposal.payload_json" | "mutation.result" | "operating_mode.terms_json" | "plan_revision.changed_fields" | "proof_verdict.matrix_json" | "proof_verdict.reasons_json" | "publication_grant.capabilities" | "repair_chain.unresolved_json" | "routine.acceptance_json" | "routine.requirements" | "routine.touches" | "run_check.suites_json" | "run_checkpoint.snapshot_json" | "run_tool.tools_json" | "runner.agents" | "runner.repos" | "task_ref.capability_requirements" | "task_ref.zones" | "task_scope.acceptance_json" | "task_scope.touches" | "teammate_call.input_json" | "teammate_event.detail_json" | "teammate_question.options_json" | "teammate_suggestion.evidence_json" | "teammate_suggestion.rule_json" | "teammate_suggestion.was_json" | "teammate_tool.actions_json" | "teammate_tool.rules_json" | "telegram_conversation_part.keyboard_json" | "tool_seal.tools_json" | "tournament_terms.agents")[];
+export declare const STORE_COLUMNS: ("approval_policy.protected_paths" | "backend_grant.mutations" | "backend_grant.paths" | "coordinator_proposal.outcome_json" | "coordinator_proposal.payload_json" | "criterion_review.screenshots_json" | "decision.options" | "flow_card.source_json" | "flow_comment.mentions_json" | "lead_config.about_json" | "mate_ask.options_json" | "mate_proposal.outcome_json" | "mate_proposal.payload_json" | "mutation.result" | "operating_mode.terms_json" | "plan_revision.changed_fields" | "proof_verdict.matrix_json" | "proof_verdict.reasons_json" | "publication_grant.capabilities" | "repair_chain.unresolved_json" | "run_check.suites_json" | "run_checkpoint.snapshot_json" | "run_tool.tools_json" | "runner.agents" | "runner.repos" | "task_ref.capability_requirements" | "task_ref.zones" | "task_scope.acceptance_json" | "task_scope.touches" | "teammate_call.input_json" | "teammate_event.detail_json" | "teammate_question.options_json" | "teammate_suggestion.evidence_json" | "teammate_suggestion.rule_json" | "teammate_suggestion.was_json" | "teammate_tool.actions_json" | "teammate_tool.rules_json" | "telegram_conversation_part.keyboard_json" | "tool_seal.tools_json")[];
 /** A SQL projection, not a physical column; replay it separately after its owning column. */
 export declare const STORE_PROJECTIONS: readonly ["run_tool.tools_json.fence"];
 /** These readers historically only parsed JSON. Shape errors must not change their values or catch boundaries. */

package/dist/contracts/store-json.js

@@ -53,9 +53,6 @@ const savedProgressSchema = z.looseObject({
         id: z.string(), state: z.enum(["pending", "current", "completed", "blocked"]), note: z.string().nullable().optional(),
     })),
 });
-const savedAgentSchema = z.looseObject({
-    provider: z.string(), model: z.string(), repairModel: z.string(), permissionMode: z.string().optional(),
-});
 const savedKeyboardSchema = z.array(z.array(telegramCallbackButtonSchema.extend({ callback_data: z.string() }).loose()));
 const savedMatrixRowSchema = proofCriterionSchema.pick({ id: true, statement: true }).extend({
     id: z.string(), statement: z.string(), requiredEvidence: savedList, state: z.string(), detail: savedList,
@@ -78,9 +75,7 @@ const STORE_COLUMN_VALUES = {
     /** Read by the scope contract's `parseAcceptanceCriteria` (`scope.ts`), which owns the criterion's shape. */
     "task_scope.acceptance_json": storedRubricSchema,
     "operating_mode.terms_json": savedModeTermsSchema,
-    "attended_authorization.terms_json": z.looseObject({ profileJson: z.string().nullable().optional() }),
     "approval_policy.protected_paths": savedList,
-    "fallback_config.entries_json": savedList,
     "runner.repos": savedList,
     "runner.agents": savedList,
     "decision.options": z.array(savedDecisionOptionSchema),
@@ -97,11 +92,6 @@ const STORE_COLUMN_VALUES = {
     "publication_grant.capabilities": z.array(z.enum(["push-branch", "open-pr"])),
     "task_ref.zones": savedList,
     "task_ref.capability_requirements": savedList,
-    "routine.touches": savedList,
-    "routine.requirements": savedList,
-    /** Read by `parseAcceptanceCriteria`, as `task_scope.acceptance_json`. */
-    "routine.acceptance_json": storedRubricSchema,
-    "tournament_terms.agents": z.array(savedAgentSchema),
     "coordinator_proposal.payload_json": savedObject,
     "coordinator_proposal.outcome_json": savedObject,
     // Other proposal kinds have operation-specific fields; the action variant already has a canonical contract.
@@ -122,11 +112,11 @@ export const STORE_PROJECTIONS = ["run_tool.tools_json.fence"];
 export const LEGACY_JSON_COLUMNS = [
     "teammate_suggestion.rule_json", "teammate_suggestion.was_json", "teammate_suggestion.evidence_json",
     "teammate_call.input_json", "teammate_tool.actions_json", "teammate_tool.rules_json", "teammate_question.options_json",
-    "teammate_event.detail_json", "task_scope.touches", "task_scope.acceptance_json", "routine.acceptance_json",
-    "operating_mode.terms_json", "attended_authorization.terms_json", "decision.options", "run_tool.tools_json",
+    "teammate_event.detail_json", "task_scope.touches", "task_scope.acceptance_json",
+    "operating_mode.terms_json", "decision.options", "run_tool.tools_json",
     "run_tool.tools_json.fence", "mate_ask.options_json", "mutation.result", "plan_revision.changed_fields",
     "run_checkpoint.snapshot_json", "telegram_conversation_part.keyboard_json", "publication_grant.capabilities",
-    "tournament_terms.agents", "coordinator_proposal.payload_json", "coordinator_proposal.outcome_json",
+    "coordinator_proposal.payload_json", "coordinator_proposal.outcome_json",
     "mate_proposal.payload_json", "mate_proposal.outcome_json",
 ];
 /** One column's versioned envelope: `{ version: 1, value }`, built in memory around the saved bare value. */

package/dist/converse.d.ts

@@ -110,17 +110,7 @@ export type ChatTaskDraft = {
      * password before it becomes a real, unapproved scope. */
     acceptance: AcceptanceCriterion[];
 };
-export type ChatRoutineDraft = {
-    kind: "routine";
-    repoId: string;
-    name: string;
-    goal: string;
-    outOfScope: string | null;
-    touches: string[];
-    acceptance: AcceptanceCriterion[];
-    schedule: string;
-};
-export type ChatDraft = ChatTaskDraft | ChatRoutineDraft;
+export type ChatDraft = ChatTaskDraft;
 export type ParsedEnvelope = {
     reply: string;
     proposals: ChatDraft[];

package/dist/converse.js

@@ -22,7 +22,6 @@
 import { TASK_TEXT_LIMITS } from "./task-text.js";
 import { createHash } from "node:crypto";
 import { hasForbiddenControls, hasDisguisedText } from "./decision.js";
-import { ROUTINE_NAME, parseSchedule } from "./routine.js";
 import { parseAcceptanceCriteria } from "./scope.js";
 // ---------------------------------------------------------------- limits
 export const WRAPPER_CAP_BYTES = 262_144; // the provider response body
@@ -285,17 +284,8 @@ function readDraft(raw) {
         return null;
     const body = raw;
     const kind = body["kind"];
-    if (kind === "task") {
-        if (!exactKeys(body, ["kind", "repoId", "title", "goal", "outOfScope", "touches", "acceptance"]))
-            return null;
-    }
-    else if (kind === "routine") {
-        if (!exactKeys(body, ["kind", "repoId", "name", "goal", "outOfScope", "touches", "schedule", "acceptance"]))
-            return null;
-    }
-    else {
+    if (kind !== "task" || !exactKeys(body, ["kind", "repoId", "title", "goal", "outOfScope", "touches", "acceptance"]))
         return null;
-    }
     const repoId = body["repoId"];
     const goal = body["goal"];
     const outOfScope = body["outOfScope"];
@@ -318,28 +308,10 @@ function readDraft(raw) {
     if (acceptanceParse.problems.length > 0 || acceptanceParse.criteria.length === 0)
         return null;
     const acceptance = acceptanceParse.criteria;
-    if (kind === "task") {
-        const title = body["title"];
-        if (typeof title !== "string" || title.trim() === "" || !honest(title, 200, 800))
-            return null;
-        return { kind, repoId, title, goal, outOfScope: outOfScope, touches: touches, acceptance };
-    }
-    const name = body["name"];
-    const schedule = body["schedule"];
-    if (typeof name !== "string" || !ROUTINE_NAME.test(name))
-        return null;
-    if (typeof schedule !== "string" || parseSchedule(schedule) === null)
+    const title = body["title"];
+    if (typeof title !== "string" || title.trim() === "" || !honest(title, 200, 800))
         return null;
-    return {
-        kind,
-        repoId,
-        name,
-        goal,
-        outOfScope: outOfScope,
-        touches: touches,
-        acceptance,
-        schedule,
-    };
+    return { kind, repoId, title, goal, outOfScope: outOfScope, touches: touches, acceptance };
 }
 /**
  * The assistant envelope: exactly {chatEnvelope: 1, reply, proposals}.
@@ -716,14 +688,12 @@ export function buildDataDocument(snapshot, budgetBytes = DATA_DOCUMENT_BUDGET_B
         })),
         decisions: snapshot.decisions.map(one => ({ repo: id(one.repoIndex), id: one.id, question: one.question, optionLabels: one.optionLabels })),
         incidents: snapshot.incidents.map(one => ({ repo: id(one.repoIndex), kind: one.kind, ageHours: one.ageHours })),
-        routines: snapshot.routines.map(one => ({ repo: id(one.repoIndex), name: one.name, schedule: one.schedule, status: one.status, lastFire: one.lastFire })),
         publications: snapshot.publications.map(one => ({ repo: id(one.repoIndex), pr: one.pr, checkState: one.checkState })),
     };
     const notShown = {
         tasks: snapshot.tasksSaturated ? "more exist" : "",
         decisions: snapshot.decisionsSaturated ? "more exist" : "",
         incidents: snapshot.incidentsSaturated ? "more exist" : "",
-        routines: snapshot.routinesSaturated ? "more exist" : "",
         publications: snapshot.publicationsSaturated ? "more exist" : "",
     };
     let shed = 0;
@@ -756,10 +726,8 @@ const SYSTEM_RULES = [
     "Never recommend which option a pending decision should take.",
     "Answer with EXACTLY one JSON document and nothing else:",
     '{"chatEnvelope": 1, "reply": "<markdown-free plain text>", "proposals": []}',
-    "A proposal is either",
-    '{"kind":"task","repoId":"r1","title":"…","goal":"…","outOfScope":null,"touches":[],"acceptance":[…]}',
-    "or",
-    '{"kind":"routine","repoId":"r1","name":"lowercase-dashes","goal":"…","outOfScope":null,"touches":[],"schedule":"daily:03:30[@Zone], weekly:<0-6>:<HH:MM>[@Zone], or every:<minutes>","acceptance":[…]}.',
+    "A proposal is",
+    '{"kind":"task","repoId":"r1","title":"…","goal":"…","outOfScope":null,"touches":[],"acceptance":[…]}.',
     'acceptance is REQUIRED and non-empty: [{"id":"c1","statement":"<one testable outcome>","evidence":["check"|"screenshot"|"changed-path"|"manual-review",…],"how":"<optional guidance, or null>"}]. A proposal with no acceptance criterion is dropped, whole.',
     "At most 3 proposals. repoId must be one of the ids in the data document.",
 ].join("\n");

package/dist/coordinator.d.ts

@@ -107,7 +107,6 @@ export declare function statusFor(store: Store, who: VerifiedCoordinator, now: D
         approvals: number;
         questions: number;
         incidents: number;
-        picks: number;
     };
     running: number;
     builtToday: number;

package/dist/coordinator.js

@@ -300,8 +300,6 @@ export function statusFor(store, who, now) {
     const incidents = one(`SELECT COUNT(*) AS n FROM incident JOIN run ON run.id = incident.run
       JOIN task_ref ON task_ref.id = run.task_ref AND task_ref.backend = 'built-in'
       WHERE task_ref.repo IN (${sql}) AND incident.resolved_at IS NULL`);
-    const picks = one(`SELECT COUNT(*) AS n FROM contest JOIN task_ref ON task_ref.id = contest.task_ref AND task_ref.backend = 'built-in'
-      WHERE task_ref.repo IN (${sql}) AND contest.state = 'pick-wait'`);
     const builtToday = one(`SELECT COUNT(*) AS n FROM run JOIN task_ref ON task_ref.id = run.task_ref AND task_ref.backend = 'built-in'
       WHERE task_ref.repo IN (${sql}) AND run.outcome = 'built' AND run.finished_at > ?`, [dayAgo]);
     const failedToday = one(`SELECT COUNT(*) AS n FROM run JOIN task_ref ON task_ref.id = run.task_ref AND task_ref.backend = 'built-in'
@@ -315,8 +313,8 @@ export function statusFor(store, who, now) {
         .all(...args)
         .map(row => ({ repo: String(row["repo"]), queued: Number(row["queued"]), running: Number(row["running"]) }));
     return {
-        waitsOnYou: unsealed + questions + incidents + picks,
-        waits: { approvals: unsealed, questions, incidents, picks },
+        waitsOnYou: unsealed + questions + incidents,
+        waits: { approvals: unsealed, questions, incidents },
         running,
         builtToday,
         failedToday,
@@ -432,7 +430,7 @@ export function taskDetailFor(store, who, taskId, evidenceRoot, now = new Date()
         scope: {
             sealed: store.scopeSealed(taskId),
             goal: scope?.goal ?? null,
-            // The scope in the console's own words — fallback chain included.
+            // The scope in the console's own words.
             words: scope === null ? [] : describeScope(scope),
         },
         waits,