toolroll 0.9.63 → 0.9.65

package/dist/console-instance.js

@@ -0,0 +1,337 @@
+/**
+ * THE RUNNING CONSOLE, PROVED LIVE (docs/plans/agents-cockpit.md B1).
+ *
+ * Bare `toolroll` in a repository attaches to a console already running for this installation instead of starting a
+ * second one. Build agents run as the operator's own user, so nothing the filesystem says can tell the operator from
+ * an agent: the console's Unix socket is DISCOVERY ONLY. It answers one verb, `hello`, with facts an agent could learn
+ * anyway, and changes nothing.
+ *
+ * What proves the console is real is a fresh random instance secret, minted at each start of `up` and written to the
+ * database (behind the agent fence) with its pid, build and port. The CLI reads it from the database it opens itself,
+ * then makes the LIVE console answer two fresh challenges with it: over the socket (HMAC of "socket:" + challenge),
+ * and over the advertised HTTP listener (HMAC of "http:" + challenge + " " + address + " " + port, where the address and
+ * port are what the console itself saw as the receiving end of that very connection). The CLI requires those to be
+ * 127.0.0.1 and the recorded port, so a relay on 127.0.0.1 forwarding to the console's other address is refused, as are
+ * a replayed hello, a stale record with a recycled pid, and another process now on that port.
+ */
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { lstatSync, mkdirSync, realpathSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { basename, dirname, join } from "node:path";
+export const CONSOLE_INSTANCE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS console_instance (
+  id         INTEGER PRIMARY KEY CHECK (id = 1),
+  secret     TEXT NOT NULL,
+  pid        INTEGER NOT NULL,
+  port       INTEGER NOT NULL,
+  build      TEXT NOT NULL,
+  socket     TEXT NOT NULL,
+  started_at TEXT NOT NULL
+);`;
+/**
+ * The socket's own owner-only directory beside the database's REAL file (a symlinked database resolves to the one
+ * folder every spelling shares). Each console start binds a socket of its own, under a fresh random name recorded
+ * with its secret: no console ever needs to remove — or can remove — another console's socket.
+ */
+/** Toolroll's own name, so it never collides with a project or worktree that happens to sit beside the database. */
+export const INSTANCE_DIR = ".toolroll-run";
+export function instanceRunDir(databaseFile) {
+    let file = databaseFile;
+    try {
+        file = realpathSync(databaseFile);
+    }
+    catch {
+        try {
+            file = join(realpathSync(dirname(databaseFile)), basename(databaseFile));
+        }
+        catch { /* not there yet: as given */ }
+    }
+    return join(dirname(file), INSTANCE_DIR);
+}
+const SOCKET_NAME = /^[0-9a-f]{16}\.sock$/;
+/** The longest Unix socket path the platform binds without truncating (sun_path less its NUL). */
+const SOCKET_PATH_MAX = process.platform === "darwin" ? 103 : 107;
+/** The console's own answer to a challenge over HTTP (an edge route, no sign-in: it reveals nothing). */
+export const INSTANCE_PATH = "/__instance";
+const CHALLENGE = /^[0-9a-f]{32,128}$/;
+const LINE_CAP = 4096;
+/** The record as stored: none, one this build can't read (never taken for none), or the record. */
+export function readInstanceState(store) {
+    const row = store.handle.prepare("SELECT secret, pid, port, build, socket, started_at FROM console_instance WHERE id = 1").get();
+    if (row === undefined)
+        return { state: "none" };
+    const secret = String(row["secret"]), pid = Number(row["pid"]), port = Number(row["port"]), socket = String(row["socket"]);
+    if (!/^[0-9a-f]{64}$/.test(secret) || !Number.isSafeInteger(pid) || !Number.isInteger(port) || port < 1 || port > 65535 || !SOCKET_NAME.test(socket))
+        return { state: "invalid" };
+    return { state: "ok", record: { secret, pid, port, build: String(row["build"]), socket, startedAt: String(row["started_at"]) } };
+}
+export function readInstance(store) {
+    const read = readInstanceState(store);
+    return read.state === "ok" ? read.record : null;
+}
+/** A stopping console forgets itself — only its own record, never a newer start's. */
+export function clearInstance(store, secret) {
+    store.handle.prepare("DELETE FROM console_instance WHERE id = 1 AND secret = ?").run(secret);
+}
+export const socketProof = (secret, challenge) => createHmac("sha256", secret).update(`socket:${challenge}`).digest("hex");
+export const httpProof = (secret, challenge, address, port) => createHmac("sha256", secret).update(`http:${challenge} ${address} ${port}`).digest("hex");
+const PROOF = /^[0-9a-f]{64}$/;
+/** Constant-time comparison of two proofs, each first required to be exactly 64 hex characters. */
+const same = (a, b) => typeof a === "string" && PROOF.test(a) && PROOF.test(b) && timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+/** The HTTP answer: bound to the address and port THIS connection was received on, as the console saw them. */
+export function instanceHttpAnswer(secret, challenge, local) {
+    if (challenge === null || !CHALLENGE.test(challenge) || local.address === undefined || local.port === undefined)
+        return { status: 400, body: JSON.stringify({ error: "challenge" }) };
+    return { status: 200, body: JSON.stringify({ proof: httpProof(secret, challenge, local.address, local.port) }) };
+}
+/**
+ * The run directory must be private to this user: a real, canonical directory owned by this user with no access for
+ * anyone else (0700), inside a canonical directory owned by this user that nobody else can write. Checked before any
+ * change is made, and before connecting or binding.
+ */
+export function runDirProblem(dir, uid = process.getuid?.() ?? -1, mustExist = true) {
+    const parent = dirname(dir);
+    let above;
+    try {
+        above = lstatSync(parent);
+    }
+    catch {
+        return `${parent} doesn't exist`;
+    }
+    try {
+        if (realpathSync(parent) !== parent)
+            return `${parent} isn't its own real path`;
+    }
+    catch {
+        return `${parent} doesn't exist`;
+    }
+    if (!above.isDirectory())
+        return `${parent} isn't a directory`;
+    if (uid >= 0 && above.uid !== uid)
+        return `${parent} belongs to another user`;
+    if ((above.mode & 0o022) !== 0)
+        return `${parent} can be written by other users`;
+    let info;
+    try {
+        info = lstatSync(dir);
+    }
+    catch {
+        return mustExist ? `${dir} doesn't exist` : null;
+    }
+    if (!info.isDirectory())
+        return `${dir} isn't a directory`;
+    if (uid >= 0 && info.uid !== uid)
+        return `${dir} belongs to another user`;
+    try {
+        lstatSync(join(dir, ".git"));
+        return `${dir} holds a repository, not Toolroll's sockets`;
+    }
+    catch { /* as it should be */ }
+    if ((info.mode & 0o077) !== 0)
+        return `${dir} is open to other users — Toolroll uses it only when it is yours alone (chmod 700)`;
+    return null;
+}
+/** A socket path that binds exactly (no truncation), named as a console names its own. */
+export function socketPathProblem(path) {
+    if (!SOCKET_NAME.test(basename(path)))
+        return `${path} isn't a console socket`;
+    if (Buffer.byteLength(path) > SOCKET_PATH_MAX)
+        return `${path} is too long for a socket here`;
+    return null;
+}
+/**
+ * `up`: the run directory, made 0700 if it isn't there. An existing one is used only as it is (never chmodded): one
+ * that isn't private to this user is refused. Everything is checked before anything is created.
+ */
+export function prepareRunDir(dir, uid = process.getuid?.() ?? -1) {
+    const before = runDirProblem(dir, uid, false);
+    if (before !== null)
+        return before;
+    try {
+        mkdirSync(dir, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            return `${dir} couldn't be made`;
+    }
+    return runDirProblem(dir, uid, true);
+}
+/** Ask a socket one question; null when nobody is listening (or it said nothing usable in time). */
+export function askSocket(socketPath, request, timeoutMs = 2_000, connect = path => createConnection(path)) {
+    return new Promise(resolve => {
+        let settled = false, buffer = "";
+        const done = (value) => { if (settled)
+            return; settled = true; clearTimeout(timer); socket.destroy(); resolve(value); };
+        const socket = connect(socketPath);
+        const timer = setTimeout(() => done({ none: "no-answer" }), timeoutMs);
+        socket.setEncoding("utf8");
+        socket.on("error", (error) => done({ none: error.code === "ECONNREFUSED" || error.code === "ENOENT" ? "no-listener" : "no-answer" }));
+        socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+        socket.on("data", chunk => {
+            buffer += chunk;
+            if (buffer.length > LINE_CAP)
+                return done({ none: "no-answer" });
+            const end = buffer.indexOf("\n");
+            if (end < 0)
+                return;
+            try {
+                const parsed = JSON.parse(buffer.slice(0, end));
+                done(parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? { answer: parsed } : { none: "no-answer" });
+            }
+            catch {
+                done({ none: "no-answer" });
+            }
+        });
+        socket.on("end", () => done({ none: "no-answer" }));
+    });
+}
+/**
+ * The console's discovery socket: one line in, one line out. `hello` (with a challenge) answers the public facts and
+ * the socket proof; every other verb is refused. It reads nothing else and changes nothing. Bound under a fresh name
+ * no other process has, so it never clears or replaces anything; its own listener removes it on close.
+ */
+export async function openInstanceSocket(databaseFile, facts, secret) {
+    const dir = instanceRunDir(databaseFile);
+    const problem = prepareRunDir(dir);
+    if (problem !== null)
+        return { ok: false, problem };
+    const name = `${randomBytes(8).toString("hex")}.sock`, socketPath = join(dir, name);
+    const pathProblem = socketPathProblem(socketPath);
+    if (pathProblem !== null)
+        return { ok: false, problem: pathProblem };
+    const server = createServer(socket => {
+        let buffer = "";
+        socket.setEncoding("utf8");
+        socket.setTimeout(5_000, () => socket.destroy());
+        const reply = (body) => { socket.end(`${JSON.stringify(body)}\n`); };
+        socket.on("error", () => socket.destroy());
+        socket.on("data", chunk => {
+            buffer += chunk;
+            if (buffer.length > LINE_CAP)
+                return void socket.destroy();
+            const end = buffer.indexOf("\n");
+            if (end < 0)
+                return;
+            let asked;
+            try {
+                asked = JSON.parse(buffer.slice(0, end));
+            }
+            catch {
+                return reply({ error: "refused" });
+            }
+            const verb = asked !== null && typeof asked === "object" ? asked.verb : undefined;
+            const challenge = asked !== null && typeof asked === "object" ? asked.challenge : undefined;
+            const key = secret();
+            if (verb !== "hello" || typeof challenge !== "string" || !CHALLENGE.test(challenge) || key === null)
+                return reply({ error: "refused" });
+            reply({ ...facts, proof: socketProof(key, challenge) });
+        });
+    });
+    // A Unix bind never replaces an existing path (EADDRINUSE).
+    const listening = await new Promise(resolve => { server.once("error", () => resolve(false)); server.listen(socketPath, () => resolve(true)); });
+    if (!listening)
+        return { ok: false, problem: `couldn't listen on ${socketPath}` };
+    return { ok: true, name, close: () => { server.close(); } };
+}
+/**
+ * A record's console: "live" (its socket answers a fresh challenge with the record's secret and pid), "gone" (nobody
+ * is listening on its socket, or the socket isn't there), or "unknown" (anything else: slow, malformed, a wrong proof).
+ * Only "gone" lets another start take the record.
+ */
+export async function recordLiveness(databaseFile, record, ask = askSocket) {
+    const socketPath = join(instanceRunDir(databaseFile), record.socket);
+    if (socketPathProblem(socketPath) !== null)
+        return "unknown";
+    const challenge = randomBytes(32).toString("hex");
+    const asked = await ask(socketPath, { verb: "hello", challenge }, 5_000);
+    if ("none" in asked)
+        return asked.none === "no-listener" ? "gone" : "unknown";
+    return asked.answer["pid"] === record.pid && same(asked.answer["proof"], socketProof(record.secret, challenge)) ? "live" : "unknown";
+}
+/**
+ * `up` claims the record for its socket — unless a live console already holds it (another start on the same
+ * database, by any spelling of its path). The write is a compare-and-set on the record it checked: two starts racing
+ * can't both win. Null: not claimed (this console runs, but `toolroll` won't attach to it).
+ */
+export async function claimInstance(store, databaseFile, facts, now, liveness = record => recordLiveness(databaseFile, record)) {
+    const rawSecret = () => { const row = store.handle.prepare("SELECT secret FROM console_instance WHERE id = 1").get(); return row === undefined ? null : String(row["secret"]); };
+    const checked = rawSecret();
+    // Taken only from nobody, or from a console confirmed gone: never on a check that merely failed, and never over a
+    // record this build can't read.
+    const current = readInstanceState(store);
+    if (current.state === "invalid")
+        return null;
+    if (current.state === "ok" && await liveness(current.record) !== "gone")
+        return null;
+    const secret = randomBytes(32).toString("hex");
+    return store.transact(() => {
+        // Exactly the record that was checked (or none): anything else is another start's newer claim.
+        if (rawSecret() !== checked)
+            return null;
+        store.handle.prepare("INSERT INTO console_instance (id, secret, pid, port, build, socket, started_at) VALUES (1, ?, ?, ?, ?, ?, ?) ON CONFLICT (id) DO UPDATE SET secret = excluded.secret, pid = excluded.pid, port = excluded.port, build = excluded.build, socket = excluded.socket, started_at = excluded.started_at")
+            .run(secret, facts.pid, facts.port, facts.build, facts.socket, now.toISOString());
+        return secret;
+    });
+}
+/**
+ * Prove the console this installation's database names is live, on both channels, before anything is shown or
+ * opened. "none": no console runs (no record, or nobody on the socket); "refused": something answers that can't
+ * prove it is the console (or a different build) — the person restarts it.
+ */
+export async function proveLiveConsole(databaseFile, store, build, seams = {}) {
+    const restart = "stop it and run `toolroll up` again";
+    // No record: nothing is running here (a console that couldn't claim one isn't offered). One this build can't read
+    // isn't "nothing": it is refused.
+    const read = readInstanceState(store);
+    if (read.state === "none")
+        return { ok: false, state: "none", message: "no console is running" };
+    if (read.state === "invalid")
+        return { ok: false, state: "refused", message: `the console's record can't be read — ${restart}` };
+    const record = read.record;
+    const dir = instanceRunDir(databaseFile);
+    const problem = runDirProblem(dir) ?? socketPathProblem(join(dir, record.socket));
+    if (problem !== null)
+        return { ok: false, state: "refused", message: `the console's socket can't be trusted: ${problem}` };
+    const socketPath = join(dir, record.socket);
+    try {
+        const socket = lstatSync(socketPath);
+        if (!socket.isSocket() || (process.getuid !== undefined && socket.uid !== process.getuid()))
+            return { ok: false, state: "refused", message: `the console's socket can't be trusted: ${socketPath} isn't this user's socket` };
+    }
+    catch (error) {
+        // Only "not there" means nothing is running; a socket the system won't show can't be checked.
+        if (error.code === "ENOENT")
+            return { ok: false, state: "none", message: "no console is running" };
+        return { ok: false, state: "refused", message: `the console's socket can't be checked — ${restart}` };
+    }
+    const challenge = seams.challenge ?? (() => randomBytes(32).toString("hex"));
+    const first = challenge();
+    const asked = await (seams.ask ?? askSocket)(socketPath, { verb: "hello", challenge: first });
+    if ("none" in asked) {
+        // Stale (a console that died): nobody is listening, so nothing is running. Discovery removes nothing.
+        if (asked.none === "no-listener")
+            return { ok: false, state: "none", message: "no console is running" };
+        return { ok: false, state: "refused", message: `the console's socket didn't answer — ${restart}` };
+    }
+    const hello = asked.answer;
+    if (hello["build"] !== record.build || hello["build"] !== build) {
+        return { ok: false, state: "refused", message: `the running console is a different build (${String(hello["build"] ?? "unknown")}, this is ${build}) — ${restart}` };
+    }
+    if (hello["pid"] !== record.pid || hello["port"] !== record.port || !same(hello["proof"], socketProof(record.secret, first))) {
+        return { ok: false, state: "refused", message: `the console on the socket couldn't prove it's this installation's — ${restart}` };
+    }
+    const second = challenge();
+    let body;
+    try {
+        const answer = await (seams.fetch ?? fetch)(`http://127.0.0.1:${record.port}${INSTANCE_PATH}?c=${second}`, { redirect: "manual", signal: AbortSignal.timeout(3_000) });
+        body = answer.status === 200 ? await answer.json() : null;
+    }
+    catch {
+        body = null;
+    }
+    const proof = body !== null && typeof body === "object" ? body.proof : undefined;
+    if (!same(proof, httpProof(record.secret, second, "127.0.0.1", record.port))) {
+        return { ok: false, state: "refused", message: `the address 127.0.0.1:${record.port} couldn't prove it's the console — ${restart}` };
+    }
+    return { ok: true, url: `http://127.0.0.1:${record.port}`, port: record.port, pid: record.pid, build: record.build };
+}

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

@@ -85,6 +85,20 @@ export declare const chatActionRequestSchemas: {
         repo: z.ZodString;
         starter: z.ZodString;
     }, z.core.$strict>;
+    readonly sweep_cancel_rest: z.ZodObject<{
+        sweep: z.ZodInt;
+    }, z.core.$strict>;
+    readonly sweep_file: z.ZodObject<{
+        repo: z.ZodString;
+        title: z.ZodString;
+        brief: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            item: z.ZodString;
+        }, z.core.$strict>>;
+        acceptance: z.ZodArray<z.ZodUnknown>;
+        maxParallel: z.ZodNumber;
+    }, z.core.$strict>;
     readonly flow_edit: z.ZodObject<{
         flow: z.ZodInt;
         name: z.ZodOptional<z.ZodString>;
@@ -309,6 +323,8 @@ export declare const sharedActionSchema: z.ZodObject<{
         subagent_state: "subagent_state";
         subagent_tools: "subagent_tools";
         subagent_undo: "subagent_undo";
+        sweep_cancel_rest: "sweep_cancel_rest";
+        sweep_file: "sweep_file";
         task_cancel: "task_cancel";
         task_resume: "task_resume";
         tool_add: "tool_add";

package/dist/contracts/chat-actions.js

@@ -41,6 +41,10 @@ export const chatActionRequestSchemas = {
     tool_remove: z.strictObject({ repo: words, name: words }),
     flow_create: z.strictObject({ repo: words, name: words, definition: nested, trigger: nested.optional() }),
     flow_starter: z.strictObject({ repo: words, starter: words }),
+    // Lead fan-out (docs/plans/lead-fan-out.md): N tasks under one brief, one yes.
+    sweep_cancel_rest: z.strictObject({ sweep: id }),
+    sweep_file: z.strictObject({ repo: words, title: words, brief: words, items: z.array(z.strictObject({ title: words, item: words })).min(2).max(20),
+        acceptance: z.array(z.unknown()).min(1), maxParallel: z.number().int().min(1).max(8) }),
     flow_edit: z.strictObject({ flow: id, name: words.optional(), definition: nested.optional() }),
     flow_card_add: z.strictObject({ flow: id, title: words, description: z.unknown().optional(), zone: words.optional() }),
     flow_card_move: z.strictObject({ card: id, zone: words }),

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

@@ -31,6 +31,15 @@ export declare const chatContentShape: {
     }, z.core.$strict>>;
     task: z.ZodOptional<z.ZodString>;
     run: z.ZodOptional<z.ZodInt>;
+    /** A notice its person's watch may hold at the final fence (cockpit §3): set at planning only for a kind a watch
+     * can hold. Absent: never held (a security alert, the digest, anything unmarked). */
+    watch: z.ZodOptional<z.ZodLiteral<true>>;
+    /** Every task (and agent) a `watch` part covers, when it covers more than one: it is held only while its person is
+     * watching every one of them. */
+    subjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodNullable<z.ZodInt>;
+        run: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>>;
     edit: z.ZodOptional<z.ZodString>;
     phase: z.ZodOptional<z.ZodLiteral<"armed">>;
     link: z.ZodOptional<z.ZodObject<{
@@ -123,6 +132,11 @@ export declare const chatContentSchema: z.ZodObject<{
     }, z.core.$strict>>;
     task: z.ZodOptional<z.ZodString>;
     run: z.ZodOptional<z.ZodInt>;
+    watch: z.ZodOptional<z.ZodLiteral<true>>;
+    subjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodNullable<z.ZodInt>;
+        run: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>>;
     edit: z.ZodOptional<z.ZodString>;
     phase: z.ZodOptional<z.ZodLiteral<"armed">>;
     link: z.ZodOptional<z.ZodObject<{
@@ -205,6 +219,11 @@ export declare const savedChatPartSchema: z.ZodObject<{
     }, z.core.$strict>>;
     task: z.ZodOptional<z.ZodString>;
     run: z.ZodOptional<z.ZodInt>;
+    watch: z.ZodOptional<z.ZodLiteral<true>>;
+    subjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodNullable<z.ZodInt>;
+        run: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>>;
     edit: z.ZodOptional<z.ZodString>;
     phase: z.ZodOptional<z.ZodLiteral<"armed">>;
     link: z.ZodOptional<z.ZodObject<{

package/dist/contracts/chat-content.js

@@ -26,6 +26,12 @@ export const chatContentShape = {
     shot: z.strictObject({ follows: z.int().nullable() }).optional(),
     task: z.string().optional(),
     run: z.int().optional(),
+    /** A notice its person's watch may hold at the final fence (cockpit §3): set at planning only for a kind a watch
+     * can hold. Absent: never held (a security alert, the digest, anything unmarked). */
+    watch: z.literal(true).optional(),
+    /** Every task (and agent) a `watch` part covers, when it covers more than one: it is held only while its person is
+     * watching every one of them. */
+    subjects: z.array(z.strictObject({ ref: z.int().nullable(), run: z.int().nullable() })).max(100).optional(),
     edit: z.string().optional(),
     phase: z.literal("armed").optional(),
     link: link.optional(),

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

@@ -66,16 +66,23 @@ export declare const CONSOLE_FORMS: {
     readonly projectCeiling: FormContract<"repo">;
     readonly demo: FormContract<"message" | "note">;
     readonly updatesDismiss: FormContract<"quiet" | "return" | "version">;
+    readonly forgetPassword: FormContract<"return">;
+    readonly runReveal: FormContract<"return">;
     readonly updatesChecks: FormContract<"check">;
     readonly code: FormContract<"acceptance" | "answers" | "base" | "candidate" | "decision" | "goal" | "model" | "password" | "prompt" | "repo" | "requestId" | "title" | "visual" | `question:${string}`>;
+    readonly sweep: FormContract<"confirm" | "snapshot">;
+    readonly passwordless: FormContract<"action" | "password">;
+    readonly term: FormContract<"password" | "program" | "repo">;
     readonly skillsRevise: FormContract<"feedback" | "nonce" | "repo" | "run">;
     readonly skillsChange: FormContract<"action" | "content" | "files" | "identity" | "method" | "nonce" | "repo" | "restore" | "revision" | "sample" | "sha" | "url">;
     readonly kit: FormContract<"repo">;
     readonly subagents: FormContract<"choice" | "dailyTurns" | "id" | "manager" | "model" | "name" | "note" | "op" | "repo" | "schedule" | "soul" | "state" | "template" | "text" | "tool" | `field.${string}` | `over.${string}` | `undo.${string}` | `use.${string}`>;
     readonly galleryUse: FormContract<string>;
-    readonly flows: FormContract<"about" | "address" | "answers" | "approve" | "body" | "budget" | "choice" | "confirm" | "days" | "decision" | "definition" | "description" | "document" | "draft" | "entry" | "file" | "include" | "key" | "label" | "language" | "name" | "note" | "owner" | "password" | "previewed" | "remove" | "repo" | "revision" | "runs" | "schedules" | "secret" | "stage" | "template" | "timeoutMinutes" | "title" | "trigger" | "url" | "value" | "watching" | `param.${string}`>;
+    readonly flows: FormContract<"about" | "address" | "answers" | "approve" | "body" | "budget" | "choice" | "confirm" | "days" | "decision" | "definition" | "description" | "document" | "draft" | "entry" | "file" | "include" | "key" | "label" | "language" | "name" | "note" | "owner" | "password" | "previewed" | "project" | "remove" | "repo" | "revision" | "runs" | "schedules" | "secret" | "sender" | "stage" | "team" | "template" | "timeoutMinutes" | "title" | "trigger" | "url" | "value" | "watching" | `param.${string}`>;
     readonly spendBudget: FormContract<"action" | "password" | "stop" | "target" | "usd">;
     readonly projectConcurrency: FormContract<"concurrency" | "repo">;
+    readonly projectLiveView: FormContract<"act" | "nonce" | "password" | "repo">;
+    readonly projectNetwork: FormContract<"hosts" | "local" | "mode" | "password" | "repo">;
     readonly projectDelete: FormContract<"name" | "password" | "repo" | "step">;
     readonly policy: FormContract<"ceiling" | "models" | "password" | "provider" | "tools">;
     readonly approval: FormContract<"not_requester" | "password" | "paths" | "protect" | "repo">;
@@ -144,6 +151,7 @@ export declare const CONSOLE_FORMS: {
     readonly leadFollow: FormContract<"enabled" | "return">;
     readonly leadEnd: FormContract<"return">;
     readonly leadStop: FormContract<"return" | "turn">;
+    readonly leadQueuedRemove: FormContract<"return">;
     readonly leadProposal: FormContract<"confirm" | "nonce" | "return" | "token">;
     readonly coordinatorProposal: FormContract<"confirm" | "return">;
     readonly chat: FormContract<"message" | "mode" | "project" | "request" | "request-session" | "result" | "task" | "token">;
@@ -156,7 +164,7 @@ export declare const CONSOLE_FORMS: {
     readonly revise: FormContract<"batch" | "return" | "source">;
     readonly followUp: FormContract<"level" | "return">;
     readonly resolveIncident: FormContract<"return">;
-    readonly taskSteer: FormContract<"note" | "return" | "run">;
+    readonly taskSteer: FormContract<"after" | "key" | "note" | "request" | "return" | "run">;
     readonly taskReply: FormContract<"answer" | "question">;
     readonly taskHold: FormContract<"reason">;
     readonly taskBlock: FormContract<"on">;
@@ -170,11 +178,11 @@ export declare const CONSOLE_FORMS: {
     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 taskApprove: FormContract<"digest" | "nonce" | "return" | "token">;
+    readonly taskApprove: FormContract<"digest" | "nonce" | "rebuild" | "return" | "token">;
     readonly taskAcceptProof: FormContract<"note" | "return" | "run">;
     readonly taskComplete: FormContract<"accept" | "note" | "publish" | "receipt" | "return" | "run">;
     readonly taskStop: FormContract<"return" | "run">;
-    readonly taskPause: FormContract<"mode" | "note" | "request" | "return" | "run">;
+    readonly taskPause: FormContract<"key" | "mode" | "note" | "request" | "return" | "run">;
     readonly taskResume: FormContract<"nonce" | "return" | "run" | "token">;
 };
 export type ConsoleFormName = keyof typeof CONSOLE_FORMS;

package/dist/contracts/console-api.js

@@ -75,16 +75,23 @@ export const CONSOLE_FORMS = {
     projectCeiling: formContract("POST (project ceiling)", ["repo"]),
     demo: formContract("POST /chat/demo/ask, /chat/demo/<id>/approve|change|revise|complete", ["message", "note"]),
     updatesDismiss: formContract("POST /settings/updates/dismiss", ["version", "quiet", "return"]),
+    forgetPassword: formContract("POST /session/forget-password", ["return"]),
+    runReveal: formContract("POST /r/<run>/reveal", ["return"]),
     updatesChecks: formContract("POST /settings/updates/checks", ["check"]),
     code: formContract("POST /code, /code/start, /code/<session>/<act>, /code/<anything else>", ["repo", "password", "title", "model", "prompt", "requestId", "base", "candidate", "goal", "acceptance", "visual", "decision", "answers"], { prefixes: ["question:"] }),
+    sweep: formContract("POST /sweeps/<sweep>/cancel-rest", ["confirm", "snapshot"]),
+    passwordless: formContract("POST /settings/passwordless", ["action", "password"]),
+    term: formContract("POST /term/start, /term/<terminal>/close, /term/<terminal>/remove", ["repo", "program", "password"]),
     skillsRevise: formContract("POST /settings/skills/revise", ["run", "repo", "feedback", "nonce"]),
     skillsChange: formContract("POST /settings/skills/import, /settings/skills/change", ["repo", "identity", "revision", "method", "content", "files", "url", "action", "sha", "sample", "nonce", "restore"]),
     kit: formContract("POST /kits/<kit>/<act>", ["repo"]),
     subagents: formContract("POST /settings/lead/subagents/new, /settings/lead/subagents/<id>/<part>, /settings/lead/subagents/questions/<id>/answer", ["choice", "text", "repo", "template", "name", "soul", "op", "id", "schedule", "tool", "state", "note", "model", "dailyTurns", "manager"], { prefixes: ["use.", "undo.", "field.", "over."] }),
     galleryUse: formContract("POST /flows/new/<template>", ["repo", "send-result", "name", "intent", "previewed"], { dynamic: true }),
-    flows: formContract("POST /flows/new, /flows/example, /flows/import, /flows/<id>/<act>, /flows/<id>/cards/<card>/<act>, /flows/<id>/triggers/<trigger>/<act>", ["repo", "document", "url", "confirm", "previewed", "template", "name", "answers", "password", "secret", "trigger", "approve", "remove", "about", "body", "timeoutMinutes", "language", "file", "address", "key", "definition", "owner", "revision", "value", "title", "description", "stage", "decision", "note", "draft", "choice", "entry", "label", "watching", "days", "budget", "runs", "include", "schedules"], { prefixes: ["param."] }),
+    flows: formContract("POST /flows/new, /flows/example, /flows/import, /flows/<id>/<act>, /flows/<id>/cards/<card>/<act>, /flows/<id>/triggers/<trigger>/<act>", ["repo", "document", "url", "confirm", "previewed", "template", "name", "answers", "password", "secret", "sender", "project", "team", "trigger", "approve", "remove", "about", "body", "timeoutMinutes", "language", "file", "address", "key", "definition", "owner", "revision", "value", "title", "description", "stage", "decision", "note", "draft", "choice", "entry", "label", "watching", "days", "budget", "runs", "include", "schedules"], { prefixes: ["param."] }),
     spendBudget: formContract("POST /spend/budget", ["password", "target", "action", "usd", "stop"]),
     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"]),
     projectDelete: formContract("POST /settings/project/delete", ["repo", "name", "step", "password"]),
     policy: formContract("POST /settings/policy", ["password", "provider", "models", "tools", "ceiling"]),
     approval: formContract("POST /settings/approval", ["repo", "password", "protect", "paths", "not_requester"]),
@@ -153,6 +160,7 @@ export const CONSOLE_FORMS = {
     leadFollow: formContract("POST /chat/mate/follow", ["enabled", "return"]),
     leadEnd: formContract("POST /chat/mate/end", ["return"]),
     leadStop: formContract("POST /chat/mate/stop", ["return", "turn"]),
+    leadQueuedRemove: formContract("POST /chat/queued/<message>/remove", ["return"]),
     leadProposal: formContract("POST /chat/proposal/<id>/confirm|dismiss", ["return", "nonce", "confirm", "token"]),
     coordinatorProposal: formContract("POST /proposals/<id>/confirm|dismiss", ["return", "confirm"]),
     chat: formContract("POST /chat", ["task", "project", "result", "mode", "request", "request-session", "message", "token"]),
@@ -167,7 +175,7 @@ export const CONSOLE_FORMS = {
     followUp: formContract("POST /r/<run>/checks|add-tests", ["return", "level"]),
     resolveIncident: formContract("POST /i/<id>/resolve", ["return"]),
     // A task's verbs (/t/<task>/<verb>), one body each.
-    taskSteer: formContract("POST /t/<task>/steer", ["note", "return", "run"]),
+    taskSteer: formContract("POST /t/<task>/steer", ["note", "return", "run", "key", "after", "request"]),
     taskReply: formContract("POST /t/<task>/reply", ["question", "answer"]),
     taskHold: formContract("POST /t/<task>/hold", ["reason"]),
     taskBlock: formContract("POST /t/<task>/block|unblock", ["on"]),
@@ -181,13 +189,13 @@ export const CONSOLE_FORMS = {
     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"]),
-    taskApprove: formContract("POST /t/<task>/approve", ["return", "digest", "token", "nonce"]),
+    taskApprove: formContract("POST /t/<task>/approve", ["return", "digest", "token", "nonce", "rebuild"]),
     taskAcceptProof: formContract("POST /t/<task>/accept-proof", ["run", "note", "return"]),
     taskComplete: formContract("POST /t/<task>/complete", ["receipt", "run", "accept", "note", "publish", "return"]),
     taskStop: formContract("POST /t/<task>/stop", ["run", "return"]),
     // Pause, or Pause and steer when a note rides along, or Resume (mode=resume): the exact run shown, and the page's own
     // request id.
-    taskPause: formContract("POST /t/<task>/pause", ["run", "request", "note", "mode", "return"]),
+    taskPause: formContract("POST /t/<task>/pause", ["run", "request", "note", "mode", "return", "key"]),
     taskResume: formContract("POST /t/<task>/resume|resume-arm", ["run", "token", "nonce", "return"]),
 };
 /** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */

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

@@ -29,6 +29,10 @@ export declare const flowCardSchema: z.ZodObject<{
     outputs: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
     attached: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
     createdBy: z.ZodString;
+    createdKind: z.ZodEnum<{
+        automation: "automation";
+        person: "person";
+    }>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     owner: z.ZodNullable<z.ZodString>;

package/dist/contracts/flow-card.js

@@ -30,6 +30,9 @@ export const flowCardSchema = z.strictObject({
     outputs: cardOutputsSchema.shape.outputs,
     attached: cardOutputsSchema.shape.attached,
     createdBy: z.string(),
+    /** v126: whether a person or an automation (a delivery, a poll, a schedule, a public form) made it. Decided where it
+     * was made, never read from its label: filing passes it on as the requester's kind. */
+    createdKind: z.enum(["person", "automation"]),
     createdAt: z.string(),
     updatedAt: z.string(),
     owner: z.string().nullable(),