toolroll 0.9.60 → 0.9.61

package/dist/server/pages.js

@@ -21,7 +21,8 @@ import { run as execRun } from "../exec.js";
 import { computeGaps } from "../gaps.js";
 import { LEDGER_CSV_HEADER, ledgerCsvRows } from "../ledger-csv.js";
 import { ledgerBody } from "../ledger-view.js";
-import { readLiveWindow } from "../live.js";
+import { agentRowOf, agentsBoardOf, agentFactsFor, sealedDiffOf } from "../agents-board.js";
+import { markAgentSeen } from "../agent-board.js";
 import { prometheusMetrics } from "../metrics.js";
 import { readMonitoring } from "../monitoring-settings.js";
 import { targetOf } from "../monitoring.js";
@@ -374,42 +375,64 @@ export function createPagesHandlers(runtime) {
             now,
         }));
     }
-    // The multiplexer in the console (peek): one pane per live run the
-    // ceiling admits, each fed by the run page's own transcript poller
-    // (the byte-offset JSON protocol — text into textContent, never
-    // markup). The pane SET is re-checked on a slow cadence; when it
-    // changes the page reloads rather than swapping pollers mid-flight.
+    // Peek became the Agents board: one place to check on every running agent (agents-board.ts).
     async function peekPage(ctx) {
-        const { url, response, project } = ctx;
-        const live = store.liveRuns(clock()).filter(run => runVisible(run));
-        if (url.searchParams.get("fragment") === "1") {
-            return respond(response, 200, "application/json", JSON.stringify({ runs: live.map(run => run.id) }));
-        }
+        return redirect(ctx.response, "/agents");
+    }
+    /** What the board says after a Reply or a steer, in fixed words (never text from the address). */
+    const AGENT_SAID = {
+        replied: { tone: "info", text: "Reply sent. The agent reads it at its next check." },
+        steered: { tone: "info", text: "Note sent. The agent reads it at its next check." },
+        "reply-closed": { tone: "error", text: "That question was already answered." },
+        "reply-stale": { tone: "error", text: "This attempt ended before your reply, so nothing was sent." },
+        "reply-invalid": { tone: "error", text: "Write a reply of up to 1,500 characters." },
+    };
+    // The Agents board (one place to check on running agents): rows by state, and the opened agent's live view.
+    async function agentsPage(ctx) {
+        const { url, who, response, project } = ctx;
         const now = clock();
-        const panes = live.map(run => {
-            const window = options.localRunner === undefined ? null : readLiveWindow(evidenceRoot, run.id, 0);
-            const tail = window !== null && window.ok ? window.text.split("\n").filter(one => one !== "").slice(-40).join("\n") : "";
-            const stage = run.phase !== null ? run.phase.replace(/-/g, " ") : run.providerStartedAt === null ? "preparing workspace" : "the agent is working";
-            return joinHtml([
-                html `<section class="card peek-pane" data-run="${run.id}">`,
-                html `<p class="row"><a href="/r/${run.id}" class="mono">#${run.id}</a> <a href="${taskHref(run.taskId)}"><strong>${run.title}</strong></a>${projectChip(run.repo)} <span class="right meta mono">${run.runner} \u00b7 ${run.role} \u00b7 ${stage} \u00b7 ${relativeAge(run.startedAt, now)}</span></p>`,
-                options.localRunner === undefined
-                    ? html `<p class="meta">The transcript is readable on the machine that runs the worker \u2014 start the console there with <code>toolroll up</code></p>`
-                    : html `<pre class="recap plan-doc live-pane" id="live-transcript-${run.id}" data-initial-offset="0">${tail}</pre><p class="meta" id="live-transcript-${run.id}-state"></p>`,
-                html `</section>`,
-            ], "\n");
-        });
-        const script = (options.localRunner === undefined ? "" : live.map(run => transcriptScript(`/r/${run.id}`, `live-transcript-${run.id}`)).join("")) +
-            `(function(){var seen=${JSON.stringify(live.map(run => run.id))};function check(){if(document.hidden){setTimeout(check,12000);return;}` +
-            `fetch("/peek?fragment=1",{redirect:"manual",cache:"no-store"}).then(function(r){return r.ok?r.json():null;})` +
-            `.then(function(d){if(d&&Array.isArray(d.runs)&&JSON.stringify(d.runs)!==JSON.stringify(seen)){location.reload();return;}setTimeout(check,12000);})` +
-            `.catch(function(){setTimeout(check,12000);});}setTimeout(check,12000);})();`;
-        return sendScreen(response, 200, screen("peek", joinHtml([
-            html `<h1>Peek</h1>`,
-            panes.length === 0
-                ? html `<p class="meta">No agent is working right now \u2014 this page follows them the moment one starts</p>`
-                : joinHtml(panes, "\n"),
-        ], "\n"), { chrome: chromeFor(project, "runs"), functional: { script, fetches: true } }));
+        const access = workAccess();
+        const asked = url.searchParams.get("run");
+        let selected = null;
+        if (asked !== null && /^[1-9][0-9]{0,9}$/.test(asked)) {
+            const run = store.getRun(Number(asked));
+            const facts = run === null || !runVisible(run) ? null : agentFactsFor(store, run.id, access, who.name);
+            if (facts !== null) {
+                // Opening a finished agent is viewing it: it leaves this person's unread Done.
+                if (facts.outcome !== null && markAgentSeen(store, who.name, facts.runId, now))
+                    facts.seen = true;
+                const live = facts.outcome === null;
+                const sealed = live ? null : sealedDiffOf(store, evidenceRoot, facts.runId);
+                // A reply's own word first; otherwise the note that the agent asked past the questions cap.
+                const said = AGENT_SAID[url.searchParams.get("said") ?? ""] ?? (facts.questionNote === null ? null : { tone: "info", text: facts.questionNote });
+                selected = {
+                    ...agentRowOf(store, facts, now, evidenceRoot), live,
+                    question: live && facts.question !== null ? { ...facts.question, action: `${taskHref(facts.taskId)}/reply` } : null,
+                    transcript: options.localRunner === undefined ? null : `/r/${facts.runId}?fragment=transcript`,
+                    // The live look at its checkout needs this machine's runner and pool, as the run page's does.
+                    peek: live && options.localRunner !== undefined && options.poolRoot !== undefined ? `/r/${facts.runId}?fragment=peek` : null,
+                    files: (sealed?.files ?? []).slice(0, 30).map(one => ({ path: one.path, added: one.additions, removed: one.deletions })),
+                    filesMore: Math.max(0, (sealed?.fileCount ?? 0) - 30),
+                    steer: live ? { action: `${taskHref(facts.taskId)}/steer`, run: facts.runId } : null,
+                    canAct: who.role === "approver" && !store.isDemo(),
+                    taskHref: taskHref(facts.taskId),
+                    // The run's own address: a finished result opens on its result page, anything else on its record.
+                    resultHref: live ? null : `/r/${facts.runId}`,
+                    room: `agent:${facts.runId}`, said,
+                };
+            }
+        }
+        const groups = agentsBoardOf(store, now, access, who.name, evidenceRoot);
+        const view = { kind: "agents", groups, selected,
+            empty: groups.length === 0 ? "No agents in the last day. They show here the moment one starts." : null };
+        const fallback = joinHtml([
+            html `<h1>Agents</h1>`,
+            groups.length === 0 ? html `<p class="meta">${view.empty ?? ""}</p>` : joinHtml(groups.map(group => joinHtml([
+                html `<h2>${group.label}</h2>`,
+                ...group.rows.map(row => html `<p class="row"><a href="${row.href}"><strong>${row.title}</strong></a> <span class="meta">${[row.label, row.line].filter(Boolean).join(" \u00b7 ")}</span></p>`),
+            ], "\n")), "\n"),
+        ], "\n");
+        return sendScreen(response, 200, screen("Agents", fallback, { chrome: chromeFor(project, "runs"), workspace: { view } }));
     }
     async function fleetPage(ctx) {
         const { url, who, response, project } = ctx;
@@ -901,6 +924,7 @@ export function createPagesHandlers(runtime) {
         "activity": activityPage,
         "system": systemScreen,
         "peek": peekPage,
+        "agents": agentsPage,
         "fleet": fleetPage,
         "ledger.export": ledgerExport,
         "menu": menuPage,

package/dist/server/render-chat.js

@@ -570,6 +570,18 @@ export function proposalCardParts(view, inert, decision, returnTo = null) {
     else if (view.kind === "unhold") {
         what = html `<h3>Release <a href="${taskHref(task)}">${task}</a> from its hold</h3>${facts(["project", mono(repoId)])}`;
     }
+    else if (view.kind === "steer" && payload["mode"] === "pause") {
+        const taskTitle = text("taskTitle") || task;
+        what = html `<h3>Pause <a href="${taskHref(task)}">${taskTitle}</a></h3>${facts(["project", mono(repoId)])}<p class="meta proposal-disclosure">Its current turn stops and the build keeps running; its next note continues it.</p>`;
+    }
+    else if (view.kind === "steer" && payload["mode"] === "resume") {
+        const taskTitle = text("taskTitle") || task;
+        what = html `<h3>Resume <a href="${taskHref(task)}">${taskTitle}</a></h3>${facts(["project", mono(repoId)])}<p class="meta proposal-disclosure">It goes on where it stopped. No note is sent.</p>`;
+    }
+    else if (view.kind === "steer" && payload["mode"] === "pause-and-steer") {
+        const taskTitle = text("taskTitle") || task;
+        what = html `<h3>Pause <a href="${taskHref(task)}">${taskTitle}</a> and send a note</h3><p class="proposal-summary">${text("note")}</p>${facts(["project", mono(repoId)])}<p class="meta proposal-disclosure">Its current turn stops first. The task’s scope doesn’t change.</p>`;
+    }
     else if (view.kind === "steer") {
         const taskTitle = text("taskTitle") || task;
         what = html `<h3>Guidance for <a href="${taskHref(task)}">${taskTitle}</a></h3><p class="proposal-summary">${text("note")}</p>${facts(["project", mono(repoId)])}<p class="meta proposal-disclosure">A running agent reads it when it next checks for notes; otherwise the next attempt does. The task’s scope doesn’t change.</p>`;

package/dist/server/render-tasks.d.ts

@@ -264,10 +264,18 @@ export declare function taskStatusCard(status: DisplayStatus & {
     diagnostics?: WorkStatus["diagnostics"];
 }, taskId: string, dispatch: DispatchDiagnosis | null, runId: number | null, approvalAction?: boolean): Html;
 export declare function checkProgressHtml(progress: CheckProgress | null, id?: string): Html;
-export declare function taskControlDetailsHtml(control: TaskControlView, taskId: string, csrf: string, surface: "task" | "chat", inert?: boolean, stopElsewhere?: boolean): Html;
+export declare function taskControlDetailsHtml(control: TaskControlView, taskId: string, csrf: string, surface: "task" | "chat", inert?: boolean, stopElsewhere?: boolean, livePause?: LivePauseFact | null): Html;
 /** `stopElsewhere`: the Building card already carries this exact run's Stop, so the control card keeps only its details.
  * `csrf` is only a guard now: an empty one (a read-only surface) renders no forms; postForm writes the field. */
-export declare function taskControlHtml(control: TaskControlView, taskId: string, csrf: string, surface: "task" | "chat", inert?: boolean, stopElsewhere?: boolean): Html;
+/** Live steering: the Claude build that takes Pause right now, its latest pause (null: none, or it continued), and
+ * until when a paused build can wait before it ends (null: no idle limit). */
+export type LivePauseFact = {
+    run: number;
+    state: "pausing" | "paused" | null;
+    until?: string | null;
+    limitMs?: number | null;
+};
+export declare function taskControlHtml(control: TaskControlView, taskId: string, csrf: string, surface: "task" | "chat", inert?: boolean, stopElsewhere?: boolean, livePause?: LivePauseFact | null): Html;
 /** The resume confirmation (v52): the exact run restated, what resuming
  * does and does not do, the gate that would still keep work from
  * starting, and the password typed again. */
@@ -489,6 +497,8 @@ export declare function taskBodyParts(data: {
     liveRunId?: number | null;
     /** What the agent did last on that live run, and when (task-activity.ts). */
     activity?: RunActivity | null;
+    /** Live steering: the Claude build that takes Pause right now, and its latest pause (null: none, or it continued). */
+    livePause?: LivePauseFact | null;
     /** Workers that are both alive and authorized for this task's project. */
     worker?: {
         answering: number;

package/dist/server/render-tasks.js

@@ -34,7 +34,8 @@ import { runCostWords } from "../summary.js";
 import {} from "../task-control.js";
 import { assignmentStageOf, demoChecksOf, stageOfCode, stageOfDispatch, STATUS_MORE, taskStatusOf } from "../task-status.js";
 import { buildProgressOf, dispatchActionLabel, earlierAttemptsWords, receiptPublicationWords, resultStatusOf, REVIEW_TOKENS, workStatusOf } from "../workspace-ui.js";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { TEXT_LIMITS } from "../text-limits.js";
 import { isOverdue, oneLineOf, projectChip, regionScript, safePrUrl, screen, SENSITIVE_INPUT, sentenceCase, shortDigest, transcriptScript, whenTime } from "./chrome.js";
 import { steerDestinationWords, steerStandingParts } from "../steer-status.js";
 import { reviewHref, taskChatHref, taskHref } from "./http.js";
@@ -808,14 +809,26 @@ export function checkProgressHtml(progress, id = "check-progress") {
         : Object.values(progress.suites).every(one => one.state === "passed") ? "passed" : "unknown";
     return html `<p id="${id}" class="check-progress mono" data-check-progress data-final="${state}" role="status" aria-live="polite">${progress.line}</p>`;
 }
-export function taskControlDetailsHtml(control, taskId, csrf, surface, inert = false, stopElsewhere = false) {
-    const card = taskControlHtml(control, taskId, csrf, surface, inert, stopElsewhere);
+export function taskControlDetailsHtml(control, taskId, csrf, surface, inert = false, stopElsewhere = false, livePause = null) {
+    const card = taskControlHtml(control, taskId, csrf, surface, inert, stopElsewhere, livePause);
     return control.kind === "paused" || control.kind === "review-stopped" || control.kind === "stopping"
         ? html `<details id="task-control-details"><summary>${control.kind === "paused" ? "Preserved work and resume" : "Stop details"}</summary>${card}</details>` : card;
 }
-/** `stopElsewhere`: the Building card already carries this exact run's Stop, so the control card keeps only its details.
- * `csrf` is only a guard now: an empty one (a read-only surface) renders no forms; postForm writes the field. */
-export function taskControlHtml(control, taskId, csrf, surface, inert = false, stopElsewhere = false) {
+/** Pause and Pause and steer beside the task page's Stop (live steering): the same exact run, each form under its own
+ * request id so a repeated submit is the same request. Pause hides once asked; a paused build says until when it can
+ * wait and offers Resume, or the note to continue with. */
+function pauseFormsHtml(taskId, livePause) {
+    const form = (fields, button, control, extra = {}) => postForm(`${taskHref(taskId)}/pause`, html `${fields}${button}`, { attrs: { class: "inline task-control-form", "data-task-control": control }, returnTo: "task", hidden: { run: livePause.run, request: `web-${randomUUID()}`, ...extra } });
+    const paused = livePause.state === "paused";
+    const until = livePause.until ?? null, limitMs = livePause.limitMs ?? null;
+    return joinHtml([
+        paused ? html `<p class="meta" role="status" data-live-pause="paused">${until === null || limitMs === null ? "Paused." : html `Paused. It can wait until ${whenTime(until)} (${Math.max(1, Math.round(limitMs / 60_000))} min) before it ends.`}</p>` : "",
+        livePause.state === null ? form(html ``, html `<button type="submit" class="task-control-button">Pause</button>`, "pause") : "",
+        paused ? form(html ``, html `<button type="submit" class="task-control-button">Resume</button>`, "resume", { mode: "resume" }) : "",
+        form(html `<input type="text" name="note" required maxlength="${TEXT_LIMITS.note}" placeholder="${paused ? "note to continue with" : "note for the agent"}" aria-label="${paused ? "note to continue with" : "note for the agent"}">`, html `<button type="submit" class="task-control-button">${paused ? "Continue" : "Pause and steer"}</button>`, "pause-and-steer"),
+    ]);
+}
+export function taskControlHtml(control, taskId, csrf, surface, inert = false, stopElsewhere = false, livePause = null) {
     if (control.kind === "none")
         return html ``;
     const guarded = csrf !== "" && !inert;
@@ -833,6 +846,7 @@ export function taskControlHtml(control, taskId, csrf, surface, inert = false, s
         return joinHtml([
             html `<section class="card task-control" id="task-control" data-task-control="stop" data-control-run="${control.run}" aria-label="stop this attempt">`,
             html `<div class="task-control-copy"><details><summary>Stop details · ${role(control)} #${control.run}</summary><p class="meta">Stopping ends only this attempt's own processes. Its branch, uncommitted work, evidence, and decisions stay preserved; other tasks keep running.</p></details></div>`,
+            stopElsewhere || !guarded || livePause === null || livePause.run !== control.run ? "" : pauseFormsHtml(taskId, livePause),
             stopElsewhere ? "" : guarded
                 ? runForm("stop", "inline task-control-form task-stop-form", html `<button type="submit" class="danger task-control-button">Stop</button>`)
                 : html `<button type="button" class="danger task-control-button" disabled>Stop</button>`,
@@ -1894,7 +1908,7 @@ export function taskBodyParts(data) {
     const statusHtml = html `${data.assignment != null && assignmentOptions !== null ? assignmentSummaryHtml(data.assignment, assignmentOptions) : receiptLeads ? completionReceiptCard(data.completion.receipt, task.id, "task", status) : taskStatusCard(status, task.id, data.dispatch ?? null, liveRunId, approveForm !== "" && data.dispatch?.action === "approve-scope")}${checkProgressHtml(data.checkProgress ?? null)}`;
     // The exact-run control (v52), directly under the scheduler's answer:
     // the one place a person stops or resumes THIS attempt.
-    const controlHtml = taskControlDetailsHtml(data.control ?? { kind: "none" }, task.id, data.csrf, "task");
+    const controlHtml = taskControlDetailsHtml(data.control ?? { kind: "none" }, task.id, data.csrf, "task", false, false, data.livePause ?? null);
     const previousResult = data.completion?.receipt == null || receiptLeads ? null : {
         title: data.assignment != null && task.state === "done" ? "Result" : "Previous result",
         html: (completionReceiptCard(data.completion.receipt, task.id, "task", data.assignment == null ? receiptStatusOf(data.completion.receipt) : assignmentStatusOf(data.assignment), data.assignment ?? null, data.assignment == null)),
@@ -2175,6 +2189,11 @@ export function taskBodyParts(data) {
     // The Building card carries Stop for the build it describes (the same form), in place of a second card below it.
     const stop = building && data.control?.kind === "stop" && data.control.run === liveRun.id && data.csrf !== ""
         ? { action: `${taskHref(task.id)}/stop`, run: data.control.run } : null;
+    // Pause and Pause and steer sit beside that Stop, for the same run, when it is a Claude build that takes live input.
+    // Each form carries its own request id, so a repeated submit is the same request and the two never collide.
+    const pause = stop !== null && data.livePause?.run === stop.run
+        ? { action: `${taskHref(task.id)}/pause`, run: stop.run, state: data.livePause.state, requests: [`web-${randomUUID()}`, `web-${randomUUID()}`, `web-${randomUUID()}`],
+            until: data.livePause.until ?? null, limitMs: data.livePause.limitMs ?? null } : null;
     // The Building card keeps its way to the build's own record (/r/<id>), whatever act it shows.
     const record = building ? { label: `Build #${liveRun.id} record`, href: `/r/${liveRun.id}` } : null;
     const earlier = earlierStopped.length === 0 ? null : {
@@ -2204,6 +2223,7 @@ export function taskBodyParts(data) {
         // One quiet line under the step: what the agent did last, and when.
         activity: liveRun === undefined ? null : data.activity ?? null,
         stop,
+        pause,
         record,
         earlier,
         approval: fragmentString(approvalHtml),

package/dist/server/route-table.js

@@ -129,7 +129,8 @@ get("people", "people.page", "/people", { limited: "unscoped", ...free });
 get("pages", "system", "/system");
 get("tasks", "tasks", "/tasks", { limited: "collection" });
 get("tasks", "queue", "/queue");
-get("pages", "peek", "/peek");
+get("pages", "peek", "/peek", free);
+get("pages", "agents", "/agents", { limited: "unscoped", ...free });
 get("pages", "fleet", "/fleet", free);
 get("tasks", "tasks.new", "/tasks/new", { limited: "collection", ...free });
 get("tasks", "task.page", `^\\/t\\/${TASK}$`, { project: "task", limited: "resource", ...free, sample: "/t/one" });
@@ -330,6 +331,7 @@ post("tasks", "task.act.plan-edit", `^\\/t\\/${TASK}\\/plan-edit$`, { project: "
 post("tasks", "task.act.next", `^\\/t\\/${TASK}\\/next$`, { project: "task", limited: "resource", sample: "/t/one/next" });
 post("tasks", "task.act.reopen", `^\\/t\\/${TASK}\\/reopen$`, { scope: "step-up", project: "task", limited: "resource", sample: "/t/one/reopen" });
 post("tasks", "task.act.steer", `^\\/t\\/${TASK}\\/steer$`, { project: "task", limited: "resource", sample: "/t/one/steer" });
+post("tasks", "task.act.reply", `^\\/t\\/${TASK}\\/reply$`, { project: "task", limited: "resource", sample: "/t/one/reply" });
 post("tasks", "task.act.accept-proof", `^\\/t\\/${TASK}\\/accept-proof$`, { project: "task", limited: "resource", sample: "/t/one/accept-proof" });
 post("tasks", "task.act.accept-revision", `^\\/t\\/${TASK}\\/accept-revision$`, { scope: "step-up", project: "task", limited: "resource", sample: "/t/one/accept-revision" });
 post("tasks", "task.act.reject-revision", `^\\/t\\/${TASK}\\/reject-revision$`, { scope: "step-up", project: "task", limited: "resource", sample: "/t/one/reject-revision" });
@@ -339,6 +341,7 @@ post("tasks", "task.act.complete", `^\\/t\\/${TASK}\\/complete$`, { project: "ta
 post("tasks", "task.act.merge", `^\\/t\\/${TASK}\\/merge$`, { project: "task", limited: "resource", sample: "/t/one/merge", ...approver("Only an approver can merge.") });
 post("tasks", "task.act.confirm-stopped", `^\\/t\\/${TASK}\\/confirm-stopped$`, { scope: "step-up", project: "task", limited: "resource", sample: "/t/one/confirm-stopped", ...approver("Only an approver can confirm a build stopped.") });
 post("tasks", "task.act.stop", `^\\/t\\/${TASK}\\/stop$`, { project: "task", limited: "resource", sample: "/t/one/stop" });
+post("tasks", "task.act.pause", `^\\/t\\/${TASK}\\/pause$`, { project: "task", limited: "resource", sample: "/t/one/pause" });
 post("tasks", "task.act.resume-arm", `^\\/t\\/${TASK}\\/resume-arm$`, { project: "task", limited: "resource", sample: "/t/one/resume-arm" });
 post("tasks", "task.act.resume", `^\\/t\\/${TASK}\\/resume$`, { scope: "step-up", project: "task", limited: "resource", sample: "/t/one/resume" });
 for (const one of ["block", "unblock", "repair-dependency", "follow-up"])

package/dist/server/settings.js

@@ -105,6 +105,7 @@ import { removeSsoSettings, saveSsoSettings, SSO_CALLBACK, ssoChangeWords } from
 import { ssoSettingsHtml } from "../sso-ui.js";
 import { lastSweep, saveSweep, storageSweepOff } from "../storage-sweep.js";
 import { storageHtml } from "../storage-ui.js";
+import { landedSummary } from "../landed-cleanup.js";
 import { bytesWords, parseCleanup } from "../storage.js";
 import { isDigestTime, RESULT_SCREENSHOTS } from "../store.js";
 import { checkTeamsCredentials, clearTeamsCredentials, loadTeamsCredentials, saveTeamsCredentials, TeamsError } from "../teams-api.js";
@@ -398,7 +399,7 @@ ${connectionHtml(asked, connection, task)}${command === null ? "" : html `<p>On
             return refuse(response, who, 403, "An instance operator looks after storage.", "/settings");
         const plan = await checkoutPlan(store, storagePool(databaseFile), now, { manual: true });
         const sweep = { last: lastSweep(store), off: storageSweepOff() };
-        return sendScreen(response, 200, screen("Storage", html `<p><a href="/settings">Settings</a></p><h1>Storage</h1>${(storageHtml({ plan, csrf: who.session.csrf, sweep }, { said: url.searchParams.get("said"), problem: url.searchParams.get("problem") }))}`, { chrome: chromeFor(project, "settings") }));
+        return sendScreen(response, 200, screen("Storage", html `<p><a href="/settings">Settings</a></p><h1>Storage</h1>${(storageHtml({ plan, csrf: who.session.csrf, sweep, landed: landedSummary(store) }, { said: url.searchParams.get("said"), problem: url.searchParams.get("problem") }))}`, { chrome: chromeFor(project, "settings") }));
     }
     // Settings → Projects → Pull requests: one project's setup. Off, the checks run on open, so the page says
     // exactly what turning on would do, or what to fix first.

package/dist/server/task-views.js

@@ -418,6 +418,15 @@ export function createTaskViews(runtime) {
                 const found = runtime.store.runsFor(ref.id).find(one => runIsLive(one));
                 return found === undefined ? null : found.id;
             })(),
+            // Live steering: the Claude build that takes Pause right now, and where its latest pause stands.
+            livePause: (() => {
+                const run = ref === null ? null : runtime.store.liveInputRun(ref.id, now);
+                if (run === null)
+                    return null;
+                const pause = runtime.store.livePauseOf(run);
+                const until = pause?.pausedAt == null || pause.limitMs === null ? null : new Date(Date.parse(pause.pausedAt) + pause.limitMs).toISOString();
+                return { run, state: pause?.state ?? null, until, limitMs: pause?.limitMs ?? null };
+            })(),
             worker: (() => {
                 const runners = runtime.store.listRunners().filter(one => one.retiredAt === null);
                 const eligible = ref?.repo === null || ref?.repo === undefined

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[];
-};
+}>;