toolroll 0.9.62 → 0.9.65

package/dist/lead-queue.d.ts

@@ -0,0 +1,104 @@
+import type { Store } from "./store.js";
+/** At most this many messages wait per person, and this many characters in all; a waiting message expires after 7 days. */
+export declare const LEAD_QUEUE_MAX_MESSAGES = 10;
+export declare const LEAD_QUEUE_MAX_CHARS = 20000;
+export declare const LEAD_QUEUE_EXPIRY_MS: number;
+/** What a queued message was sent with: resolved and validated at send, re-validated before its turn. */
+export type LeadQueueContext = {
+    task?: string;
+    result?: number;
+    mode?: string;
+    project?: string;
+};
+export type LeadQueueStatus = "queued" | "running" | "answered" | "failed" | "cancelled" | "uncertain";
+export type LeadQueueRow = {
+    message: number;
+    thread: number;
+    approver: string;
+    approverGeneration: number;
+    session: number;
+    ceilingDigest: string;
+    requestId: string;
+    payloadHash: string;
+    context: LeadQueueContext | null;
+    status: LeadQueueStatus;
+    revision: number;
+    generation: number;
+    runner: string | null;
+    turnId: number | null;
+    error: string | null;
+    createdAt: string;
+    text: string;
+};
+/** A claimed row: the fence every later step re-proves (status running, this runner, this generation and revision). */
+export type LeadQueueClaim = LeadQueueRow & {
+    runner: string;
+    status: "running";
+};
+/** The identity of a send: the same request with the same words and context is the same message. */
+export declare function leadQueuePayloadHash(thread: number, text: string, context: LeadQueueContext | null): string;
+export type SendDecision = {
+    kind: "run";
+} | {
+    kind: "queued";
+    row: LeadQueueRow;
+    already: boolean;
+} | {
+    kind: "conflict";
+} | {
+    kind: "full";
+    message: string;
+};
+export declare class PersonalQueue {
+    private readonly store;
+    constructor(store: Store);
+    private get db();
+    /** The approver's backlog: rows waiting or claimed but not yet bound to a turn, oldest first. */
+    backlog(approver: string): LeadQueueRow[];
+    /** Every queue row of a thread (what the thread shows next to its messages). */
+    forThread(thread: number): LeadQueueRow[];
+    get(message: number): LeadQueueRow | null;
+    /**
+     * Send: run now, or wait — in ONE transaction, so a turn ending between the check and the insert can't strand a
+     * message. A request already saved with the same words and context is that message (never a second send, never a
+     * removed one resurrected); with different ones it conflicts. Busy means a personal lead turn of this person is
+     * queued or running, or something of theirs already waits.
+     */
+    sendOrQueue(input: {
+        approver: string;
+        approverGeneration: number;
+        session: number;
+        ceilingDigest: string;
+        thread: number;
+        text: string;
+        requestId: string;
+        context: LeadQueueContext | null;
+    }, now: Date): SendDecision;
+    /**
+     * The next message to run: per person, only the oldest of their backlog, only while none of theirs runs, and only when
+     * `eligible` agrees (the runtime's admission stamp). Claiming keeps it in the backlog until its turn binds it.
+     */
+    claimNext(runner: string, now: Date, eligible?: (row: LeadQueueRow) => boolean): LeadQueueClaim | null;
+    /** The claim still stands: running, this runner, this generation and revision, unbound or bound to `turn`. */
+    current(claim: LeadQueueClaim): boolean;
+    /** Inside the engine's admission transaction (onAdmitted): the claim binds to the turn that took it, exactly once. */
+    bindTurn(claim: LeadQueueClaim, turnId: number): boolean;
+    /** The claim ends: answered (its turn's reply is in the thread), failed or cancelled (words kept as the error), or
+     * uncertain (an outcome that can't be confirmed — never sent again). A message that never got a turn loses its words. */
+    finish(claim: LeadQueueClaim, result: {
+        status: "answered" | "failed" | "cancelled" | "uncertain";
+        error?: string;
+        turnId?: number;
+    }, now: Date): boolean;
+    /** A refusal before admission (a cap, a budget, a latch, another turn): back to waiting with the words to show. */
+    defer(claim: LeadQueueClaim, error: string): boolean;
+    /** Remove a waiting message (its author only, while it still waits): its words are forgotten, its request kept. */
+    remove(approver: string, message: number, now: Date): "removed" | "started" | "not-found";
+    /** Settle rows whose bound turn ended (by its recorded state), expire week-old waiting rows, and mark a claim that
+     * never bound by its turn deadline uncertain (the binding is the proof; elapsed time never resends). */
+    reconcile(now: Date, turnDeadlineMs: number): number;
+    /** End every waiting message sent under a session (it ended, or its person's chat was revoked). */
+    cancelForSession(session: number, why: string, now: Date): number;
+    /** A message that never ran keeps no words, context or search copy (it stays pending, so never history). */
+    private forgetWords;
+}

package/dist/lead-queue.js

@@ -0,0 +1,187 @@
+/**
+ * The personal lead queue (docs/plans/lead-message-queue.md): a message sent while one of its author's personal lead
+ * turns runs (or while earlier ones wait) waits here and runs one turn per message, in order — the same machinery
+ * shared team conversations use (team-leads.ts), for the person's own threads (/chat, a task's or a project's chat).
+ *
+ * The row's words are its lead_message (pending until the engine's admission binds it, which clears pending in the
+ * same statement). Admission itself is the engine's (runLeadTurn with queuedMessageId + onAdmitted): this module only
+ * decides queue-or-run at send, claims the backlog's oldest row, binds, finishes, defers, removes and expires.
+ */
+import { createHash } from "node:crypto";
+/** At most this many messages wait per person, and this many characters in all; a waiting message expires after 7 days. */
+export const LEAD_QUEUE_MAX_MESSAGES = 10;
+export const LEAD_QUEUE_MAX_CHARS = 20_000;
+export const LEAD_QUEUE_EXPIRY_MS = 7 * 86_400_000;
+/** The identity of a send: the same request with the same words and context is the same message. */
+export function leadQueuePayloadHash(thread, text, context) {
+    return createHash("sha256").update(JSON.stringify([thread, text, context === null ? null : canonical(context)])).digest("hex");
+}
+const canonical = (context) => Object.fromEntries(Object.entries(context).filter(([, value]) => value !== undefined).sort(([a], [b]) => a.localeCompare(b)));
+const readRow = (row) => ({
+    message: Number(row["message"]), thread: Number(row["thread"]), approver: String(row["approver"]), approverGeneration: Number(row["approver_generation"]),
+    session: Number(row["session"]), ceilingDigest: String(row["ceiling_digest"]), requestId: String(row["request_id"]), payloadHash: String(row["payload_hash"]),
+    context: row["context_json"] === null ? null : JSON.parse(String(row["context_json"])), status: String(row["status"]),
+    revision: Number(row["revision"]), generation: Number(row["generation"]), runner: row["runner"] === null ? null : String(row["runner"]),
+    turnId: row["turn_id"] === null ? null : Number(row["turn_id"]), error: row["error"] === null ? null : String(row["error"]),
+    createdAt: String(row["created_at"]), text: String(row["text"] ?? ""),
+});
+const SELECT = "SELECT q.*, m.text FROM lead_queue q JOIN lead_message m ON m.id = q.message";
+export class PersonalQueue {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    get db() { return this.store.handle; }
+    /** The approver's backlog: rows waiting or claimed but not yet bound to a turn, oldest first. */
+    backlog(approver) {
+        return this.db.prepare(`${SELECT} WHERE q.approver = ? AND (q.status = 'queued' OR (q.status = 'running' AND q.turn_id IS NULL)) ORDER BY q.message`).all(approver).map(readRow);
+    }
+    /** Every queue row of a thread (what the thread shows next to its messages). */
+    forThread(thread) {
+        return this.db.prepare(`${SELECT} WHERE q.thread = ? ORDER BY q.message`).all(thread).map(readRow);
+    }
+    get(message) {
+        const row = this.db.prepare(`${SELECT} WHERE q.message = ?`).get(message);
+        return row === undefined ? null : readRow(row);
+    }
+    /**
+     * Send: run now, or wait — in ONE transaction, so a turn ending between the check and the insert can't strand a
+     * message. A request already saved with the same words and context is that message (never a second send, never a
+     * removed one resurrected); with different ones it conflicts. Busy means a personal lead turn of this person is
+     * queued or running, or something of theirs already waits.
+     */
+    sendOrQueue(input, now) {
+        return this.store.transact(() => {
+            const hash = leadQueuePayloadHash(input.thread, input.text, input.context);
+            const seen = this.db.prepare(`${SELECT} WHERE q.session = ? AND q.request_id = ?`).get(input.session, input.requestId);
+            if (seen !== undefined)
+                return String(seen["payload_hash"]) === hash ? { kind: "queued", row: readRow(seen), already: true } : { kind: "conflict" };
+            const live = this.db.prepare(`SELECT 1 FROM mate_turn WHERE approver = ? AND state IN ('queued','running')
+        AND NOT EXISTS (SELECT 1 FROM team_conversation tc WHERE tc.thread = mate_turn.thread) LIMIT 1`).get(input.approver);
+            const waiting = this.backlog(input.approver);
+            if (live === undefined && waiting.length === 0)
+                return { kind: "run" };
+            if (waiting.length >= LEAD_QUEUE_MAX_MESSAGES)
+                return { kind: "full", message: `${LEAD_QUEUE_MAX_MESSAGES} messages are already waiting. Remove one, or wait for a reply.` };
+            if (waiting.reduce((sum, one) => sum + one.text.length, 0) + input.text.length > LEAD_QUEUE_MAX_CHARS) {
+                return { kind: "full", message: "The messages waiting are already long. Remove one, or wait for a reply." };
+            }
+            const message = this.store.appendLeadMessage({ thread: input.thread, turn: null, role: "operator", text: input.text, pending: true }, now);
+            this.db.prepare(`INSERT INTO lead_queue (message, thread, approver, approver_generation, session, ceiling_digest, request_id, payload_hash, context_json, status, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', ?)`).run(message, input.thread, input.approver, input.approverGeneration, input.session, input.ceilingDigest, input.requestId, hash, input.context === null ? null : JSON.stringify(canonical(input.context)), now.toISOString());
+            return { kind: "queued", row: this.get(message), already: false };
+        });
+    }
+    /**
+     * The next message to run: per person, only the oldest of their backlog, only while none of theirs runs, and only when
+     * `eligible` agrees (the runtime's admission stamp). Claiming keeps it in the backlog until its turn binds it.
+     */
+    claimNext(runner, now, eligible = () => true) {
+        return this.store.transact(() => {
+            // An uncertain row does not hold the person's later messages (unlike a team room): its outcome is shown on it, and
+            // an unknown cost already pauses chat through its own latch.
+            const heads = this.db.prepare(`${SELECT} WHERE q.status = 'queued'
+        AND NOT EXISTS (SELECT 1 FROM lead_queue r WHERE r.approver = q.approver AND r.status = 'running')
+        AND NOT EXISTS (SELECT 1 FROM lead_queue e WHERE e.approver = q.approver AND e.status = 'queued' AND e.message < q.message)
+        ORDER BY q.message LIMIT 50`).all().map(readRow);
+            for (const row of heads) {
+                if (!eligible(row))
+                    continue;
+                const changed = this.db.prepare("UPDATE lead_queue SET status = 'running', generation = generation + 1, runner = ?, claimed_at = ? WHERE message = ? AND status = 'queued'")
+                    .run(runner, now.toISOString(), row.message);
+                if (Number(changed.changes) !== 1)
+                    continue;
+                return { ...row, status: "running", runner, generation: row.generation + 1 };
+            }
+            return null;
+        });
+    }
+    /** The claim still stands: running, this runner, this generation and revision, unbound or bound to `turn`. */
+    current(claim) {
+        return this.db.prepare("SELECT 1 FROM lead_queue WHERE message = ? AND status = 'running' AND runner = ? AND generation = ? AND revision = ?")
+            .get(claim.message, claim.runner, claim.generation, claim.revision) !== undefined;
+    }
+    /** Inside the engine's admission transaction (onAdmitted): the claim binds to the turn that took it, exactly once. */
+    bindTurn(claim, turnId) {
+        if (!this.current(claim))
+            return false;
+        const turn = this.store.getLeadTurn(turnId);
+        if (turn === null || turn.thread !== claim.thread || turn.approver !== claim.approver)
+            return false;
+        return Number(this.db.prepare("UPDATE lead_queue SET turn_id = ? WHERE message = ? AND turn_id IS NULL AND status = 'running' AND generation = ?")
+            .run(turnId, claim.message, claim.generation).changes) === 1;
+    }
+    /** The claim ends: answered (its turn's reply is in the thread), failed or cancelled (words kept as the error), or
+     * uncertain (an outcome that can't be confirmed — never sent again). A message that never got a turn loses its words. */
+    finish(claim, result, now) {
+        return this.store.transact(() => {
+            const row = this.db.prepare("SELECT turn_id FROM lead_queue WHERE message = ? AND status = 'running' AND runner = ? AND generation = ?").get(claim.message, claim.runner, claim.generation);
+            if (row === undefined)
+                return false;
+            if (result.turnId !== undefined && row["turn_id"] !== null && Number(row["turn_id"]) !== result.turnId)
+                return false;
+            this.db.prepare("UPDATE lead_queue SET status = ?, error = ?, turn_id = COALESCE(turn_id, ?), revision = revision + 1, settled_at = ? WHERE message = ?")
+                .run(result.status, result.error ?? null, result.turnId ?? null, now.toISOString(), claim.message);
+            if (row["turn_id"] === null && result.turnId === undefined)
+                this.forgetWords(claim.message);
+            return true;
+        });
+    }
+    /** A refusal before admission (a cap, a budget, a latch, another turn): back to waiting with the words to show. */
+    defer(claim, error) {
+        return Number(this.db.prepare(`UPDATE lead_queue SET status = 'queued', generation = generation + 1, revision = revision + 1, runner = NULL, claimed_at = NULL, error = ?
+      WHERE message = ? AND status = 'running' AND turn_id IS NULL AND runner = ? AND generation = ?`).run(error, claim.message, claim.runner, claim.generation).changes) === 1;
+    }
+    /** Remove a waiting message (its author only, while it still waits): its words are forgotten, its request kept. */
+    remove(approver, message, now) {
+        return this.store.transact(() => {
+            const row = this.db.prepare("SELECT status FROM lead_queue WHERE message = ? AND approver = ?").get(message, approver);
+            if (row === undefined)
+                return "not-found";
+            if (row["status"] !== "queued")
+                return "started";
+            this.db.prepare("UPDATE lead_queue SET status = 'cancelled', error = 'Removed.', revision = revision + 1, settled_at = ? WHERE message = ?").run(now.toISOString(), message);
+            this.forgetWords(message);
+            return "removed";
+        });
+    }
+    /** Settle rows whose bound turn ended (by its recorded state), expire week-old waiting rows, and mark a claim that
+     * never bound by its turn deadline uncertain (the binding is the proof; elapsed time never resends). */
+    reconcile(now, turnDeadlineMs) {
+        return this.store.transact(() => {
+            let changed = 0;
+            for (const row of this.db.prepare(`SELECT q.message, t.state, t.failure_reason FROM lead_queue q JOIN mate_turn t ON t.id = q.turn_id
+        WHERE q.status = 'running' AND t.state IN ('answered','failed')`).all()) {
+                const uncertain = this.store.leadTurnCostUnconfirmed(Number(this.db.prepare("SELECT turn_id FROM lead_queue WHERE message = ?").get(Number(row["message"]))["turn_id"]));
+                const status = row["state"] === "answered" ? "answered" : uncertain ? "uncertain" : "failed";
+                changed += Number(this.db.prepare("UPDATE lead_queue SET status = ?, error = ?, revision = revision + 1, settled_at = ? WHERE message = ? AND status = 'running'")
+                    .run(status, status === "answered" ? null : String(row["failure_reason"] ?? "failed"), now.toISOString(), Number(row["message"])).changes);
+            }
+            const stale = new Date(now.getTime() - turnDeadlineMs).toISOString();
+            changed += Number(this.db.prepare("UPDATE lead_queue SET status = 'uncertain', error = 'Delivery could not be confirmed. Nothing was sent again.', revision = revision + 1, settled_at = ? WHERE status = 'running' AND turn_id IS NULL AND claimed_at < ?")
+                .run(now.toISOString(), stale).changes);
+            const old = new Date(now.getTime() - LEAD_QUEUE_EXPIRY_MS).toISOString();
+            for (const row of this.db.prepare("SELECT message FROM lead_queue WHERE status = 'queued' AND created_at < ?").all(old)) {
+                this.db.prepare("UPDATE lead_queue SET status = 'failed', error = 'Not sent: it waited too long.', revision = revision + 1, settled_at = ? WHERE message = ?").run(now.toISOString(), Number(row["message"]));
+                this.forgetWords(Number(row["message"]));
+                changed++;
+            }
+            return changed;
+        });
+    }
+    /** End every waiting message sent under a session (it ended, or its person's chat was revoked). */
+    cancelForSession(session, why, now) {
+        return this.store.transact(() => {
+            const rows = this.db.prepare("SELECT message FROM lead_queue WHERE session = ? AND status = 'queued'").all(session);
+            for (const row of rows) {
+                this.db.prepare("UPDATE lead_queue SET status = 'cancelled', error = ?, revision = revision + 1, settled_at = ? WHERE message = ?").run(why, now.toISOString(), Number(row["message"]));
+                this.forgetWords(Number(row["message"]));
+            }
+            return rows.length;
+        });
+    }
+    /** A message that never ran keeps no words, context or search copy (it stays pending, so never history). */
+    forgetWords(message) {
+        this.store.forgetQueuedLeadMessage(message);
+    }
+}

package/dist/lead-sweep.d.ts

@@ -0,0 +1,67 @@
+import { type AssignmentSnapshot } from "./assignment.js";
+import { type Store } from "./store.js";
+import { type StopRequest } from "./task-control.js";
+export declare const SWEEP_VERDICTS: readonly ["fixed", "not reproducible", "blocked", "done"];
+export type SweepVerdict = typeof SWEEP_VERDICTS[number];
+/** The line every sweep child's brief asks for, appended to the shared rules. */
+export declare const VERDICT_RULE = "Start your handoff's conclusion with one line: `Verdict: fixed`, `Verdict: not reproducible`, `Verdict: blocked` or `Verdict: done`, then ` \u2014 ` and one sentence why (the root cause, what you tried, or what blocks it).";
+/** A conclusion's verdict line, read strictly. */
+export declare function verdictOf(conclusion: string | null | undefined): {
+    verdict: SweepVerdict;
+    why: string;
+} | null;
+export type SweepRow = {
+    ordinal: number;
+    label: string;
+    /** The child's family root: its identity in the sweep. */
+    task: string;
+    /** The task the family is on now (a revision of the child, after one): what an act on this row acts on. */
+    active: string;
+    state: AssignmentSnapshot["state"] | "missing";
+    detail: string;
+    verdict: {
+        verdict: SweepVerdict;
+        why: string;
+    } | null;
+    /** The child's result, when it has one. */
+    result: {
+        taskId: string;
+        runId: number;
+    } | null;
+};
+export type SweepTable = {
+    id: number;
+    title: string;
+    repo: string;
+    maxParallel: number;
+    rows: SweepRow[];
+    counts: {
+        settled: number;
+        working: number;
+        total: number;
+        byVerdict: Partial<Record<SweepVerdict, number>>;
+    };
+};
+/** A sweep as its table shows it; null when there is no such sweep or this reader may not see its project. */
+export declare function sweepTable(store: Store, id: number, now: Date, repos: readonly string[], root?: string): SweepTable | null;
+/** "8 of 11 settled — 5 fixed, 2 not reproducible, 1 blocked": the sweep in one line. */
+export declare function sweepLine(table: SweepTable): string;
+/** Not ready yet: working, being checked, or waiting on a decision — what "cancel the rest" acts on. */
+export declare const SWEEP_OPEN: ReadonlySet<SweepRow["state"]>;
+/** One open item exactly as it stands now: its active task, state, attempt (a running build to stop) and last change. */
+export type SweepOpenItem = {
+    label: string;
+    task: string;
+    state: string;
+    run: number | null;
+    at: string | null;
+    scope: string | null;
+};
+/** Exactly what "cancel the rest" would act on now; any change makes a card or a form for it stale. */
+export declare function sweepOpen(store: Store, table: SweepTable, now: Date): SweepOpenItem[];
+export declare const sweepOpenDigest: (open: readonly SweepOpenItem[]) => string;
+/**
+ * Cancel the rest: a running build is stopped through the ordinary stop (process-exit safeguards and all); anything
+ * else is cancelled. Every refusal is said, never swallowed. The caller has proved `open` is what stands now.
+ */
+export declare function cancelSweepRest(store: Store, actor: string, open: readonly SweepOpenItem[], now: Date, via: StopRequest["via"]): string;

package/dist/lead-sweep.js

@@ -0,0 +1,99 @@
+/**
+ * Lead fan-out (docs/plans/lead-fan-out.md): a sweep's table and verdicts, read from facts — never a model.
+ *
+ * Each row is a child's assignment (the same state words the board uses), its verdict, and its result. The verdict is
+ * the first line of the child's conclusion, `Verdict: fixed | not reproducible | blocked | done — why`, which the
+ * sweep's brief asks for. It is read strictly: anything else reads as no verdict, never a guess.
+ */
+import { createHash } from "node:crypto";
+import { withActor } from "./actor.js";
+import { assignmentOf } from "./assignment.js";
+import { chatTaskRun } from "./chat-task-actions.js";
+import { verifiedAuthor } from "./store.js";
+import { requestTaskStop } from "./task-control.js";
+export const SWEEP_VERDICTS = ["fixed", "not reproducible", "blocked", "done"];
+/** The line every sweep child's brief asks for, appended to the shared rules. */
+export const VERDICT_RULE = "Start your handoff's conclusion with one line: `Verdict: fixed`, `Verdict: not reproducible`, `Verdict: blocked` or `Verdict: done`, then ` — ` and one sentence why (the root cause, what you tried, or what blocks it).";
+/** A conclusion's verdict line, read strictly. */
+export function verdictOf(conclusion) {
+    if (typeof conclusion !== "string")
+        return null;
+    const first = conclusion.split("\n", 1)[0].trim();
+    const match = /^Verdict:\s*(fixed|not reproducible|not-reproducible|blocked|done)\s*(?:—|–|-|:)\s*(.{1,300})$/i.exec(first);
+    if (match === null)
+        return null;
+    const verdict = match[1].toLowerCase().replace("-", " ");
+    return SWEEP_VERDICTS.includes(verdict) ? { verdict, why: match[2].trim() } : null;
+}
+const SETTLED = new Set(["ready-to-check", "complete", "cancelled", "needs-decision", "missing"]);
+/** A sweep as its table shows it; null when there is no such sweep or this reader may not see its project. */
+export function sweepTable(store, id, now, repos, root) {
+    const sweep = store.getSweep(id);
+    if (sweep === null || !repos.includes(sweep.repo))
+        return null;
+    const rows = store.sweepTasks(id).map(child => {
+        const assignment = assignmentOf(store, child.rootTask, now, { principal: "operator", repos }, root);
+        const run = assignment?.receipt?.runId ?? null;
+        const resultTask = assignment?.receipt?.taskId ?? null;
+        const conclusion = run === null ? null : store.getRun(run)?.handoff ?? null;
+        return {
+            ordinal: child.ordinal, label: child.label, task: child.rootTask, active: assignment?.activeTaskId ?? child.rootTask,
+            state: assignment?.state ?? "missing", detail: assignment?.detail ?? "This task is gone.",
+            verdict: verdictOf(conclusion),
+            result: run === null || resultTask === null ? null : { taskId: resultTask, runId: run },
+        };
+    });
+    const byVerdict = {};
+    for (const row of rows)
+        if (row.verdict !== null)
+            byVerdict[row.verdict.verdict] = (byVerdict[row.verdict.verdict] ?? 0) + 1;
+    const settled = rows.filter(row => SETTLED.has(row.state)).length;
+    return { id, title: sweep.title, repo: sweep.repo, maxParallel: sweep.maxParallel, rows,
+        counts: { settled, working: rows.length - settled, total: rows.length, byVerdict } };
+}
+/** "8 of 11 settled — 5 fixed, 2 not reproducible, 1 blocked": the sweep in one line. */
+export function sweepLine(table) {
+    const verdicts = SWEEP_VERDICTS.filter(one => (table.counts.byVerdict[one] ?? 0) > 0).map(one => `${table.counts.byVerdict[one]} ${one}`);
+    return `${table.counts.settled} of ${table.counts.total} settled${verdicts.length === 0 ? "" : ` — ${verdicts.join(", ")}`}`;
+}
+/** Not ready yet: working, being checked, or waiting on a decision — what "cancel the rest" acts on. */
+export const SWEEP_OPEN = new Set(["working", "checking", "needs-decision"]);
+/** Exactly what "cancel the rest" would act on now; any change makes a card or a form for it stale. */
+export function sweepOpen(store, table, now) {
+    return table.rows.filter(row => SWEEP_OPEN.has(row.state)).map(row => ({
+        label: row.label, task: row.active, state: row.state, run: chatTaskRun(store, row.active, "stop", now), at: store.getTask(row.active)?.updatedAt ?? null,
+        // The scope's identity too: a goal rewritten in between makes a card or form for it stale (Codex sweep r2).
+        scope: store.getScope(row.active)?.digest ?? null,
+    }));
+}
+export const sweepOpenDigest = (open) => createHash("sha256").update(JSON.stringify(open)).digest("hex");
+/**
+ * Cancel the rest: a running build is stopped through the ordinary stop (process-exit safeguards and all); anything
+ * else is cancelled. Every refusal is said, never swallowed. The caller has proved `open` is what stands now.
+ */
+export function cancelSweepRest(store, actor, open, now, via) {
+    let cancelled = 0, stopping = 0;
+    const refused = [];
+    for (const item of open) {
+        if (item.run !== null) {
+            const stop = requestTaskStop(store, { taskId: item.task, runId: item.run, by: verifiedAuthor(actor), via }, now);
+            if (stop.ok)
+                stopping += 1;
+            else
+                refused.push(`${item.label} (${stop.detail})`);
+            continue;
+        }
+        const result = withActor({ account: actor, lead: false }, () => store.cancelTask(item.task, now));
+        if (result.ok)
+            cancelled += 1;
+        else
+            refused.push(`${item.label} (${String(result.reason ?? "refused")})`);
+    }
+    const parts = [`Cancelled ${cancelled} item${cancelled === 1 ? "" : "s"}.`];
+    if (stopping > 0)
+        parts.push(`Stop requested for ${stopping} running build${stopping === 1 ? "" : "s"}: ${stopping === 1 ? "it stops" : "they stop"} at the next safe point; cancel ${stopping === 1 ? "it" : "them"} from the task page once stopped.`);
+    if (refused.length > 0)
+        parts.push(`Not cancelled: ${refused.join("; ")}.`);
+    parts.push("Finished results stay.");
+    return parts.join(" ");
+}

package/dist/lead-tools.d.ts

@@ -48,6 +48,12 @@ export type LeadToolContext = {
     checkedCapabilities?: Map<string, number>;
     /** Records this turn's one question to its owner; false when it already asked one. Absent: this surface cannot ask. */
     ask?: (question: string, options: readonly string[]) => boolean;
+    /** This turn's tool discovery (find_tools): how many searches it made and which deferred tools it found, which the
+     * conversation loop advertises from its next request. Absent (a direct call outside a turn): nothing to add to. */
+    findTools?: {
+        searches: number;
+        found: Set<string>;
+    };
 };
 export type LeadToolResult = {
     ok: true;
@@ -105,6 +111,22 @@ export declare const ISO_STAMP_RULE: RegExp;
  * through a confirmed card into the one authenticated edit transaction.
  */
 export declare function agentsOver(store: Store, taskId: string, now: Date): Record<string, unknown> | null;
+/**
+ * The tools every request advertises (docs/plans/lead-deferred-tools.md): the ones most replies use, and every tool a
+ * guard requires read in an earlier step (search_project_memory before any proposal, get_capabilities before work that
+ * needs an agent, get_result before propose_review, get_decision before propose_answer). The rest are found with
+ * find_tools and advertised from the next request of the same reply.
+ */
+export declare const LEAD_CORE_TOOLS: ReadonlySet<string>;
+/** At most this many find_tools searches per reply, results per search, and bytes of found tool schemas per reply. */
+export declare const FIND_TOOLS_PER_TURN = 3;
+export declare const FIND_TOOLS_MAX_RESULTS = 6;
+export declare const FIND_TOOLS_SCHEMA_BYTES = 48000;
+/** The deferred tools a query finds, best first: an exact name, then words in the name, keywords and description. */
+export declare function findLeadTools(query: string): {
+    name: string;
+    summary: string;
+}[];
 /** The lead's tools, in the order the model is shown them: each one's inputSchema is its contract, derived. */
 export declare const LEAD_TOOLS: LeadTool[];
 /** A unified diff, file by file, with each file's added and removed lines. */