toolroll 0.9.84 → 0.9.86

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

@@ -168,6 +168,8 @@ declare const STORE_COLUMN_VALUES: {
         operation: z.ZodEnum<{
             decision_record: "decision_record";
             decision_retire: "decision_retire";
+            flow_browser: "flow_browser";
+            flow_browser_off: "flow_browser_off";
             flow_card_add: "flow_card_add";
             flow_card_approve: "flow_card_approve";
             flow_card_assign: "flow_card_assign";

package/dist/contracts/trigger-payloads.d.ts

@@ -45,6 +45,11 @@ export declare const githubRunSchema: z.ZodCatch<z.ZodObject<{
     display_title: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     created_at: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     html_url: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    id: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    event: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    head_repository: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        full_name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>>;
 /** `repos/:repo/issues` and `repos/:repo/pulls`: a list (anything else reads as an empty one). */
 export declare const githubIssueListSchema: z.ZodCatch<z.ZodArray<z.ZodCatch<z.ZodObject<{
@@ -111,6 +116,11 @@ export declare const githubRunListSchema: z.ZodCatch<z.ZodObject<{
         display_title: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         created_at: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         html_url: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        id: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        event: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        head_repository: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            full_name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>>>;
 }, z.core.$strip>>;
 /** A signed GitHub webhook event (`issues`, `pull_request`, `workflow_run`; a `ping` reads as an empty one). */
@@ -176,6 +186,11 @@ export declare const githubEventSchema: z.ZodCatch<z.ZodObject<{
         display_title: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         created_at: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         html_url: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        id: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        event: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        head_repository: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            full_name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>>;
 /** A Linear issue, from the GraphQL query (`labels { nodes }`) or a webhook's `data` (`labels` as a list). */
@@ -353,6 +368,11 @@ export declare const readGithubRunList: (raw: unknown) => {
         display_title?: string | undefined;
         created_at?: string | undefined;
         html_url?: string | undefined;
+        id?: number | undefined;
+        event?: string | undefined;
+        head_repository?: {
+            full_name?: string | undefined;
+        } | undefined;
     }[] | undefined;
 };
 export declare const readGithubEvent: (raw: unknown) => GithubEvent;

package/dist/contracts/trigger-payloads.js

@@ -42,6 +42,10 @@ export const githubRunSchema = z.object({
     display_title: text,
     created_at: text,
     html_url: text,
+    /** Read by tidy's CI observations (task-tidy.md): which run, why it ran, and whose repository its commit is in. */
+    id: loose(z.number()),
+    event: text,
+    head_repository: loose(z.object({ full_name: text })),
 }).catch({});
 /** `repos/:repo/issues` and `repos/:repo/pulls`: a list (anything else reads as an empty one). */
 export const githubIssueListSchema = z.array(githubIssueSchema).catch([]);

package/dist/contracts/youiyoux-request.d.ts

@@ -0,0 +1,248 @@
+/**
+ * A youiyoux request as Toolroll reads it (youiyoux-intake.ts): the published `youi.request/v1` schema (youiyoux's
+ * schema/youi.request.schema.json), held to its own limits, and the `youi.proposal/v1` options file an options request's
+ * agent writes (schema/youi.proposal.schema.json). Unknown keys are allowed, as the published schemas allow them;
+ * everything Toolroll reads is checked here, and every string is outside text all the same.
+ */
+import { z } from "zod";
+import { type ContractResult } from "./contract.js";
+export declare const REQUEST_ID: RegExp;
+/** An options file's id: `p-` and the same 10 hex as the options request it answers. */
+export declare const PROPOSAL_ID: RegExp;
+/** The provenance every task filed from a request carries (task_ref.filed_via): immutable, and the seal reads it. */
+export declare const YOUIYOUX_FILED_VIA = "youiyoux";
+/** The one chat card a pass's filings make for a project (youiyoux-intake.ts), drawn by chat-decide.ts: the new tasks,
+ * Approve all and each one's own Approve and Open. */
+export declare const YOUIYOUX_CARD_KIND = "youiyoux-requests";
+/** Where a person sees and approves everything waiting on them in the console (flow-triggers.ts NEEDS_YOU_HREF). */
+export declare const YOUIYOUX_HOME_PATH = "/work?view=needs-you";
+export declare const YOUIYOUX_EVIDENCE: readonly ["screenshot", "check", "changed-path", "manual-review"];
+/** What an options request offers its agent: the one file to write (`.youi/proposals/<proposal>.json`), the props an
+ * option may set (enum values from `values`), and whether it may give the component new text. */
+export declare const youiyouxOfferSchema: z.ZodObject<{
+    proposal: z.ZodString;
+    file: z.ZodString;
+    choices: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            enum: "enum";
+            number: "number";
+            string: "string";
+        }>;
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>;
+    text: z.ZodBoolean;
+}, z.core.$strip>;
+export type YouiyouxOffer = z.infer<typeof youiyouxOfferSchema>;
+export declare const youiyouxTaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    goal: z.ZodString;
+    touches: z.ZodArray<z.ZodString>;
+    touchesKnown: z.ZodBoolean;
+    why: z.ZodOptional<z.ZodString>;
+    not: z.ZodArray<z.ZodString>;
+    acceptance: z.ZodArray<z.ZodObject<{
+        statement: z.ZodString;
+        evidence: z.ZodArray<z.ZodEnum<{
+            "changed-path": "changed-path";
+            check: "check";
+            "manual-review": "manual-review";
+            screenshot: "screenshot";
+        }>>;
+    }, z.core.$strip>>;
+    offer: z.ZodOptional<z.ZodObject<{
+        proposal: z.ZodString;
+        file: z.ZodString;
+        choices: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                boolean: "boolean";
+                enum: "enum";
+                number: "number";
+                string: "string";
+            }>;
+            values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>;
+        text: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const youiyouxRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"youi.request/v1">;
+    id: z.ZodString;
+    project: z.ZodString;
+    kind: z.ZodEnum<{
+        change: "change";
+        comment: "comment";
+        options: "options";
+    }>;
+    status: z.ZodEnum<{
+        addressed: "addressed";
+        closed: "closed";
+        open: "open";
+    }>;
+    body: z.ZodString;
+    author: z.ZodObject<{
+        kind: z.ZodEnum<{
+            agent: "agent";
+            person: "person";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    target: z.ZodObject<{
+        route: z.ZodString;
+        scope: z.ZodEnum<{
+            element: "element";
+            here: "here";
+        }>;
+        name: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>;
+    task: z.ZodOptional<z.ZodObject<{
+        title: z.ZodString;
+        goal: z.ZodString;
+        touches: z.ZodArray<z.ZodString>;
+        touchesKnown: z.ZodBoolean;
+        why: z.ZodOptional<z.ZodString>;
+        not: z.ZodArray<z.ZodString>;
+        acceptance: z.ZodArray<z.ZodObject<{
+            statement: z.ZodString;
+            evidence: z.ZodArray<z.ZodEnum<{
+                "changed-path": "changed-path";
+                check: "check";
+                "manual-review": "manual-review";
+                screenshot: "screenshot";
+            }>>;
+        }, z.core.$strip>>;
+        offer: z.ZodOptional<z.ZodObject<{
+            proposal: z.ZodString;
+            file: z.ZodString;
+            choices: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    boolean: "boolean";
+                    enum: "enum";
+                    number: "number";
+                    string: "string";
+                }>;
+                values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>;
+            text: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    thread: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+export type YouiyouxRequest = z.infer<typeof youiyouxRequestSchema>;
+export type YouiyouxTask = z.infer<typeof youiyouxTaskSchema>;
+export declare function readYouiyouxRequest(raw: unknown): ContractResult<YouiyouxRequest>;
+/** The one file an options request's agent may write: `.youi/proposals/p-<the request's hex>.json`. */
+export declare const proposalIdOf: (request: string) => string;
+export declare const proposalFileOf: (proposal: string) => string;
+/** Why an options request can't be filed as youiyoux's contract has it, or null: it carries a task with an offer whose
+ * proposal is `p-<its own hex>`, whose file is that proposal's, and the task may touch that one file and nothing else. */
+export declare function optionsProblem(request: YouiyouxRequest): string | null;
+export declare const PROPOSAL_STATUSES: readonly ["open", "chosen", "dismissed"];
+export declare const youiyouxProposalSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schema: z.ZodLiteral<"youi.proposal/v1">;
+    id: z.ZodString;
+    project: z.ZodString;
+    route: z.ZodString;
+    target: z.ZodObject<{
+        name: z.ZodString;
+        element: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodInt>;
+        column: z.ZodOptional<z.ZodInt>;
+        box: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>;
+        page: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    ask: z.ZodString;
+    author: z.ZodObject<{
+        kind: z.ZodEnum<{
+            agent: "agent";
+            person: "person";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            a: "a";
+            b: "b";
+            c: "c";
+            d: "d";
+        }>;
+        label: z.ZodString;
+        why: z.ZodString;
+        set: z.ZodArray<z.ZodObject<{
+            prop: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strip>>;
+        text: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        chosen: "chosen";
+        dismissed: "dismissed";
+        open: "open";
+    }>;
+    choice: z.ZodOptional<z.ZodEnum<{
+        a: "a";
+        b: "b";
+        c: "c";
+        d: "d";
+    }>>;
+    decidedBy: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            agent: "agent";
+            person: "person";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    decidedAt: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodString>;
+    for: z.ZodString;
+}, z.core.$strip>;
+export type YouiyouxProposal = z.infer<typeof youiyouxProposalSchema>;
+export declare function readYouiyouxProposal(raw: unknown): ContractResult<YouiyouxProposal>;
+/** What Toolroll writes beside a request (`youi.request-task/v1`): the task it became, how that task stands, and, when
+ * the console has an address, the task's link and `home`, where a person sees and approves all waiting work. */
+export declare const YOUIYOUX_TASK_STATUSES: readonly ["queued", "needs-you", "building", "ready", "done", "failed", "stopped"];
+export type YouiyouxTaskStatus = (typeof YOUIYOUX_TASK_STATUSES)[number];
+/** A link youiyoux opens: http or https, at most 2,000 characters, with no user name or password in it. */
+export declare const youiyouxLinkSchema: z.ZodString;
+export declare const youiyouxRequestTaskSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"youi.request-task/v1">;
+    request: z.ZodString;
+    runner: z.ZodLiteral<"Toolroll">;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    home: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        building: "building";
+        done: "done";
+        failed: "failed";
+        "needs-you": "needs-you";
+        queued: "queued";
+        ready: "ready";
+        stopped: "stopped";
+    }>;
+    detail: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type YouiyouxRequestTask = z.infer<typeof youiyouxRequestTaskSchema>;
+export declare function readYouiyouxRequestTask(raw: unknown): ContractResult<YouiyouxRequestTask>;

package/dist/contracts/youiyoux-request.js

@@ -0,0 +1,152 @@
+/**
+ * A youiyoux request as Toolroll reads it (youiyoux-intake.ts): the published `youi.request/v1` schema (youiyoux's
+ * schema/youi.request.schema.json), held to its own limits, and the `youi.proposal/v1` options file an options request's
+ * agent writes (schema/youi.proposal.schema.json). Unknown keys are allowed, as the published schemas allow them;
+ * everything Toolroll reads is checked here, and every string is outside text all the same.
+ */
+import { z } from "zod";
+import { parseContract } from "./contract.js";
+export const REQUEST_ID = /^r-[0-9a-f]{10}$/;
+/** An options file's id: `p-` and the same 10 hex as the options request it answers. */
+export const PROPOSAL_ID = /^p-[0-9a-f]{10}$/;
+/** The provenance every task filed from a request carries (task_ref.filed_via): immutable, and the seal reads it. */
+export const YOUIYOUX_FILED_VIA = "youiyoux";
+/** The one chat card a pass's filings make for a project (youiyoux-intake.ts), drawn by chat-decide.ts: the new tasks,
+ * Approve all and each one's own Approve and Open. */
+export const YOUIYOUX_CARD_KIND = "youiyoux-requests";
+/** Where a person sees and approves everything waiting on them in the console (flow-triggers.ts NEEDS_YOU_HREF). */
+export const YOUIYOUX_HOME_PATH = "/work?view=needs-you";
+const text = (max) => z.string().min(1).max(max);
+const who = z.object({ kind: z.enum(["person", "agent"]), name: text(100) });
+// The published schema's date-time: an ISO timestamp with a zone.
+const when = z.string().max(40).regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/);
+export const YOUIYOUX_EVIDENCE = ["screenshot", "check", "changed-path", "manual-review"];
+/** A component prop as youiyoux names one: what an option may set. */
+const PROP = /^[A-Za-z_$][\w$]{0,63}$/;
+const value = z.union([z.string().max(2000), z.number().finite(), z.boolean()]);
+/** What an options request offers its agent: the one file to write (`.youi/proposals/<proposal>.json`), the props an
+ * option may set (enum values from `values`), and whether it may give the component new text. */
+export const youiyouxOfferSchema = z.object({
+    proposal: z.string().regex(PROPOSAL_ID),
+    file: text(500),
+    choices: z.record(z.string().regex(PROP), z.object({
+        type: z.enum(["enum", "string", "boolean", "number"]),
+        values: z.array(text(200)).max(100).optional(),
+        default: value.optional(),
+    })).refine(choices => Object.keys(choices).length <= 50, "at most 50 props"),
+    text: z.boolean(),
+});
+export const youiyouxTaskSchema = z.object({
+    title: text(120),
+    goal: text(4000),
+    touches: z.array(text(500)).max(50),
+    touchesKnown: z.boolean(),
+    why: text(500).optional(),
+    not: z.array(text(300)).max(10),
+    acceptance: z.array(z.object({ statement: text(300), evidence: z.array(z.enum(YOUIYOUX_EVIDENCE)).min(1) })).min(1).max(10),
+    /** An options request's: what its agent writes (optionsProblem holds it to the request). */
+    offer: youiyouxOfferSchema.optional(),
+});
+export const youiyouxRequestSchema = z.object({
+    schema: z.literal("youi.request/v1"),
+    id: z.string().regex(REQUEST_ID),
+    project: text(200),
+    kind: z.enum(["comment", "change", "options"]),
+    status: z.enum(["open", "addressed", "closed"]),
+    body: text(4000),
+    author: who,
+    createdAt: when,
+    updatedAt: when,
+    // Where the person pointed: the page, the component, and (when youiyoux knew it) the file and line that draw it.
+    target: z.object({ route: text(300), scope: z.enum(["here", "element"]), name: text(200), file: text(500).optional(), line: z.int().positive().max(Number.MAX_SAFE_INTEGER).optional() }),
+    task: youiyouxTaskSchema.optional(),
+    thread: z.array(z.unknown()).max(500),
+});
+export function readYouiyouxRequest(raw) {
+    return parseContract(youiyouxRequestSchema, raw);
+}
+/** The one file an options request's agent may write: `.youi/proposals/p-<the request's hex>.json`. */
+export const proposalIdOf = (request) => `p-${request.slice(2)}`;
+export const proposalFileOf = (proposal) => `.youi/proposals/${proposal}.json`;
+/** Why an options request can't be filed as youiyoux's contract has it, or null: it carries a task with an offer whose
+ * proposal is `p-<its own hex>`, whose file is that proposal's, and the task may touch that one file and nothing else. */
+export function optionsProblem(request) {
+    if (request.kind !== "options")
+        return null;
+    const offer = request.task?.offer;
+    if (request.task === undefined || offer === undefined)
+        return "it asks for options with no offer";
+    const proposal = proposalIdOf(request.id);
+    if (offer.proposal !== proposal)
+        return `its offer is for ${offer.proposal}, not ${proposal}`;
+    if (offer.file !== proposalFileOf(proposal))
+        return `its offer's file isn't ${proposalFileOf(proposal)}`;
+    if (!request.task.touchesKnown || request.task.touches.length !== 1 || request.task.touches[0] !== offer.file)
+        return "its task may touch more than its options file";
+    return null;
+}
+/** `youi.proposal/v1`: the options an agent puts on youiyoux's Screens canvas (youiyoux's packages/core/src/proposals.ts,
+ * mirrored). Toolroll checks only the shape and what it reads; youiyoux checks each option against the component's
+ * contract when it reads the file. */
+const OPTION_IDS = ["a", "b", "c", "d"];
+export const PROPOSAL_STATUSES = ["open", "chosen", "dismissed"];
+export const youiyouxProposalSchema = z.object({
+    $schema: z.string().max(500).optional(),
+    schema: z.literal("youi.proposal/v1"),
+    id: z.string().regex(PROPOSAL_ID),
+    project: text(200),
+    route: text(300),
+    target: z.object({
+        name: text(200), element: text(200).optional(), file: text(500).optional(),
+        line: z.int().positive().max(Number.MAX_SAFE_INTEGER).optional(), column: z.int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+        box: z.object({ x: z.number().finite(), y: z.number().finite(), width: z.number().finite().nonnegative(), height: z.number().finite().nonnegative() }),
+        page: z.object({ width: z.number().finite().positive(), height: z.number().finite().positive() }).optional(),
+    }),
+    ask: text(1000),
+    author: who,
+    createdAt: when,
+    updatedAt: when,
+    options: z.array(z.object({
+        id: z.enum(OPTION_IDS),
+        label: text(60),
+        why: text(500),
+        set: z.array(z.object({ prop: z.string().regex(PROP), value })).max(20),
+        text: text(2000).nullable(),
+    }).refine(option => option.set.length > 0 || option.text !== null, "an option changes a prop or the text")).min(2).max(4),
+    status: z.enum(PROPOSAL_STATUSES),
+    choice: z.enum(OPTION_IDS).optional(),
+    decidedBy: who.optional(),
+    decidedAt: when.optional(),
+    request: z.string().regex(REQUEST_ID).optional(),
+    for: z.string().regex(REQUEST_ID),
+}).refine(doc => new Set(doc.options.map(option => option.id)).size === doc.options.length, "each option has its own letter")
+    .refine(doc => doc.choice === undefined || doc.options.some(option => option.id === doc.choice), "the choice is one of its options");
+export function readYouiyouxProposal(raw) {
+    return parseContract(youiyouxProposalSchema, raw);
+}
+/** What Toolroll writes beside a request (`youi.request-task/v1`): the task it became, how that task stands, and, when
+ * the console has an address, the task's link and `home`, where a person sees and approves all waiting work. */
+export const YOUIYOUX_TASK_STATUSES = ["queued", "needs-you", "building", "ready", "done", "failed", "stopped"];
+/** A link youiyoux opens: http or https, at most 2,000 characters, with no user name or password in it. */
+export const youiyouxLinkSchema = z.string().max(2000).refine(value => {
+    try {
+        const url = new URL(value);
+        return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "";
+    }
+    catch {
+        return false;
+    }
+}, "an http or https address with no credentials");
+export const youiyouxRequestTaskSchema = z.strictObject({
+    schema: z.literal("youi.request-task/v1"),
+    request: z.string().regex(REQUEST_ID),
+    runner: z.literal("Toolroll"),
+    task: z.strictObject({ id: z.string().min(1).max(120), url: youiyouxLinkSchema.nullable() }),
+    home: youiyouxLinkSchema.optional(),
+    status: z.enum(YOUIYOUX_TASK_STATUSES),
+    detail: z.string().max(200),
+    updatedAt: when,
+});
+export function readYouiyouxRequestTask(raw) {
+    return parseContract(youiyouxRequestTaskSchema, raw);
+}

package/dist/coordinator.js

@@ -326,6 +326,7 @@ export function listTasksFor(store, who, filter, now) {
          FROM task_ref JOIN task ON task.id = task_ref.external_id AND task_ref.backend = 'built-in'
         WHERE task_ref.repo IN (${sql})
           AND (? IS NULL OR task.state = ?)
+          AND NOT EXISTS (SELECT 1 FROM task_archive WHERE task_archive.task_ref = task_ref.id)
           AND task_ref.id > ?
         ORDER BY task_ref.id LIMIT ?`)
         .all(now.toISOString(), ...args, filter.state ?? null, filter.state ?? null, filter.cursor ?? 0, limit + 1);

package/dist/deploy-gate.js

@@ -8,6 +8,7 @@
 import { assignmentOf } from "./assignment.js";
 import { liveReleaseOf, personApprovalOf, releaseApprovalOf } from "./scope.js";
 import { verificationEvidence } from "./verification-evidence.js";
+import { refArchived } from "./task-archive.js";
 import { releaseCiRunningOf } from "./release-ci-hold.js";
 import { nightlyDebtHold } from "./nightly-github.js";
 /** Whether run `runId` is a deployable candidate now, read only from the plane's records and this runtime's code. */
@@ -29,6 +30,9 @@ export function deploymentGate(store, input) {
         return refuse(`Run ${input.runId} is not a built candidate at ${head.slice(0, 7)}.`);
     if (scope === null || scope.approvedDigest !== scope.digest || scope.digest !== run.scopeDigest)
         return refuse("The run's signed scope is no longer the approved one.");
+    // A put-away task (v145, task-tidy.md) deploys nothing: restore it first.
+    if (refArchived(store, run.taskRef))
+        return refuse("This task is put away. Restore it before deploying.");
     // A person may approve during CI, including a release without carry terms. Every deployment road must wait
     // for the plane's exact-head observation, not only the release coordinator's polling loop.
     if (releaseCiRunningOf(store, ref.externalId) !== null)

package/dist/dispatch.d.ts

@@ -26,6 +26,9 @@ export type TaskReadinessBlocker = {
     blockerId: string;
     blockerState: TaskState;
     message: string;
+} | {
+    code: "archived";
+    message: string;
 };
 export type DispatchAction = "open-result" | "retry-task" | "place-task" | "write-scope" | "select-agent" | "approve-scope" | "answer-decision" | "unhold" | "inspect-hold" | "repair-dependency" | "repair-capability" | "start-worker"
 /** v50: ask for the bounded explicit review retry (`task review <run>`

package/dist/dispatch.js

@@ -16,7 +16,7 @@ import { REVIEW_TOKENS, resultStatusOf, reviewFactsOf } from "./workspace-ui.js"
 import { replacedWords } from "./task-status.js";
 import { failedAttemptSentence, latestFinishedAttempt } from "./needs-you.js";
 import { buildReviewOf } from "./review-switch.js";
-import { BUILT_IN, parseCapabilityKey } from "./store.js";
+import { BUILT_IN, refArchived, parseCapabilityKey } from "./store.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
 /**
  * Task state, active holds, and unfinished dependencies in the exact order
@@ -33,6 +33,9 @@ export function taskReadinessBlocker(store, taskRef, now) {
         .get(BUILT_IN, taskRef);
     if (task === undefined)
         return { code: "unknown-task", message: "no such task" };
+    // A put-away task (v145) never dispatches, whatever its state: restore it first.
+    if (refArchived(store, taskRef))
+        return { code: "archived", message: "put away" };
     const state = String(task["state"]);
     if (state !== "queued")
         return { code: "state", state, message: `state is ${state}, not queued` };

package/dist/flow-browser.d.ts

@@ -0,0 +1,103 @@
+import { type FlowDefinition } from "./flows.js";
+import type { FlowRow, FlowScriptRow, Store } from "./store.js";
+/** v144: each approval of browser use, live or ended. `digest` is browserApprovalDigest of what was approved. Additive only. */
+export declare const FLOW_BROWSER_SCHEMA = "\nCREATE TABLE IF NOT EXISTS flow_browser_grant (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\n  flow          INTEGER NOT NULL,\n  repo          TEXT NOT NULL,\n  flow_revision INTEGER NOT NULL,\n  flow_digest   TEXT NOT NULL,\n  digest        TEXT NOT NULL,\n  zones_json    TEXT NOT NULL,\n  signed_by     TEXT NOT NULL,\n  signed_at     TEXT NOT NULL,\n  proof         TEXT NOT NULL,\n  revoked_at    TEXT,\n  revoked_by    TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS flow_browser_live ON flow_browser_grant (flow) WHERE revoked_at IS NULL;\n";
+/** One zone an approval covers: the zone, and the script it runs (name, version and content digest). */
+export type BrowserZone = {
+    zone: string;
+    script: string;
+    version: number;
+    digest: string;
+};
+/** Everything an approval is about: the flow, its project, the drawing (revision and digest) and every browser zone. */
+export type BrowserTerms = {
+    flow: number;
+    repo: string;
+    revision: number;
+    flowDigest: string;
+    zones: BrowserZone[];
+};
+export type FlowBrowserGrant = BrowserTerms & {
+    id: number;
+    digest: string;
+    signedBy: string;
+    signedAt: string;
+    proof: string;
+};
+/** The approval's digest: domain-separated over the whole of its terms, so a changed flow, drawing, revision or any
+ * covered script (a restored one is a new version) is a different approval. */
+export declare function browserApprovalDigest(terms: BrowserTerms): string;
+/** The flow's script zones that say they start a browser, each with the script it runs now; null when one's script is
+ * missing, waiting for approval, or runs a project file (an approval seals the script's own text, never a file the
+ * project can change). */
+export declare function browserZonesOf(store: Store, flow: FlowRow, definition: FlowDefinition): BrowserZone[] | null;
+/** What an approval of this flow would be about now, read from the store; null when it can't be approved. */
+export declare function browserTermsOf(store: Store, flow: FlowRow): BrowserTerms | null;
+/** The flow's live approval, as recorded (whether it still stands is browserStanding's question). */
+export declare function liveBrowserGrant(store: Store, flowId: number): FlowBrowserGrant | null;
+/**
+ * Whether `zone` of this flow may start a browser now. `run`, when given, is what the caller is about to run — the
+ * drawing it read and the very script object it hands the launch — and the answer is about exactly that. The live
+ * approval stands only when its digest is the approval this flow would be now (same flow, project, drawing revision and
+ * digest, and every browser zone's script name, version and digest), it was a person's, and its signer is still an
+ * approver who reaches the project; `run`'s drawing must be that drawing and its script that zone's script. Anything
+ * unreadable, changed or mismatched is a no, with the plain words a card waits with.
+ */
+export declare function browserStanding(store: Store, flowId: number, zone: string, run?: {
+    definition: FlowDefinition;
+    script: FlowScriptRow;
+}): {
+    allowed: true;
+} | {
+    allowed: false;
+    said: string;
+};
+/** What approving means, in words the person reads before they give their password. */
+export declare function browserTerms(zones: readonly BrowserZone[]): string[];
+/**
+ * Approve browser use for the flow as it stands. `proof` is the signer's credential method, proved by the caller just
+ * now; only a person's counts (a lead's or remote run's token is refused), from an approver who reaches the project.
+ * Re-reads the flow, its zones and scripts in the one transaction that writes; `sawDigest` (required) is the approval
+ * (browserApprovalDigest: drawing and scripts) the person read, and anything else is refused. Replaces any live one.
+ */
+export declare function signFlowBrowser(store: Store, input: {
+    flow: number;
+    signer: string;
+    proof: string | null;
+    sawDigest: string;
+    /** The console and chat: the signer's account must still be this generation (the session that proved it) and reach every project. */
+    console?: {
+        generation: number;
+    };
+}, now: Date): {
+    ok: true;
+    grant: FlowBrowserGrant;
+} | {
+    ok: false;
+    message: string;
+};
+/** Any approver on the project ends it, with no password: lowering authority. False when there was none. */
+export declare function revokeFlowBrowser(store: Store, flowId: number, by: string, now: Date): boolean;
+/** What the flow page, `flows show` and chat say about browser use: null when no zone says it starts a browser. */
+export type BrowserView = {
+    /** allowed: the approval stands now; ended: there is one, but it no longer stands; none: no one has approved. */
+    status: "allowed" | "ended" | "none";
+    /** The one line every surface shows. */
+    words: string;
+    signedBy: string | null;
+    signedAt: string | null;
+    /** The browser zones as they stand now, each with its title. Empty while one can't be approved (see `problem`). */
+    zones: (BrowserZone & {
+        title: string;
+    })[];
+    /** What approving means (browserTerms), and the approval digest the step-up must carry back. */
+    terms: string[];
+    digest: string | null;
+    /** Why it can't be approved as it stands, or null. */
+    problem: string | null;
+};
+/**
+ * Browser use for one flow, read from the store (no writes: page visits call it). Whether it is allowed is exactly
+ * browserStanding's answer for the flow's browser zones; the rest only says why in plain words.
+ */
+export declare function browserViewOf(store: Store, flow: FlowRow): BrowserView | null;