toolroll 0.9.93 → 0.9.95

package/dist/contracts/chat-card.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A Toolroll card as it is kept and shown (docs/plans/toolroll-cards.md): what a card's spec became once Toolroll filled
+ * it from its own records. Every value here was written by Toolroll; the one exception is a `text` block, which a person
+ * reads as a plain paragraph labelled as the lead's note, never as data. A saved card is read back through this
+ * schema before any renderer sees it.
+ */
+import { z } from "zod";
+export declare const CARD_LIMITS: {
+    readonly blocks: 8;
+    readonly columns: 6;
+    readonly rows: 20;
+    readonly points: 12;
+    readonly facts: 10;
+    readonly buttons: 4;
+    readonly actions: 4;
+    readonly cell: 80;
+    readonly label: 40;
+    readonly heading: 80;
+    readonly text: 600;
+    readonly note: 400;
+    readonly notes: 12;
+};
+export declare const CARD_CHART_TYPES: readonly ["bar", "pie", "line", "area"];
+export type CardChartType = (typeof CARD_CHART_TYPES)[number];
+export declare const chatCardSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    asOf: z.ZodString;
+    repos: z.ZodArray<z.ZodString>;
+    blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"divider">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"facts">;
+        heading: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"table">;
+        heading: z.ZodString;
+        origin: z.ZodEnum<{
+            records: "records";
+            report: "report";
+        }>;
+        columns: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            numeric: z.ZodBoolean;
+        }, z.core.$strict>>;
+        rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+        more: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"notes">;
+        heading: z.ZodString;
+        origin: z.ZodEnum<{
+            records: "records";
+            report: "report";
+        }>;
+        items: z.ZodArray<z.ZodString>;
+        more: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"chart">;
+        heading: z.ZodString;
+        chart: z.ZodEnum<{
+            area: "area";
+            bar: "bar";
+            line: "line";
+            pie: "pie";
+        }>;
+        points: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            shown: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+    buttons: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    actions: z.ZodArray<z.ZodObject<{
+        proposal: z.ZodInt;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ChatCard = z.infer<typeof chatCardSchema>;
+export type ChatCardBlock = ChatCard["blocks"][number];
+/** A saved card, or null: it was changed, or a build that wrote it knew another shape. */
+export declare function readChatCard(value: unknown): ChatCard | null;

package/dist/contracts/chat-card.js

@@ -0,0 +1,54 @@
+/**
+ * A Toolroll card as it is kept and shown (docs/plans/toolroll-cards.md): what a card's spec became once Toolroll filled
+ * it from its own records. Every value here was written by Toolroll; the one exception is a `text` block, which a person
+ * reads as a plain paragraph labelled as the lead's note, never as data. A saved card is read back through this
+ * schema before any renderer sees it.
+ */
+import { z } from "zod";
+export const CARD_LIMITS = { blocks: 8, columns: 6, rows: 20, points: 12, facts: 10, buttons: 4, actions: 4, cell: 80, label: 40, heading: 80, text: 600, note: 400, notes: 12 };
+const label = z.string().min(1).max(CARD_LIMITS.label);
+const heading = z.string().min(1).max(CARD_LIMITS.heading);
+const cell = z.string().max(CARD_LIMITS.cell);
+export const CARD_CHART_TYPES = ["bar", "pie", "line", "area"];
+const textBlock = z.strictObject({ kind: z.literal("text"), text: z.string().min(1).max(CARD_LIMITS.text) });
+const dividerBlock = z.strictObject({ kind: z.literal("divider") });
+const factsBlock = z.strictObject({ kind: z.literal("facts"), heading, items: z.array(z.strictObject({ label, value: cell })).min(1).max(CARD_LIMITS.facts) });
+const tableBlock = z.strictObject({
+    kind: z.literal("table"), heading,
+    /** `report`: an agent's own report, shown as such; never a figure of Toolroll's. */
+    origin: z.enum(["records", "report"]),
+    columns: z.array(z.strictObject({ label, numeric: z.boolean() })).min(1).max(CARD_LIMITS.columns),
+    rows: z.array(z.array(cell).max(CARD_LIMITS.columns)).max(CARD_LIMITS.rows),
+    /** Rows the records hold beyond the ones shown. */
+    more: z.int().min(0),
+});
+/** Lines of saved words, whole: findings and a handover note. `report` as a table's: not Toolroll's figures. */
+const notesBlock = z.strictObject({ kind: z.literal("notes"), heading, origin: z.enum(["records", "report"]), items: z.array(z.string().min(1).max(CARD_LIMITS.note)).min(1).max(CARD_LIMITS.notes), more: z.int().min(0) });
+const chartBlock = z.strictObject({
+    kind: z.literal("chart"), heading, chart: z.enum(CARD_CHART_TYPES),
+    points: z.array(z.strictObject({ label, value: z.number().finite().min(0), shown: cell })).min(1).max(CARD_LIMITS.points),
+});
+export const chatCardSchema = z.strictObject({
+    version: z.literal(1),
+    title: heading,
+    /** When Toolroll read the records. */
+    asOf: z.string().regex(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z$/),
+    /** The projects the values came from: a card goes only where all of them are reachable. */
+    repos: z.array(z.string()).max(200),
+    blocks: z.array(z.discriminatedUnion("kind", [textBlock, dividerBlock, factsBlock, tableBlock, notesBlock, chartBlock])).min(1).max(CARD_LIMITS.blocks),
+    /** Fixed destinations in Toolroll: a path made by chat-controls.ts, never a model's address. */
+    buttons: z.array(z.strictObject({ label, path: z.string().max(400).regex(/^\/(?![/\\])/) })).max(CARD_LIMITS.buttons),
+    /** Proposals this card leads to: each keeps its own Confirm message directly under the card. */
+    actions: z.array(z.strictObject({ proposal: z.int().min(1), label: z.string().min(1).max(CARD_LIMITS.heading) })).max(CARD_LIMITS.actions),
+});
+/** A saved card, or null: it was changed, or a build that wrote it knew another shape. */
+export function readChatCard(value) {
+    const read = chatCardSchema.safeParse(value);
+    if (!read.success)
+        return null;
+    const card = read.data;
+    for (const block of card.blocks)
+        if (block.kind === "table" && block.rows.some(row => row.length !== block.columns.length))
+            return null;
+    return card;
+}

package/dist/contracts/chat-content.d.ts

@@ -114,6 +114,71 @@ export declare const chatContentShape: {
             }, z.core.$strict>;
         }, z.core.$strict>]>>>;
     }, z.core.$strict>>;
+    /** A Toolroll card (docs/plans/toolroll-cards.md): `text` stays its plain version, and `link`/`also` its buttons, so
+     * an app that can't show it, or refuses it, still has the whole message. */
+    rich: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        title: z.ZodString;
+        asOf: z.ZodString;
+        repos: z.ZodArray<z.ZodString>;
+        blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"divider">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"facts">;
+            heading: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"table">;
+            heading: z.ZodString;
+            origin: z.ZodEnum<{
+                records: "records";
+                report: "report";
+            }>;
+            columns: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                numeric: z.ZodBoolean;
+            }, z.core.$strict>>;
+            rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+            more: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"notes">;
+            heading: z.ZodString;
+            origin: z.ZodEnum<{
+                records: "records";
+                report: "report";
+            }>;
+            items: z.ZodArray<z.ZodString>;
+            more: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"chart">;
+            heading: z.ZodString;
+            chart: z.ZodEnum<{
+                area: "area";
+                bar: "bar";
+                line: "line";
+                pie: "pie";
+            }>;
+            points: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                shown: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">>;
+        buttons: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+        actions: z.ZodArray<z.ZodObject<{
+            proposal: z.ZodInt;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     /** The "What should change?" this part asks (chat-decide.ts): a reply to its message is the feedback. */
     prompt: z.ZodOptional<z.ZodInt>;
 };
@@ -199,6 +264,69 @@ export declare const chatContentSchema: z.ZodObject<{
             }, z.core.$strict>;
         }, z.core.$strict>]>>>;
     }, z.core.$strict>>;
+    rich: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        title: z.ZodString;
+        asOf: z.ZodString;
+        repos: z.ZodArray<z.ZodString>;
+        blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"divider">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"facts">;
+            heading: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"table">;
+            heading: z.ZodString;
+            origin: z.ZodEnum<{
+                records: "records";
+                report: "report";
+            }>;
+            columns: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                numeric: z.ZodBoolean;
+            }, z.core.$strict>>;
+            rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+            more: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"notes">;
+            heading: z.ZodString;
+            origin: z.ZodEnum<{
+                records: "records";
+                report: "report";
+            }>;
+            items: z.ZodArray<z.ZodString>;
+            more: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"chart">;
+            heading: z.ZodString;
+            chart: z.ZodEnum<{
+                area: "area";
+                bar: "bar";
+                line: "line";
+                pie: "pie";
+            }>;
+            points: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                shown: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">>;
+        buttons: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+        actions: z.ZodArray<z.ZodObject<{
+            proposal: z.ZodInt;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     prompt: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 export type ChatContent = z.infer<typeof chatContentSchema>;
@@ -286,6 +414,69 @@ export declare const savedChatPartSchema: z.ZodObject<{
             }, z.core.$strict>;
         }, z.core.$strict>]>>>;
     }, z.core.$strict>>;
+    rich: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        title: z.ZodString;
+        asOf: z.ZodString;
+        repos: z.ZodArray<z.ZodString>;
+        blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"divider">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"facts">;
+            heading: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"table">;
+            heading: z.ZodString;
+            origin: z.ZodEnum<{
+                records: "records";
+                report: "report";
+            }>;
+            columns: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                numeric: z.ZodBoolean;
+            }, z.core.$strict>>;
+            rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+            more: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"notes">;
+            heading: z.ZodString;
+            origin: z.ZodEnum<{
+                records: "records";
+                report: "report";
+            }>;
+            items: z.ZodArray<z.ZodString>;
+            more: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"chart">;
+            heading: z.ZodString;
+            chart: z.ZodEnum<{
+                area: "area";
+                bar: "bar";
+                line: "line";
+                pie: "pie";
+            }>;
+            points: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                shown: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">>;
+        buttons: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+        actions: z.ZodArray<z.ZodObject<{
+            proposal: z.ZodInt;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     prompt: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 /** A saved part's content (`version` is the saved form's, not the content's). */

package/dist/contracts/chat-content.js

@@ -9,6 +9,7 @@
  */
 import { z } from "zod";
 import { parseContract, readVersioned, versioned } from "./contract.js";
+import { chatCardSchema } from "./chat-card.js";
 const id = z.int().min(1);
 const link = z.strictObject({ label: z.string(), path: z.string() });
 /** A Toolroll button's one-time token, as every chat app carries it: 32 hex, or `d:` and 24 hex for a decide button
@@ -58,6 +59,9 @@ export const chatContentShape = {
     /** A result's, plan's, failure's or pull request's own buttons (chat-decide.ts), minted with the part: each an act's
      * one-time token or a link. They ride the message once it is sent. */
     decide: z.strictObject({ rows: z.array(z.array(z.union([z.strictObject({ label: z.string(), token: z.string().regex(CHAT_BUTTON_TOKEN) }), z.strictObject({ label: z.string(), link })]))) }).optional(),
+    /** A Toolroll card (docs/plans/toolroll-cards.md): `text` stays its plain version, and `link`/`also` its buttons, so
+     * an app that can't show it, or refuses it, still has the whole message. */
+    rich: chatCardSchema.optional(),
     /** The "What should change?" this part asks (chat-decide.ts): a reply to its message is the feedback. */
     prompt: id.optional(),
 };

package/dist/contracts/cli.d.ts

@@ -566,6 +566,58 @@ export declare const COMMAND_OUTPUTS: {
         reason: z.ZodString;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>], "ok">;
+    readonly "task ready": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task ready">;
+        taskId: z.ZodString;
+        activeTaskId: z.ZodString;
+        run: z.ZodNullable<z.ZodNumber>;
+        head: z.ZodNullable<z.ZodString>;
+        answer: z.ZodEnum<{
+            merged: "merged";
+            no: "no";
+            "not-yet": "not-yet";
+            yes: "yes";
+        }>;
+        sentence: z.ZodString;
+        rows: z.ZodArray<z.ZodObject<{
+            key: z.ZodEnum<{
+                build: "build";
+                checks: "checks";
+                comments: "comments";
+                conflicts: "conflicts";
+                plan: "plan";
+                "pr-ci": "pr-ci";
+                "pull-request": "pull-request";
+                release: "release";
+                requirements: "requirements";
+                "up-to-date": "up-to-date";
+            }>;
+            label: z.ZodString;
+            mark: z.ZodEnum<{
+                no: "no";
+                skip: "skip";
+                unknown: "unknown";
+                waiting: "waiting";
+                yes: "yes";
+            }>;
+            say: z.ZodString;
+            act: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    fix: "fix";
+                    retry: "retry";
+                    "run-checks": "run-checks";
+                }>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task ready">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
     readonly "task hold": z.ZodDiscriminatedUnion<[z.ZodObject<{
         envelopeVersion: z.ZodLiteral<1>;
         ok: z.ZodLiteral<true>;

package/dist/contracts/cli.js

@@ -183,6 +183,10 @@ export const COMMAND_OUTPUTS = {
     // `status` is the observation's own answer (the one merges read); the rows are each check's timing.
     "task ship": answers("task ship", { task: str, pullRequest: int, githubRepo: str, head: str, observedAt: str, status: z.enum(["passing", "failing", "running", "none"]),
         checks: rows({ name: str, workflow: nullable(str), state: z.enum(["queued", "running", "passed", "failed", "skipped", "cancelled", "neutral"]), startedAt: nullable(str), completedAt: nullable(str), url: nullable(str), kind: z.enum(["run", "status"]), seconds: nullable(int) }) }),
+    // "Can I merge?" (merge-checklist.ts): the answer, its sentence, and one row per fact, each blocker with its act.
+    "task ready": answers("task ready", { taskId: str, activeTaskId: str, run: nullable(int), head: nullable(str), answer: z.enum(["yes", "no", "not-yet", "merged"]), sentence: str,
+        rows: rows({ key: z.enum(["plan", "build", "checks", "requirements", "pull-request", "pr-ci", "up-to-date", "conflicts", "comments", "release"]), label: str,
+            mark: z.enum(["yes", "no", "waiting", "unknown", "skip"]), say: str, act: nullable(z.looseObject({ kind: z.enum(["run-checks", "retry", "fix"]) })) }) }),
     "task hold": answers("task hold", { id: str, reason: str, until: nullable(str) }),
     "task unhold": answers("task unhold", { id: str }),
     "task wait": answers("task wait", { task: str, outcome: str }),

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

@@ -87,6 +87,7 @@ export declare const CONSOLE_FORMS: {
     readonly projectConcurrency: FormContract<"concurrency" | "repo">;
     readonly projectLiveView: FormContract<"act" | "nonce" | "password" | "repo">;
     readonly projectNetwork: FormContract<"hosts" | "local" | "mode" | "password" | "repo">;
+    readonly projectFallback: FormContract<"agents" | "paid" | "password" | "repo">;
     readonly projectWrites: FormContract<"password" | "repo" | "writes">;
     readonly projectCheckAccess: FormContract<"confirm-open" | "level" | "password" | "repo">;
     readonly projectSandbox: FormContract<"mach" | "password" | "read-deny" | "repo">;
@@ -98,7 +99,7 @@ export declare const CONSOLE_FORMS: {
     readonly signIn: FormContract<"action" | "client-id" | "client-secret" | "groups-claim" | "issuer" | "label" | "password" | "passwords" | "scopes" | `group-${string}` | `projects-${string}` | `role-${string}`>;
     readonly updates: FormContract<"password" | "version" | "when">;
     readonly retention: FormContract<"chat" | "checkouts" | "evidence" | "notifications" | "password">;
-    readonly storage: FormContract<"cleanup" | "password" | "path" | "preview">;
+    readonly storage: FormContract<"cleanup" | "idle" | "password" | "path" | "preview">;
     readonly pullRequests: FormContract<"act" | "base" | "github" | "method" | "password" | "repo" | "when-green">;
     readonly checks: FormContract<"act" | "command" | "level" | "on" | "password" | "repo" | "timeout">;
     readonly backups: FormContract<"every" | "folder" | "keep" | "live_every" | "live_folder" | "password">;
@@ -115,6 +116,8 @@ export declare const CONSOLE_FORMS: {
     readonly modelsRules: FormContract<"id" | "password" | "rule" | "scope">;
     readonly knowledgeRefresh: FormContract<"repo">;
     readonly knowledgeProposal: FormContract<"decision" | "proposal" | "repo">;
+    readonly knowledgeNote: FormContract<"claim" | "decision" | "proposal" | "repo">;
+    readonly knowledgeTidy: FormContract<"action" | "choice" | "claim" | "proposal" | "repo" | "revision" | "target" | "why">;
     readonly knowledgeDecision: FormContract<"action" | "claim" | "decision" | "reason" | "repo" | "why">;
     readonly knowledgeChange: FormContract<"action" | "content" | "id" | "identity" | "instructions" | "path" | "repo" | "restore" | "revision" | "title">;
     readonly learningChange: FormContract<"action" | "identity" | "lesson" | "repo" | "revision" | "sha" | "version">;
@@ -140,7 +143,13 @@ export declare const CONSOLE_FORMS: {
     readonly projectsSelect: FormContract<"path" | "return">;
     readonly projectsRemove: FormContract<"repo">;
     readonly projectsOpen: FormContract<"path" | "return">;
-    readonly tasksAdd: FormContract<"acceptance" | "after" | "goal" | "id" | "not" | "permission-mode" | "plan-first" | "planning-policy" | "projectRevision" | "quality-mode" | "repo" | "scout" | "title" | "touches">;
+    readonly codeMap: FormContract<"on" | "repo">;
+    readonly codeMapRefresh: FormContract<never>;
+    readonly tasksFast: FormContract<"digest" | "preview">;
+    readonly keepGrown: FormContract<never>;
+    readonly followThrough: FormContract<"act" | "capture" | "file" | "finding" | "label" | "line" | "note" | "pointer" | "run">;
+    readonly releaseGoOn: FormContract<"password">;
+    readonly tasksAdd: FormContract<"acceptance" | "after" | "from" | "from-head" | "from-read" | "goal" | "id" | "not" | "permission-mode" | "plain" | "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<"auto-approve" | "chat-approve" | "days" | "digest" | "expiry" | "name" | "nonce" | "plan-auto" | "publication" | "repair-auto" | "review-auto" | "review-retry-auto" | "token">;
@@ -198,7 +207,7 @@ export declare const CONSOLE_FORMS: {
     readonly taskRevision: FormContract<"revision-id" | "token">;
     readonly taskCancel: FormContract<"reason">;
     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 taskScope: FormContract<"acceptance" | "budget-microusd" | "budget-usd" | "goal" | "goal-brief" | "not" | "permission-mode" | "quality-mode" | "requirement" | "requirement-how" | "requirement-new" | "requirement-new-how" | "sawDigest" | "touches">;
     readonly taskApprove: FormContract<"digest" | "nonce" | "rebuild" | "return" | "sheet" | "token">;
     readonly taskAcceptProof: FormContract<"note" | "return" | "run">;
     readonly taskComplete: FormContract<"accept" | "note" | "publish" | "receipt" | "return" | "run">;

package/dist/contracts/console-api.js

@@ -96,6 +96,7 @@ export const CONSOLE_FORMS = {
     projectConcurrency: formContract("POST /settings/project/concurrency", ["repo", "concurrency"]),
     projectLiveView: formContract("POST /settings/project/live-view", ["repo", "act", "password", "nonce"]),
     projectNetwork: formContract("POST /settings/project/network", ["repo", "mode", "local", "hosts", "password"]),
+    projectFallback: formContract("POST /settings/project/fallback", ["repo", "agents", "paid", "password"]),
     projectWrites: formContract("POST /settings/project/writes", ["repo", "writes", "password"]),
     projectCheckAccess: formContract("POST /settings/project/check-access", ["repo", "level", "confirm-open", "password"]),
     projectSandbox: formContract("POST /settings/project/sandbox", ["repo", "read-deny", "mach", "password"]),
@@ -107,7 +108,7 @@ export const CONSOLE_FORMS = {
     signIn: formContract("POST /settings/sign-in", ["action", "password", "issuer", "client-id", "client-secret", "label", "scopes", "groups-claim", "passwords"], { prefixes: ["group-", "role-", "projects-"] }),
     updates: formContract("POST /settings/updates, /settings/updates/seen, /settings/updates/cancel", ["password", "version", "when"]),
     retention: formContract("POST /settings/retention", ["password", "evidence", "checkouts", "chat", "notifications"]),
-    storage: formContract("POST /settings/storage, /settings/storage/clean, /settings/storage/discard", ["password", "cleanup", "preview", "path"]),
+    storage: formContract("POST /settings/storage, /settings/storage/clean, /settings/storage/discard", ["password", "cleanup", "idle", "preview", "path"]),
     pullRequests: formContract("POST /settings/pull-requests", ["repo", "act", "password", "github", "base", "method", "when-green"]),
     checks: formContract("POST /settings/checks", ["repo", "password", "act", "on", "level", "command", "timeout"]),
     backups: formContract("POST /settings/backups", ["password", "every", "keep", "folder", "live_every", "live_folder"]),
@@ -129,6 +130,8 @@ export const CONSOLE_FORMS = {
     modelsRules: formContract("POST /settings/models/accept, /settings/models/keep, /settings/models/suggest-on, /settings/models/turn-off, /settings/models/not-now, /settings/models/suggest-off, /settings/models/try, /settings/models/stop", ["password", "scope", "id", "rule"]),
     knowledgeRefresh: formContract("POST /settings/knowledge/refresh", ["repo"]),
     knowledgeProposal: formContract("POST /settings/knowledge/proposal", ["repo", "decision", "proposal"]),
+    knowledgeNote: formContract("POST /settings/knowledge/note", ["repo", "decision", "proposal", "claim"]),
+    knowledgeTidy: formContract("POST /settings/knowledge/tidy", ["repo", "action", "proposal", "choice", "claim", "why", "target", "revision"]),
     knowledgeDecision: formContract("POST /settings/knowledge/decision", ["repo", "action", "claim", "why", "decision", "reason"]),
     knowledgeChange: formContract("POST /settings/knowledge/change", ["repo", "action", "identity", "revision", "instructions", "title", "content", "path", "id", "restore"]),
     learningChange: formContract("POST /settings/learning/change", ["repo", "action", "identity", "revision", "lesson", "version", "sha"]),
@@ -155,7 +158,13 @@ export const CONSOLE_FORMS = {
     projectsSelect: formContract("POST /projects/select", ["path", "return"]),
     projectsRemove: formContract("POST /projects/remove", ["repo"]),
     projectsOpen: formContract("POST /projects/open", ["path", "return"]),
-    tasksAdd: formContract("POST /tasks/add", ["projectRevision", "id", "title", "repo", "goal", "not", "touches", "scout", "permission-mode", "quality-mode", "after", "acceptance", "planning-policy", "plan-first"]),
+    codeMap: formContract("POST /settings/project/code-map, /settings/project/code-map/holdout", ["repo", "on"]),
+    codeMapRefresh: formContract("POST /projects/<project>/map/refresh", []),
+    tasksFast: formContract("POST /tasks/fast", ["preview", "digest"]),
+    keepGrown: formContract("POST /t/<id>/keep-grown", []),
+    followThrough: formContract("POST /t/<id>/follow-through", ["act", "note", "file", "line", "finding", "run", "pointer", "capture", "label"]),
+    releaseGoOn: formContract("POST /t/<id>/release/go-on", ["password"]),
+    tasksAdd: formContract("POST /tasks/add", ["projectRevision", "plain", "from", "from-head", "from-read", "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", "chat-approve", "publication", "expiry", "nonce", "digest", "token", "review-auto", "review-retry-auto", "repair-auto"]),
@@ -216,7 +225,7 @@ export const CONSOLE_FORMS = {
     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", ["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"]),
+    taskScope: formContract("POST /t/<task>/scope", ["sawDigest", "permission-mode", "quality-mode", "budget-usd", "budget-microusd", "requirement", "requirement-new", "requirement-how", "requirement-new-how", "goal-brief", "goal", "not", "touches", "acceptance"]),
     taskApprove: formContract("POST /t/<task>/approve", ["return", "digest", "token", "nonce", "rebuild", "sheet"]),
     taskAcceptProof: formContract("POST /t/<task>/accept-proof", ["run", "note", "return"]),
     taskComplete: formContract("POST /t/<task>/complete", ["receipt", "run", "accept", "note", "publish", "return"]),

package/dist/contracts/flow-propose.d.ts

@@ -4,13 +4,15 @@
  * (mate-tools.ts). The lead-tools contract (item 5) imports it from here rather than restating it.
  */
 import { z } from "zod";
-export declare const PROPOSE_FLOW_OPERATIONS: readonly ["create", "edit", "add_card", "move_card", "approve", "send_back", "choose", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter", "allow_browser", "turn_off_browser"];
+export declare const PROPOSE_FLOW_OPERATIONS: readonly ["archive", "turn_off_unattended", "allow_unattended", "create", "edit", "add_card", "move_card", "approve", "send_back", "choose", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter", "allow_browser", "turn_off_browser"];
 export declare const proposeFlowInputSchema: z.ZodObject<{
     operation: z.ZodEnum<{
         add_card: "add_card";
         add_trigger: "add_trigger";
         allow_browser: "allow_browser";
+        allow_unattended: "allow_unattended";
         approve: "approve";
+        archive: "archive";
         assign: "assign";
         cancel_card: "cancel_card";
         choose: "choose";
@@ -27,11 +29,16 @@ export declare const proposeFlowInputSchema: z.ZodObject<{
         send_back: "send_back";
         starter: "starter";
         turn_off_browser: "turn_off_browser";
+        turn_off_unattended: "turn_off_unattended";
         unfollow: "unfollow";
     }>;
     repo: z.ZodOptional<z.ZodString>;
     flow: z.ZodOptional<z.ZodInt>;
     card: z.ZodOptional<z.ZodInt>;
+    days: z.ZodOptional<z.ZodInt>;
+    budget: z.ZodOptional<z.ZodString>;
+    runs: z.ZodOptional<z.ZodString>;
+    include: z.ZodOptional<z.ZodArray<z.ZodInt>>;
     kit: z.ZodOptional<z.ZodEnum<{
         [x: string]: string;
     }>>;

package/dist/contracts/flow-propose.js

@@ -11,7 +11,7 @@ import { KITS } from "../kits.js";
 import { TEXT_LIMITS } from "../text-limits.js";
 import { toModelSchema } from "./contract.js";
 import { flowStepsSchema, leadTriggerSchema, SCRIPT_LANGUAGES, SCRIPT_NAME } from "./flow.js";
-export const PROPOSE_FLOW_OPERATIONS = ["create", "edit", "add_card", "move_card", "approve", "send_back", "choose", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter", "allow_browser", "turn_off_browser"];
+export const PROPOSE_FLOW_OPERATIONS = ["archive", "turn_off_unattended", "allow_unattended", "create", "edit", "add_card", "move_card", "approve", "send_back", "choose", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter", "allow_browser", "turn_off_browser"];
 const id = z.int().min(1);
 const enumOf = (values) => z.enum(values);
 export const proposeFlowInputSchema = z.strictObject({
@@ -19,6 +19,8 @@ export const proposeFlowInputSchema = z.strictObject({
     /** A project as list_repos names it (r1, r2). */
     repo: z.string().regex(/^r[0-9]{1,3}$/, { error: "must be a project from list_repos, like r1" }).optional(),
     flow: id.optional(), card: id.optional(),
+    /** allow_unattended: how long it runs on its own, what it may spend, and the schedules chosen beyond the plain ones. */
+    days: z.int().min(1).optional(), budget: z.string().max(20).optional(), runs: z.string().max(20).optional(), include: z.array(id).max(50).optional(),
     kit: enumOf(KITS.map(one => one.id)).optional(),
     starter: z.enum(STARTER_IDS).optional(),
     name: z.string().max(TEXT_LIMITS.flowName).optional(),