toolroll 0.9.59 → 0.9.61

package/dist/server/tasks.js

@@ -46,6 +46,7 @@ import { runCostWords } from "../summary.js";
 import { requestTaskStop, resumeTaskStop } from "../task-control.js";
 import { templateByName } from "../templates.js";
 import { TEXT_LIMITS } from "../text-limits.js";
+import { agentQuestion, answerAgentQuestion, markAgentSeen } from "../agent-board.js";
 import { WorkIndexCursorError, workIndexPage } from "../work-index.js";
 import { buildProgressOf, parseWorkView } from "../workspace-ui.js";
 import { requestContext } from "./request-context.js";
@@ -458,6 +459,9 @@ export function createTasksHandlers(runtime) {
             return sendScreen(response, 409, screen("Result changed", html `<h1>Result changed</h1><p>This acceptance link no longer matches the current result. Review the current task before accepting.</p><p class="refusal-back"><a class="button-link" href="/review">Review results</a></p>`, { chrome: chromeFor(project, "runs") }));
         }
         const selected = selectedRow === null ? null : reviewCockpitViewOf(selectedRow, who, now);
+        // Opening a run's own result page is viewing it: it leaves this person's unread Done on the Agents board.
+        if (wantedId !== null && selected?.run != null)
+            markAgentSeen(store, who.name, selected.run.id, now);
         // A build that delivered nothing reads Failed here, and so does a failed task's delivered result: what went wrong
         // is the card and Retry the ink act. That result may still be accepted, but only in outline, as Accept anyway, with
         // a reason.
@@ -1621,8 +1625,31 @@ export function createTasksHandlers(runtime) {
                             : "no such task";
                     return taskScreen(response, who, taskId, said, 400);
                 }
+                // From the Agents board, back to the same agent (allow-listed: a run of this task, never a URL from the form).
+                const run = Number(body.get("run") ?? "");
+                if (body.get("return") === "agents" && Number.isSafeInteger(run) && store.getRun(run)?.taskRef === ref.id)
+                    return redirect(response, `/agents?run=${run}&said=steered`);
                 return redirect(response, taskHref(taskId));
             }
+            case "reply": {
+                const body = readForm(posted, CONSOLE_FORMS.taskReply);
+                // A reply is steering, so it is a browser session's act too.
+                if (who.via !== "cookie")
+                    return refuse(response, who, 403, "replying to an agent is a browser session's act");
+                // The same gates as a pause: the route's act scope already refuses a viewer; these say why, and the demo answers nothing.
+                if (who.role !== "approver")
+                    return taskScreen(response, who, taskId, "your login can watch — replying to an agent is an approver's act", 403);
+                if (store.isDemo())
+                    return taskScreen(response, who, taskId, "the demo authorizes nothing", 403);
+                const id = Number(body.get("question") ?? "");
+                const asked = Number.isSafeInteger(id) && id > 0 ? agentQuestion(store, id) : null;
+                if (asked === null || asked.taskRef !== ref.id)
+                    return taskScreen(response, who, taskId, "that question is not on this task", 404);
+                const answered = answerAgentQuestion(store, { question: id, answer: body.get("answer") ?? "", author: who.name, at: now,
+                    file: (task, note) => store.fileSteerNote(task, verifiedAuthor(who.name), note, now) });
+                const said = answered.ok ? "replied" : answered.reason === "invalid-answer" || answered.reason === "not-saved" ? "reply-invalid" : answered.reason === "closed" ? "reply-closed" : "reply-stale";
+                return redirect(response, `/agents?run=${asked.run}&said=${said}`);
+            }
             case "hold": {
                 const body = readForm(posted, CONSOLE_FORMS.taskHold);
                 const reason = (body.get("reason") ?? "").trim() || "held from the console";
@@ -2306,6 +2333,40 @@ export function createTasksHandlers(runtime) {
                 const back = body.get("return") ?? "";
                 return redirect(response, back === "chat" ? `${taskChatHref(taskId)}#task-control` : `${taskHref(taskId)}#task-control`);
             }
+            case "pause": {
+                const body = readForm(posted, CONSOLE_FORMS.taskPause);
+                // Pause, and Pause and steer (live steering): a browser session's act, an approver's act, naming the ONE run
+                // the page showed under the page's own request id. It stops the running Claude build's turn and keeps the
+                // build; a note that rides along is filed in the same transaction and sent right after. mode=resume continues a
+                // paused build with no note. Never a stop.
+                if (who.via !== "cookie")
+                    return refuse(response, who, 403, "pausing a build is a browser session's act");
+                if (who.role !== "approver")
+                    return taskScreen(response, who, taskId, "your login can watch — pausing a build is an approver's act", 403);
+                if (store.isDemo())
+                    return taskScreen(response, who, taskId, "the demo authorizes nothing", 403);
+                const named = (body.get("run") ?? "").trim();
+                if (!/^[0-9]{1,15}$/.test(named))
+                    return taskScreen(response, who, taskId, "which build? a pause names one exact run", 400);
+                const note = (body.get("note") ?? "").trim();
+                // Resume: the paused build goes on where it stopped; no note is filed.
+                const asked = body.get("mode") === "resume"
+                    ? store.requestResume({ taskId, runId: Number(named), by: verifiedAuthor(who.name), via: "web", requestId: body.get("request") ?? "" }, now)
+                    : store.requestPause({ taskId, runId: Number(named), by: verifiedAuthor(who.name), via: "web", requestId: body.get("request") ?? "", ...(note === "" ? {} : { note }) }, now);
+                if (!asked.ok) {
+                    const words = {
+                        stale: `build #${named} has stopped taking notes — reload to see the current attempt`,
+                        "not-paused": `build #${named} isn't paused any more — reload to see where it stands`,
+                        "invalid-request": "that form was incomplete — reload and try again",
+                        duplicate: "that form was already used for another build — reload and try again",
+                        "task-finished": "this task is finished",
+                        "unknown-task": "no such task",
+                    };
+                    return taskScreen(response, who, taskId, words[asked.reason] ?? asked.detail, asked.reason === "invalid-note" ? 400 : 409);
+                }
+                const back = body.get("return") ?? "";
+                return redirect(response, back === "chat" ? `${taskChatHref(taskId)}#task-control` : `${taskHref(taskId)}#task-control`);
+            }
             case "resume-arm": {
                 const body = readForm(posted, CONSOLE_FORMS.taskResume);
                 return armTaskResume(response, who, taskId, (body.get("run") ?? "").trim(), body.get("return") === "chat" ? "chat" : "task", now);
@@ -2715,6 +2776,7 @@ export function createTasksHandlers(runtime) {
         "task.act.next": taskAct("next"),
         "task.act.reopen": taskAct("reopen"),
         "task.act.steer": taskAct("steer"),
+        "task.act.reply": taskAct("reply"),
         "task.act.accept-proof": taskAct("accept-proof"),
         "task.act.accept-revision": taskAct("accept-revision"),
         "task.act.reject-revision": taskAct("reject-revision"),
@@ -2724,6 +2786,7 @@ export function createTasksHandlers(runtime) {
         "task.act.merge": taskMerge,
         "task.act.confirm-stopped": taskConfirmStopped,
         "task.act.stop": taskAct("stop"),
+        "task.act.pause": taskAct("pause"),
         "task.act.resume-arm": taskAct("resume-arm"),
         "task.act.resume": taskAct("resume"),
         "task.act.block": taskAct("block"),

package/dist/shared-deps.d.ts

@@ -98,13 +98,18 @@ export declare function unusedShared(root: string, checkouts: readonly {
 export declare function removeShared(path: string): boolean;
 /**
  * The daily sweep: remove each copy no checkout uses and none has linked for `unusedMs` (a week), and old debris.
- * Right before a copy goes, who uses it and when it was last linked are read again; a copy a checkout picked up in
- * between stays.
+ * Right before a copy goes, who uses it, when it was last linked and whether live work uses it (`spare`,
+ * storage-sweep.ts) are read again; a copy a checkout picked up in between stays. Removal never holds the event loop.
  */
 export declare function pruneUnusedShared(root: string, checkouts: () => readonly {
     path: string;
     repo: string;
-}[], now: Date, unusedMs?: number): {
+}[], now: Date, unusedMs?: number, options?: {
+    spare?: (path: string) => boolean;
+    /** Deterministic race/failure seams; never supplied by the worker. */
+    quarantined?: (original: string, trash: string) => void | Promise<void>;
+    remove?: (path: string) => Promise<void>;
+}): Promise<{
     removed: SharedUse[];
     failed: string[];
-};
+}>;

package/dist/shared-deps.js

@@ -17,10 +17,12 @@
  * checkout links or matches; the plane's daily storage sweep removes one no checkout has used for a week.
  */
 import { createHash, randomBytes } from "node:crypto";
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
+import { rm } from "node:fs/promises";
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { markNeverIndex } from "./never-index.js";
+import { QUARANTINE_NOTE, quarantine, quarantineEntries, claimQuarantine, releaseQuarantine, restoreQuarantine, deleteQuarantine } from "./sweep-quarantine.js";
 export const DEPS_FOLDER = "deps";
 const READY = "ready.json";
 const RETIRED = "retired";
@@ -199,7 +201,11 @@ function treeDigest(nodeModules) {
 }
 /** The shared node_modules for a key, when one is ready and unchanged since it was made. A changed one is retired. */
 export function readyCopy(root, key) {
+    if (!/^[0-9a-f]{24}$/.test(key))
+        return null;
     const dir = join(root, key);
+    if (existsSync(join(dir, QUARANTINE_NOTE)))
+        return null;
     const ready = readReady(dir);
     if (ready === null || ready.key !== key || existsSync(join(dir, RETIRED)) || !existsSync(join(dir, NODE_MODULES)))
         return null;
@@ -259,12 +265,20 @@ export function linkInto(worktree, shared) {
     const at = join(worktree, NODE_MODULES);
     if (existsSync(at) || isLink(at))
         return null;
+    const root = dirname(dirname(shared)), key = basename(dirname(shared));
+    if (readyCopy(root, key) !== shared)
+        return null;
     try {
         mkdirSync(at);
+        // Publish intent before reading the copy. A sweep that renames it mid-link sees this user and restores it;
+        // if the sweep won before the intent, the final ready check fails and no broken link is handed to a run.
+        writeFileSync(join(at, LINK_NOTE), `${shared}\n`, "utf8");
+        touch(dirname(shared));
         for (const entry of readdirSync(shared, { withFileTypes: true })) {
             symlinkSync(join(shared, entry.name), join(at, entry.name), entry.isDirectory() ? (process.platform === "win32" ? "junction" : "dir") : "file");
         }
-        writeFileSync(join(at, LINK_NOTE), `${shared}\n`, "utf8");
+        if (readyCopy(root, key) !== shared)
+            throw new Error("Shared copy is no longer available");
         markNeverIndex(at);
         touch(dirname(shared));
         return "link";
@@ -272,6 +286,8 @@ export function linkInto(worktree, shared) {
     catch {
         rmSync(at, { recursive: true, force: true });
     }
+    if (readyCopy(root, key) !== shared)
+        return null;
     const cloned = process.platform === "darwin" ? spawnSync("cp", ["-c", "-R", shared, at], { timeout: 600_000 })
         : process.platform === "linux" ? spawnSync("cp", ["--reflink=always", "-R", shared, at], { timeout: 600_000 })
             : null;
@@ -396,7 +412,9 @@ export function sharedCopies(root) {
 }
 /** Which checkouts use each copy: those linking it, and those whose lockfile it was installed from. */
 export function sharedUse(root, checkouts) {
-    const copies = sharedCopies(root);
+    return useCopies(root, sharedCopies(root), checkouts);
+}
+function useCopies(root, copies, checkouts) {
     const users = new Map(copies.map(one => [one.key, new Set()]));
     for (const checkout of checkouts) {
         const linked = linkedKey(checkout.path, root);
@@ -411,7 +429,8 @@ export function sharedUse(root, checkouts) {
             continue;
         for (const copy of copies) {
             const ready = readReady(copy.dir);
-            if (!copy.retired && copy.repo === checkout.repo && ready !== null && matchesInputs(copy.dir, ready, inputs))
+            if (!copy.retired && copy.repo === checkout.repo && (ready !== null ? matchesInputs(copy.dir, ready, inputs) :
+                [inputs.digest, digestPair(inputs.lock, inputs.manifest)].includes(copy.lock)))
                 users.get(copy.key).add(checkout.path);
         }
     }
@@ -456,24 +475,81 @@ export function removeShared(path) {
 }
 /**
  * The daily sweep: remove each copy no checkout uses and none has linked for `unusedMs` (a week), and old debris.
- * Right before a copy goes, who uses it and when it was last linked are read again; a copy a checkout picked up in
- * between stays.
+ * Right before a copy goes, who uses it, when it was last linked and whether live work uses it (`spare`,
+ * storage-sweep.ts) are read again; a copy a checkout picked up in between stays. Removal never holds the event loop.
  */
-export function pruneUnusedShared(root, checkouts, now, unusedMs = SHARED_UNUSED_MS) {
+export async function pruneUnusedShared(root, checkouts, now, unusedMs = SHARED_UNUSED_MS, options = {}) {
     const stale = (one) => one.checkouts.length === 0 && now.getTime() - Date.parse(one.usedAt) > unusedMs;
     const removed = [];
     const failed = [];
+    const finish = async (trash) => {
+        try {
+            await options.quarantined?.(trash.original, trash.path);
+            let used = options.spare?.(trash.original) === true || options.spare?.(trash.path) === true;
+            const copy = trash.journal.data;
+            if (copy !== null) {
+                let usedAt = copy.usedAt;
+                try {
+                    usedAt = statSync(join(trash.path, READY)).mtime.toISOString();
+                }
+                catch { /* partially deleted trash */ }
+                const fresh = useCopies(root, [{ ...copy, dir: trash.path, usedAt }], checkouts())[0];
+                used ||= !stale(fresh);
+            }
+            if (used) {
+                if (!restoreQuarantine(trash))
+                    failed.push(trash.original);
+                return;
+            }
+            await deleteQuarantine(trash, options.remove ?? removeSharedLater);
+            if (copy !== null)
+                removed.push(copy);
+        }
+        catch {
+            failed.push(trash.original);
+        }
+        finally {
+            releaseQuarantine(trash);
+        }
+    };
+    for (const entry of quarantineEntries(root)) {
+        const claimed = claimQuarantine(entry);
+        if (claimed !== null)
+            await finish(claimed);
+    }
     for (const one of sharedUse(root, checkouts()).filter(stale)) {
+        await nextTurn();
         const fresh = sharedUse(root, checkouts()).find(other => other.key === one.key);
-        if (fresh === undefined || !stale(fresh))
+        if (fresh === undefined || !stale(fresh) || options.spare?.(fresh.dir) === true)
             continue;
-        if (removeShared(fresh.dir))
-            removed.push(fresh);
-        else
+        try {
+            const trash = quarantine(fresh.dir, fresh);
+            if (trash !== null)
+                await finish(trash);
+        }
+        catch {
             failed.push(fresh.dir);
+        }
     }
-    for (const debris of sharedDebris(root, now))
-        if (!removeShared(debris))
+    for (const debris of sharedDebris(root, now)) {
+        await nextTurn();
+        if (options.spare?.(debris) === true)
+            continue;
+        try {
+            const trash = quarantine(debris, null);
+            if (trash !== null)
+                await finish(trash);
+        }
+        catch {
             failed.push(debris);
+        }
+    }
     return { removed, failed };
 }
+const nextTurn = () => new Promise(resolve => setImmediate(resolve));
+/** removeShared without holding the event loop: chmod and rm run off it. */
+async function removeSharedLater(path) {
+    if (process.platform !== "win32")
+        await new Promise(resolve => execFile("chmod", ["-R", "u+w", path], { timeout: 120_000 }, () => resolve()));
+    await rm(path, { recursive: true, force: true });
+}

package/dist/slack-socket.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The Socket Mode client, apart from the follower so the Slack SDK loads only
+ * once Slack is set up (slack.ts imports this when it finds credentials).
+ */
+import { SocketModeClient } from "@slack/socket-mode";
+export { LogLevel } from "@slack/socket-mode";
+/** The bot and socket tokens must belong to the same app, including after reconnect. */
+export declare class ToolrollSlackSocket extends SocketModeClient {
+    expectedApp: string;
+    wrongApp: () => void;
+    protected onWebSocketMessage(data: string | ArrayBuffer, isBinary: boolean): Promise<void>;
+}

package/dist/slack-socket.js

@@ -0,0 +1,29 @@
+/**
+ * The Socket Mode client, apart from the follower so the Slack SDK loads only
+ * once Slack is set up (slack.ts imports this when it finds credentials).
+ */
+import { SocketModeClient } from "@slack/socket-mode";
+export { LogLevel } from "@slack/socket-mode";
+/** The bot and socket tokens must belong to the same app, including after reconnect. */
+export class ToolrollSlackSocket extends SocketModeClient {
+    expectedApp = "";
+    wrongApp = () => { };
+    async onWebSocketMessage(data, isBinary) {
+        let packet;
+        try {
+            packet = JSON.parse(typeof data === "string" ? data : new TextDecoder().decode(data));
+        }
+        catch {
+            return;
+        }
+        if (packet.type === "hello") {
+            const info = packet.connection_info;
+            if (info?.app_id !== this.expectedApp) {
+                this.wrongApp();
+                await this.disconnect();
+                return;
+            }
+        }
+        return super.onWebSocketMessage(data, isBinary);
+    }
+}

package/dist/slack.d.ts

@@ -1,11 +1,4 @@
-import { SocketModeClient } from "@slack/socket-mode";
 import { type SlackChatOptions } from "./slack-chat.js";
-/** The bot and socket tokens must belong to the same app, including after reconnect. */
-export declare class ToolrollSlackSocket extends SocketModeClient {
-    expectedApp: string;
-    wrongApp: () => void;
-    protected onWebSocketMessage(data: string | ArrayBuffer, isBinary: boolean): Promise<void>;
-}
 export declare function followSlack(options: Omit<SlackChatOptions, "identity" | "api" | "owner" | "current"> & {
     dir: string;
     signal: AbortSignal;

package/dist/slack.js

@@ -1,33 +1,9 @@
 /** One leased Socket Mode connection, hosted by the ordinary worker. */
 import { randomBytes } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
-import { SocketModeClient, LogLevel } from "@slack/socket-mode";
 import { loadSlackCredentials, slackApi } from "./slack-api.js";
 import { ChatState } from "./chat-delivery-state.js";
 import { receiveSlack, processSlackEvent, deliverSlackPart, planSlackNotifications, planSlackRooms, } from "./slack-chat.js";
-/** The bot and socket tokens must belong to the same app, including after reconnect. */
-export class ToolrollSlackSocket extends SocketModeClient {
-    expectedApp = "";
-    wrongApp = () => { };
-    async onWebSocketMessage(data, isBinary) {
-        let packet;
-        try {
-            packet = JSON.parse(typeof data === "string" ? data : new TextDecoder().decode(data));
-        }
-        catch {
-            return;
-        }
-        if (packet.type === "hello") {
-            const info = packet.connection_info;
-            if (info?.app_id !== this.expectedApp) {
-                this.wrongApp();
-                await this.disconnect();
-                return;
-            }
-        }
-        return super.onWebSocketMessage(data, isBinary);
-    }
-}
 export async function followSlack(options) {
     const owner = randomBytes(16).toString("hex"), state = new ChatState(options.store, "slack");
     const pause = async (ms) => {
@@ -56,6 +32,8 @@ export async function followSlack(options) {
                 state.owns(credentials.installation, owner));
         };
         const problem = (text) => state.setProblem(credentials.installation, owner, text);
+        // The SDK loads once Slack is set up, not with every command that could host the follower.
+        const { ToolrollSlackSocket, LogLevel } = await import("./slack-socket.js");
         // SDK log output can include envelopes/tokens. Only fixed status phrases are saved.
         const client = new ToolrollSlackSocket({
             appToken: credentials.appToken,

package/dist/staged-runtimes.d.ts

@@ -1,3 +1,4 @@
+import { type ProcessRow } from "./run-closeout.js";
 /** A deploy or update that never finished keeps its stage this long (it may be resumed). */
 export declare const UNFINISHED_KEEP_MS: number;
 export declare const STAGED_FOLDER = "staged-upgrades";
@@ -22,9 +23,17 @@ export type StagePlan = {
 export declare function stagedRuntimes(stateDir: string): Stage[];
 /**
  * Paths a runtime may be running from: the launchd services' definitions, every `toolroll` (or older
- * `standing-orders`) command on PATH or under nvm, this process, and `extra`.
+ * `standing-orders`) command on PATH, in the usual link folders or under nvm (a link counts by its target), this
+ * process, and `extra`.
  */
-export declare function runtimesInUse(extra?: readonly string[], home?: string, path?: string): string[];
+export declare function runtimesInUse(extra?: readonly string[], home?: string, path?: string, stateDir?: string): string[];
+/** Retain only recognized Toolroll entry scripts in candidate stages, never complete argv. ps is asked only
+ * for Node/Toolroll processes; /proc supplies NUL-separated argv on Linux. Fail closed with a fixed message,
+ * since an execFileSync exception can otherwise contain private argument text in stdout/stderr. */
+export declare function runtimeScriptPaths(stateDir: string, onlyPids?: readonly number[], observations?: {
+    census?: () => ProcessRow[];
+    argv?: (pids: readonly number[]) => string[];
+}): string[];
 /** What stays and what goes now, and why. */
 export declare function stagePlan(stateDir: string, inUse: readonly string[], now: Date): StagePlan;
 export type StagePrune = {
@@ -33,10 +42,13 @@ export type StagePrune = {
     refused: string | null;
 };
 /**
- * Remove the stages that go. Right before each goes, the plan is made again (what's in use now) and the stage must
- * still be a real folder directly in staged-upgrades.
+ * Remove the stages that go. Right before each goes, the plan is made again (what's in use now), nothing live may use
+ * it (`spare`, storage-sweep.ts) and the stage must still be a real folder directly in staged-upgrades.
  */
 export declare function pruneStagedRuntimes(stateDir: string, now: Date, options?: {
     inUse?: () => string[];
     remove?: (path: string) => void;
+    spare?: (path: string) => boolean;
+    /** Deterministic race seam, not supplied by production callers. */
+    quarantined?: (original: string, trash: string) => void;
 }): StagePrune;