toolroll 0.9.59 → 0.9.61

package/dist/operate.js

@@ -10,14 +10,18 @@ import { runBatchChecks } from "./batch-checks.js";
 import { BATCH_HINT, BATCH_WINDOW_MS, projectBatchChecks, setProjectBatchChecks } from "./batch-policy.js";
 import { buildReviewPass } from "./build-review.js";
 import { buildReviewLines, buildReviewOf } from "./review-switch.js";
+import { steerDestinationWords, steerStandingOf, steerStandingWords } from "./steer-status.js";
+import { utcMinute } from "./when-html.js";
 import { parseProtectedPaths } from "./approval-policy.js";
 import { rulesSummary } from "./approval-rules-ui.js";
 import { evidencePack, exportDay, ledgerExportChunks, standaloneEvidenceHtml } from "./evidence-pack.js";
 import { matchesOutsideCheckpoint } from "./ledger-chain.js";
 import { CLEANUP_CHOICES, bytesWords, cleanupWords, diskBytes, parseCleanup, storageReport } from "./storage.js";
 import { removeStaleTestTemp, tempRoots, testTempFolders } from "./test-temp.js";
+import { storageSweepSupervisor } from "./storage-sweep-process.js";
 import { dailyStorageSweep, lastSweep, nextSweepAt, saveSweep, storageSweepOff as storageSweepOffNow, sweepDetails, sweepWords as storageSweepWords } from "./storage-sweep.js";
 import { removeShared, sharedDepsRoot, sharedUse, unusedShared } from "./shared-deps.js";
+import { cleanLandedBacklog, gitOf, landedBacklog, reconcileLanded, BACKLOG_DAYS } from "./landed-cleanup.js";
 import { checkoutPlan, cleanCheckouts, discardCheckout, finishedCheckouts, slimKeptCheckouts, whyWords } from "./checkout-cleanup.js";
 import { closeOutCheckouts, closeOutRuns, stoppedWords } from "./run-closeout.js";
 import { MIN_DAYS, RETENTION_KINDS, countWords, dailyRetention, isRetentionKind, lastSweepAt, parsePeriod, periodLabel, periodWords, retentionPlan, sweepWords } from "./retention.js";
@@ -252,6 +256,7 @@ export const OPERATE_HELP = `toolroll — operating the queue
   toolroll task evidence <id>        the task's evidence pack as JSON (--html for a printable page; --out <file>)
   toolroll storage                   where the disk goes: database, build checkouts, releases, evidence, leftover test temp folders
   toolroll storage clean [--yes]     preview removing finished tasks' clean checkouts (their branches stay) and test temp folders older than a day; --yes removes them
+  toolroll storage clean --landed [--yes]   preview work that landed in main over a week ago: marks its results complete, removes their clean checkouts and local branches; --yes does it (instance operator)
   toolroll storage cleanup <when>    remove a finished task's clean checkout: finished|2d|7d|never (instance operator)
   toolroll storage discard <path> --yes   throw away a checkout kept for its changes; its branch stays
   toolroll integrations [--json]     which integrations work: Connected, Not set up or Broken, and what to do (--saved: no new checks)
@@ -289,7 +294,7 @@ export const OPERATE_HELP = `toolroll — operating the queue
   toolroll task add-tests <id>       file a small task to write tests for that change
   toolroll task revise <id> --feedback "requested change"
   toolroll assignment show <task>    root, current work and exact handoff
-  toolroll assignment updates        durable updates (--after <cursor>)
+  toolroll assignment updates        history of handoffs sent to people (--after <cursor>)
   toolroll assignment brief          catch up from the local database
   toolroll assignment inbox --consumer <name>  receive saved status changes
   toolroll assignment ack --consumer <name> --batch <id>  acknowledge delivery
@@ -306,9 +311,18 @@ export const OPERATE_HELP = `toolroll — operating the queue
                                         is still required); --undo puts it
                                         back in filing order
   toolroll task steer <id> --note "..."
-                                        guidance for the next attempt — it
-                                        reads the note before starting; a
-                                        running agent is not interrupted
+                                        guidance for the agent — a running
+                                        Claude build gets it in seconds,
+                                        another running build reads it when
+                                        it next checks for notes, otherwise
+                                        the next attempt does; --now pauses
+                                        the running Claude build first
+  toolroll task pause <id> [--run <id>] stop a running Claude build's
+                                        current turn and keep the build; the
+                                        next note continues it (Stop ends it)
+  toolroll task continue <id> [--run <id>]
+                                        resume a paused Claude build where it
+                                        stopped, without a note
   toolroll task assign <id> --runner <name> | --anyone
                                         reserve it for one worker (it joins
                                         the back of that worker's queue) or
@@ -597,7 +611,7 @@ Exit codes
  * (surface.ts) is tested for exact equality against them.
  */
 export const TASK_ACTIONS = [
-    "add", "list", "show", "wait", "state", "block", "unblock", "next", "steer", "assign",
+    "add", "list", "show", "wait", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign",
     "reopen", "scope", "approve", "hold", "unhold", "require", "requeue", "regate", "plan",
     "review", "accept", "repair", "route", "stop", "resume", "complete", "revise", "merge", "ask",
     "checks", "add-tests",
@@ -650,6 +664,8 @@ export const OPERATE_VALUE_FLAGS = new Set([
     "access", "projects", "overlap",
     // audit: a token by name where --token is a credential (remote).
     "token-name",
+    // task pause / task steer --now: the asker's own request id, so a repeat is the same request.
+    "request",
 ]);
 export const OPERATE_BOOLEAN_FLAGS = new Set([
     "json", "yes", "all", "brief", "local", "history", "latest-watch", "dry-run", "file",
@@ -663,6 +679,8 @@ export const OPERATE_BOOLEAN_FLAGS = new Set([
     "saved",
     // task complete: also open the result's pull request.
     "pull-request",
+    // storage clean --landed: work already in main.
+    "landed",
     // up: the exact start-up details (containment) in the terminal too.
     "verbose",
     // lead token: end the lead's credential.
@@ -673,6 +691,8 @@ export const OPERATE_BOOLEAN_FLAGS = new Set([
     "also",
     // tokens: the person's password, piped (never an argument).
     "password-stdin",
+    // task steer: pause the running Claude build, then send the note.
+    "now",
 ]);
 export function parseOperateArgs(argv, ownValues = new Set()) {
     const positional = [];
@@ -1717,9 +1737,9 @@ async function runnerCommand(positional, flags, context) {
         if (name === undefined || given === undefined || positional.length > 3) {
             return fail(write, json, "runner capacity", "usage", "`runner capacity <name> <n> --as <you> --token <t>`", EXIT.usage);
         }
-        const capacity = parseRunnerCapacity(given);
+        const capacity = parseRunnerCapacity(given, { allowZero: true });
         if (capacity === null) {
-            return fail(write, json, "runner capacity", "usage", `capacity is a whole number of tasks, 1 to ${RUNNER_CAPACITY_MAX}`, EXIT.usage);
+            return fail(write, json, "runner capacity", "usage", `capacity is a whole number of tasks, 0 to ${RUNNER_CAPACITY_MAX}; 0 stops new builds`, EXIT.usage);
         }
         const acting = await askCredentials(flags, context);
         const verified = acting === null ? null : authenticateApprover(store, acting.name, acting.token);
@@ -1731,6 +1751,12 @@ async function runnerCommand(positional, flags, context) {
             return fail(write, json, "runner capacity", changed.reason, changed.reason === "retired" ? `${name} is retired` : `no runner \`${name}\``, EXIT.refused);
         }
         const running = store.liveClaimCount(name, now);
+        if (changed.after === 0) {
+            return succeed(write, json, "runner capacity", { name, before: changed.before, after: changed.after, running }, () => [
+                `${name} takes no new builds. ${running === 0 ? "Nothing is running." : `${running} running task(s) will finish.`}`,
+                `Resume with: toolroll runner capacity ${name} <1-${RUNNER_CAPACITY_MAX}>`,
+            ]);
+        }
         return succeed(write, json, "runner capacity", { name, before: changed.before, after: changed.after, running }, () => [
             changed.before === changed.after
                 ? `${name} already runs up to ${changed.after} at once.`
@@ -3419,6 +3445,14 @@ async function reconcileCommand(flags, context) {
             reaped: reaped.map(claim => claim.leaseId),
         });
     }
+    // Landed work (landed-cleanup.ts): finish teardowns a crash cut short, then mark newly landed results complete (a
+    // ledger entry says why) and remove their clean checkouts and local build and plan branches.
+    let landed = { completed: [], steps: [] };
+    try {
+        landed = await reconcileLanded(store, worktrees, gitOf(context.gitRunner), repo, context.evidenceRoot, clock);
+    }
+    catch { /* the next pass tries again */ }
+    const landedGone = landed.steps.filter(one => one.outcome === "removed");
     // Checkout cleanup (Settings → Storage): finished work's clean checkouts go as the setting says (by default when
     // the task is complete or cancelled); their branches stay. Each removal is in the ledger.
     // Completing or cancelling a task stops anything still running from its checkout first.
@@ -3437,9 +3471,10 @@ async function reconcileCommand(flags, context) {
     const retained = retention === null ? [] : retention.counts.filter(one => one.count > 0);
     // The daily storage sweep (storage-sweep.ts): stale test temp folders, orphans Toolroll left running, finished
     // checkouts, extra staged runtimes and dependency installs unused for a week; saved for Settings → Storage.
+    // Launch only: report a result here only if it already completed. Later results save independently.
     let storageSwept = null;
     try {
-        storageSwept = await dailyStorageSweep(store, { databaseFile: context.databaseFile, pool: worktrees, tempRoots: context.tempRoots ?? tempRoots() }, clock);
+        storageSwept = dailyStorageSweep(store, { databaseFile: context.databaseFile, pool: worktrees, tempRoots: context.tempRoots ?? tempRoots(), ...(context.sweepOwner === undefined ? {} : { owner: context.sweepOwner }) }, clock);
     }
     catch {
         storageSwept = null; /* the next pass tries again */
@@ -3455,6 +3490,8 @@ async function reconcileCommand(flags, context) {
         closedRuns.length === 0 &&
         closedCheckouts.length === 0 &&
         slimmed.slimmed.length === 0 &&
+        landed.completed.length === 0 &&
+        landedGone.length === 0 &&
         liveSwept.removed.length === 0;
     return succeed(write, json, "reconcile", {
         recovered,
@@ -3465,6 +3502,7 @@ async function reconcileCommand(flags, context) {
         checkoutsKept: pruned.kept,
         processesStopped: [...closedRuns.map(one => ({ run: one.runId, pids: one.done.stopped.map(row => row.pid) })), ...closedCheckouts.map(one => ({ checkout: one.path, pids: one.done.stopped.map(row => row.pid) }))],
         checkoutsSlimmed: slimmed.slimmed.map(one => one.path),
+        landed: { completed: landed.completed, steps: landed.steps },
         liveViewsSwept: liveSwept.removed.length,
         retention: retention === null ? null : { counts: retention.counts, freedBytes: retention.freed },
         storageSweep: storageSwept,
@@ -3478,6 +3516,8 @@ async function reconcileCommand(flags, context) {
             ...(pruned.removed.length === 0 ? [] : [`Removed ${pruned.removed.length} finished task checkout(s), about ${bytesWords(pruned.freed)}; their branches stay.`]),
             ...closedRuns.map(one => `Run #${one.runId} ended; stopped ${stoppedWords(one.done)}.`),
             ...closedCheckouts.map(one => `${one.path}: its task finished; stopped ${stoppedWords(one.done)}.`),
+            ...(landed.completed.length === 0 ? [] : [`Marked ${landed.completed.length} landed result(s) complete: ${landed.completed.join(", ")}.`]),
+            ...(landedGone.length === 0 ? [] : [`Removed landed work: ${landedGone.filter(one => one.kind === "checkout").length} checkout(s), ${landedGone.filter(one => one.kind === "branch").length} local branch(es).`]),
             ...(slimmed.slimmed.length === 0 ? [] : [`Dropped dependencies and build output from ${slimmed.slimmed.length} kept checkout(s), about ${bytesWords(slimmed.slimmed.reduce((sum, one) => sum + one.bytes, 0))}.`]),
             ...(liveSwept.removed.length === 0 ? [] : [`Cleared ${liveSwept.removed.length} finished live view(s).`]),
             ...(retention === null || retained.length === 0 ? [] : [`Retention removed ${sweepWords(retention.counts, retention.freed)}.`]),
@@ -4343,8 +4383,10 @@ async function providersCommand(flags, context) {
         }
         write(`  isolation      ${audit.isolation.flag === null
             ? "no hermetic flag"
-            : `${audit.isolation.flag} exists, not passed${audit.isolation.resumeSafe === false ? " — it would break session resume" : audit.isolation.resumeSafe === null ? " — its effect on resume is unvalidated" : ""}`}`);
-        write(`  config surface ${audit.configSurface.join("; ")}`);
+            : audit.isolation.enforced
+                ? `builds run in their own setup (${audit.isolation.flag}) — none of your own hooks, plugins or MCP servers; reviews keep theirs`
+                : `${audit.isolation.flag} exists, not passed${audit.isolation.resumeSafe === false ? " — it would break session resume" : audit.isolation.resumeSafe === null ? " — its effect on resume is unvalidated" : ""}`}`);
+        write(`  ${audit.isolation.enforced ? "builds get    " : "config surface"} ${audit.configSurface.join("; ")}`);
         write("");
     }
     write("  \u2192 toolroll config show    which provider each phase actually resolves to");
@@ -6102,8 +6144,10 @@ async function runWatchLoop(args) {
     const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
     // Reconciliation has its own cadence and sink. Sharing tick's sink would
     // interleave envelopes while a build awaits its provider or project check.
+    const sweepOwner = {};
     const maintenance = startMaintenance({
         intervalMs: reconcileEveryMs,
+        onStop: () => storageSweepSupervisor(context.databaseFile).stop(sweepOwner),
         shouldStop: stopping,
         onError: error => {
             reconciliationReady = false;
@@ -6114,7 +6158,7 @@ async function runWatchLoop(args) {
         },
         run: async () => {
             const maintenanceLines = [];
-            const maintenanceContext = { ...quietContext, write: line => maintenanceLines.push(line) };
+            const maintenanceContext = { ...quietContext, sweepOwner, write: line => maintenanceLines.push(line) };
             const code = await reconcileCommand(passFlags(), maintenanceContext);
             if (code !== EXIT.ok)
                 throw new Error(maintenanceLines.join(" "));
@@ -8469,7 +8513,7 @@ function taskCommand(positional, flags, context) {
     return taskAction(action, rest, flags, context);
 }
 /** Task verbs that are the lead working on a task, not reading it. */
-const LEAD_WORK_VERBS = new Set(["state", "steer", "reopen", "requeue", "regate", "repair", "resume", "stop", "scope", "approve", "plan", "checks", "revise", "hold", "unhold", "route", "require"]);
+const LEAD_WORK_VERBS = new Set(["state", "steer", "pause", "continue", "reopen", "requeue", "regate", "repair", "resume", "stop", "scope", "approve", "plan", "checks", "revise", "hold", "unhold", "route", "require"]);
 function taskAction(action, rest, flags, context) {
     switch (action) {
         case "complete":
@@ -8510,6 +8554,10 @@ function taskAction(action, rest, flags, context) {
             return nextTask(rest, flags, context);
         case "steer":
             return steerTask(rest, flags, context);
+        case "pause":
+            return pauseTask(rest, flags, context);
+        case "continue":
+            return continueTask(rest, flags, context);
         case "assign":
             return assignTask(rest, flags, context);
         case "reopen":
@@ -9005,6 +9053,7 @@ function showTask(positional, context) {
     const listed = workIndexTask(store, id, now, access, context.evidenceRoot);
     const shared = listed === null ? null : { headline: listed.status.label, sentence: listed.status.detail };
     const primaryAction = listed === null ? work?.primaryAction ?? null : listed.primaryAction;
+    const steeringLive = store.steeringLiveBuild(ref.id, now) !== null;
     const detail = {
         task,
         work: work === null || listed === null ? work : { ...work, status: { ...work.status, label: listed.status.label, detail: listed.status.detail, tone: listed.status.tone }, primaryAction },
@@ -9044,6 +9093,9 @@ function showTask(positional, context) {
         stops: store.stopsForTask(ref.id),
         // The pull request Complete opened (any version), with its CI state and merge commit — the console's view.
         pullRequest: newestPullRequestOf(store, store.taskFamilyOf(id, null, true)?.versions.map(one => one.id) ?? [id]),
+        // Operator steering (v120), in the task page's words: read (and when), waiting, or for the next attempt.
+        steering: store.listSteerNotes(ref.id).map(one => ({ id: one.id, author: one.author, createdAt: one.createdAt, note: one.note,
+            standing: steerStandingOf(one, steeringLive), words: steerStandingWords(one, steeringLive, utcMinute) })),
     };
     return succeed(write, json, "task show", detail, () => [
         `${task.id}  ${task.state}${ref.deliverable === "report" ? "  (scout — delivers a report)" : ""}`,
@@ -9078,6 +9130,7 @@ function showTask(positional, context) {
             ? []
             : [`  position  ${detail.position.position} of ${detail.position.total}${detail.position.column === null ? " in the shared queue" : ` in ${detail.position.column}'s queue`}`]),
         ...(detail.hold === null ? [] : [`  held: ${detail.hold.reason}`]),
+        ...detail.steering.slice(-5).map(one => `  note #${one.id} to the agent: ${one.words}`),
         ...(detail.claim === null ? [] : [`  claimed by ${detail.claim.runner} until ${detail.claim.expiresAt}`]),
         ...(detail.dispatch === null ? [] : [`  dispatch: ${detail.dispatch.summary} — ${detail.dispatch.detail}`]),
         ...(detail.control.kind === "none"
@@ -9433,7 +9486,7 @@ async function steerTask(positional, flags, context) {
     const id = positional[0];
     const note = text(flags, "note");
     if (id === undefined || note === undefined) {
-        return fail(write, json, "task steer", "usage", "`toolroll task steer <id> --note \"...\" --as <you> --token <t>` — steering speaks with the operator's voice, so it takes your credential; the note reaches the next attempt's brief, fenced, inside the approved scope", EXIT.usage);
+        return fail(write, json, "task steer", "usage", "`toolroll task steer <id> --note \"...\" --as <you> --token <t>` — steering speaks with the operator's voice, so it takes your credential; a running build's agent reads the note when it next checks for notes, otherwise the next attempt's brief quotes it, fenced, inside the approved scope", EXIT.usage);
     }
     // Ruling 11: authorship derives from a VERIFIED principal, never a flag.
     // Missing credentials are usage (the invocation is incomplete); present
@@ -9446,6 +9499,9 @@ async function steerTask(positional, flags, context) {
     if (!authed.ok) {
         return fail(write, json, "task steer", "not-an-approver", "that is not an approver, or the token does not match", EXIT.refused);
     }
+    // --now: Pause and steer — the running Claude build's turn stops, then this note continues it.
+    if (flags.get("now") === true)
+        return pauseRunningBuild("task steer", id, note, verifiedAuthor(acting.name), flags, context);
     const filed = store.fileSteerNote(id, verifiedAuthor(acting.name), note, context.now, mutationFrom(flags, context.now));
     if (!filed.ok) {
         const detail = filed.reason === "unknown-task"
@@ -9455,8 +9511,89 @@ async function steerTask(positional, flags, context) {
                 : (filed.problem ?? "that note will not store");
         return fail(write, json, "task steer", filed.reason, detail, EXIT.refused);
     }
-    return succeed(write, json, "task steer", { task: id, note: filed.id }, () => [
-        `Noted. The next attempt at ${id} reads it before starting — a running agent is not interrupted.`,
+    const steered = store.lookupRef(id);
+    const live = steered !== null && store.steeringLiveBuild(steered.id, context.now) !== null;
+    const liveInput = steered !== null && store.liveInputRun(steered.id, context.now) !== null;
+    return succeed(write, json, "task steer", { task: id, note: filed.id, standing: live ? "waiting" : "next-attempt" }, () => [
+        `Noted. ${steerDestinationWords(live, liveInput)} \`task show ${id}\` says when it has been read.`,
+    ]);
+}
+/**
+ * `toolroll task pause <id> [--run <n>] --as <you> --token <t>` (live steering): stop a running Claude build's
+ * current turn and keep the build — its session waits for the next note. Never a stop: nothing ends, holds or
+ * reclaims the attempt. Bound to the exact run (--run, or the one taking live input now); a repeated --request id
+ * is the same request.
+ */
+async function pauseTask(positional, flags, context) {
+    const { store, write, json } = context;
+    const id = positional[0];
+    if (id === undefined)
+        return fail(write, json, "task pause", "usage", "`toolroll task pause <id> [--run <run-id>] --as <you> --token <t>`", EXIT.usage);
+    const acting = await askCredentials(flags, context);
+    if (acting === null)
+        return fail(write, json, "task pause", "usage", "pausing takes `--as <you> --token <t>` — it is an operator's act and is recorded against your name", EXIT.usage);
+    const authed = authenticateApprover(store, acting.name, acting.token);
+    if (!authed.ok)
+        return fail(write, json, "task pause", "not-an-approver", "that is not an approver, or the token does not match", EXIT.refused);
+    return pauseRunningBuild("task pause", id, undefined, verifiedAuthor(acting.name), flags, context);
+}
+/**
+ * `toolroll task continue <id> [--run <n>] --as <you> --token <t>` (live steering): Resume a paused Claude build with a
+ * short continue frame and no note. Bound to the exact run (--run, or the one taking live input now), and only while it
+ * is paused; a repeated --request id is the same request.
+ */
+async function continueTask(positional, flags, context) {
+    const { store, write, json } = context;
+    const id = positional[0];
+    if (id === undefined)
+        return fail(write, json, "task continue", "usage", "`toolroll task continue <id> [--run <run-id>] --as <you> --token <t>`", EXIT.usage);
+    const acting = await askCredentials(flags, context);
+    if (acting === null)
+        return fail(write, json, "task continue", "usage", "resuming takes `--as <you> --token <t>` — it is an operator's act and is recorded against your name", EXIT.usage);
+    const authed = authenticateApprover(store, acting.name, acting.token);
+    if (!authed.ok)
+        return fail(write, json, "task continue", "not-an-approver", "that is not an approver, or the token does not match", EXIT.refused);
+    const ref = store.lookupRef(id);
+    if (ref === null || store.getTask(id) === null)
+        return fail(write, json, "task continue", "unknown-task", `no task \`${id}\``, EXIT.refused);
+    const runText = text(flags, "run");
+    const named = runText === undefined ? store.liveInputRun(ref.id, context.now) : Number(runText);
+    if (named === null)
+        return fail(write, json, "task continue", "not-live", `${id} has no running Claude build to resume`, EXIT.refused);
+    if (!Number.isInteger(named) || named < 1)
+        return fail(write, json, "task continue", "usage", "--run names one exact attempt by its number", EXIT.usage);
+    const requestId = text(flags, "request") ?? text(flags, "key") ?? `cli-${randomUUID()}`;
+    const asked = store.requestResume({ taskId: id, runId: named, by: verifiedAuthor(acting.name), via: "cli", requestId }, context.now);
+    if (!asked.ok)
+        return fail(write, json, "task continue", asked.reason, asked.detail, EXIT.refused, { run: named });
+    return succeed(write, json, "task continue", { task: id, run: named, resume: asked.resume, repeated: asked.duplicate }, () => [
+        asked.duplicate ? `Build #${named} of ${id} was already asked to resume with that request; nothing changed.`
+            : `Resuming build #${named} of ${id} where it stopped.`,
+    ]);
+}
+/** Pause, or Pause and steer, through the store's one action; the words both CLI doors print. */
+function pauseRunningBuild(command, id, note, by, flags, context) {
+    const { store, write, json } = context;
+    const ref = store.lookupRef(id);
+    if (ref === null || store.getTask(id) === null)
+        return fail(write, json, command, "unknown-task", `no task \`${id}\``, EXIT.refused);
+    const runText = text(flags, "run");
+    const named = runText === undefined ? store.liveInputRun(ref.id, context.now) : Number(runText);
+    if (named === null) {
+        return fail(write, json, command, "not-live", note === undefined
+            ? `${id} has no running Claude build to pause`
+            : `${id} has no running Claude build to pause; send the note without --now`, EXIT.refused);
+    }
+    if (!Number.isInteger(named) || named < 1)
+        return fail(write, json, command, "usage", "--run names one exact attempt by its number", EXIT.usage);
+    const requestId = text(flags, "request") ?? text(flags, "key") ?? `cli-${randomUUID()}`;
+    const asked = store.requestPause({ taskId: id, runId: named, by, via: "cli", requestId, ...(note === undefined ? {} : { note }) }, context.now);
+    if (!asked.ok)
+        return fail(write, json, command, asked.reason, asked.detail, EXIT.refused, { run: named });
+    return succeed(write, json, command, { task: id, run: named, pause: asked.pause, note: asked.note, repeated: asked.duplicate }, () => [
+        asked.duplicate ? `Build #${named} of ${id} was already asked to pause with that request; nothing changed.`
+            : note === undefined ? `Pausing build #${named} of ${id}. Its next note continues it; \`task stop\` ends it.`
+                : `Pausing build #${named} of ${id}, then sending your note. \`task show ${id}\` says when it has been read.`,
     ]);
 }
 /** The mirror of block: stop waiting. Removal cannot create a cycle. */
@@ -10981,7 +11118,7 @@ async function retentionCommand(positional, flags, context) {
     const periods = store.setRetentionPeriod(kind, days, acting.name, context.clock());
     return succeed(context.write, context.json, command, { periods }, () => [`${label(kind)}: kept ${days === null ? "forever" : `for ${periodWords(days)}`}.`]);
 }
-/** `storage`, `storage cleanup [<when>]`, `storage clean [--yes]`, `storage discard <path> --yes`: where the disk goes,
+/** `storage`, `storage cleanup [<when>]`, `storage clean [--landed] [--yes]`, `storage discard <path> --yes`: where the disk goes,
  * and task checkouts: when a finished task's clean checkout is removed, cleaning up now, and throwing away one kept for
  * its changes. Changing anything takes an instance operator. */
 async function storageCommand(positional, flags, context) {
@@ -10989,7 +11126,7 @@ async function storageCommand(positional, flags, context) {
     const command = `storage ${action ?? ""}`.trim();
     const store = context.store;
     const changes = (action === "cleanup" && rest.length > 0) || (action === "clean" && flags.has("yes")) || action === "discard";
-    const allowed = new Set([...(changes ? ["as", "token", "token-file", "token-env"] : []), ...(action === "clean" || action === "discard" ? ["yes"] : []), "db", "json"]);
+    const allowed = new Set([...(changes ? ["as", "token", "token-file", "token-env"] : []), ...(action === "clean" || action === "discard" ? ["yes"] : []), ...(action === "clean" ? ["landed"] : []), "db", "json"]);
     for (const name of flags.keys())
         if (!allowed.has(name))
             return fail(context.write, context.json, command, "usage", `--${name} is not a ${command} option.`, EXIT.usage);
@@ -11067,6 +11204,11 @@ async function storageCommand(positional, flags, context) {
         const saved = store.setCheckoutCleanup(cleanup, actor, context.clock());
         return succeed(context.write, context.json, command, { cleanup: saved }, () => [`Saved. A finished task's clean checkout is removed ${cleanupWords(saved)}; its branch stays.`]);
     }
+    if (action === "clean" && flags.has("landed")) {
+        if (rest.length > 0 || flags.get("landed") !== true)
+            return fail(context.write, context.json, "storage clean --landed", "usage", "Use storage clean --landed to preview, then storage clean --landed --yes.", EXIT.usage);
+        return landedCommand(flags.has("yes"), operator, refused, pool, context);
+    }
     if (action === "clean") {
         if (rest.length > 0)
             return fail(context.write, context.json, command, "usage", "Use storage clean to preview, then storage clean --yes.", EXIT.usage);
@@ -11092,7 +11234,7 @@ async function storageCommand(positional, flags, context) {
             return refused("cleans up checkouts");
         const done = await cleanCheckouts(store, pool, context.clock, { manual: true, actor });
         const temp = leftovers(true);
-        const swept = removeStaleTestTemp(roots, context.clock());
+        const swept = await removeStaleTestTemp(roots, context.clock());
         if (swept.removed.length > 0) {
             store.recordAction({ at: context.clock().toISOString(), actor, repo: null, taskId: null, runId: null, action: "test temp folders removed", outcome: "removed", source: "request",
                 detail: `${swept.removed.length} older than a day, about ${bytesWords(temp.staleBytes)}${swept.failed.length === 0 ? "" : `; ${swept.failed.length} couldn't be removed`}` });
@@ -11140,7 +11282,47 @@ async function storageCommand(positional, flags, context) {
             return fail(context.write, context.json, command, "refused", done.message, EXIT.refused);
         return succeed(context.write, context.json, command, { discarded: target, freedBytes: done.bytes }, () => [`Discarded ${target}, about ${bytesWords(done.bytes)}; its branch stays.`]);
     }
-    return fail(context.write, context.json, command, "usage", "Use storage, storage cleanup <when>, storage clean [--yes] or storage discard <path> --yes.", EXIT.usage);
+    return fail(context.write, context.json, command, "usage", "Use storage, storage cleanup <when>, storage clean [--landed] [--yes] or storage discard <path> --yes.", EXIT.usage);
+}
+/** `storage clean --landed [--yes]`: the one-time pass over work that piled up before reconcile did this on its own.
+ * Results whose work landed at least a week ago are marked complete (a ledger entry says why) and their clean
+ * checkouts and local branches go; so do Toolroll's own branches no task uses whose work landed. A preview changes
+ * nothing; --yes takes an instance operator, records every teardown first, then carries it out. */
+async function landedCommand(yes, operator, refused, pool, context) {
+    const command = "storage clean --landed";
+    const git = gitOf(context.gitRunner);
+    const plurals = (count, one, many = `${one}s`) => `${count} ${count === 1 ? one : many}`;
+    const keepLine = (one) => `  ${projectName(one.repo)} ${one.what}: ${one.why}`;
+    const stepLine = (one) => `  ${projectName(one.repo)} ${one.target}${one.why === null ? "" : `: ${one.why}`}`;
+    const counts = (plan) => ({
+        results: plan.results.length, complete: plan.results.filter(one => one.completes).length,
+        checkouts: plan.results.reduce((sum, one) => sum + one.targets.filter(target => target.kind === "checkout").length, 0) + plan.branches.filter(one => one.checkout !== null).length,
+        branches: plan.results.reduce((sum, one) => sum + one.targets.filter(target => target.kind === "branch").length, 0) + plan.branches.length,
+    });
+    if (!yes) {
+        const plan = await landedBacklog(context.store, git, context.evidenceRoot, context.clock());
+        const n = counts(plan);
+        const anything = n.results + plan.branches.length + plan.pending > 0;
+        return succeed(context.write, context.json, command, { preview: true, cutoff: plan.cutoff, results: plan.results, branches: plan.branches, kept: plan.kept, pending: plan.pending }, () => [
+            anything ? `Would mark ${plurals(n.complete, "landed result")} complete and remove ${plurals(n.checkouts, "checkout")} and ${plurals(n.branches, "local branch", "local branches")}.` : `Nothing landed more than ${BACKLOG_DAYS} days ago is left to clean up.`,
+            ...plan.results.map(one => `  ${projectName(one.repo)} ${one.taskId}: ${one.reason}${one.completes ? "" : " (already complete)"}`),
+            ...plan.branches.map(one => `  ${projectName(one.repo)} ${one.branch}: ${one.reason}`),
+            ...(plan.pending === 0 ? [] : [`${plurals(plan.pending, "item")} from an earlier clean-up will finish too.`]),
+            ...(plan.kept.length === 0 ? [] : [`Stays (${plan.kept.length}):`, ...plan.kept.map(keepLine)]),
+            anything ? "Nothing was changed. Run toolroll storage clean --landed --yes to do it." : "Nothing was changed.",
+        ]);
+    }
+    const actor = await operator();
+    if (actor === null)
+        return refused("cleans up landed work");
+    const plan = await landedBacklog(context.store, git, context.evidenceRoot, context.clock());
+    const done = await cleanLandedBacklog(context.store, pool, git, context.evidenceRoot, context.clock, plan, actor);
+    const gone = done.steps.filter(one => one.outcome === "removed" || one.outcome === "already gone");
+    const stays = done.steps.filter(one => one.outcome === "waits" || one.outcome === "kept");
+    return succeed(context.write, context.json, command, { completed: done.completed, steps: done.steps, refused: done.refused, kept: plan.kept }, () => [
+        `Marked ${plurals(done.completed.length, "landed result")} complete. Removed ${plurals(gone.filter(one => one.kind === "checkout").length, "checkout")} and ${plurals(gone.filter(one => one.kind === "branch").length, "local branch", "local branches")}.`,
+        ...(stays.length + done.refused.length === 0 ? [] : [`Stays (${stays.length + done.refused.length}):`, ...stays.map(stepLine), ...done.refused.map(keepLine)]),
+    ]);
 }
 function checkoutSummary(plan) {
     return { count: plan.count, totalBytes: plan.totalBytes, waitingReview: plan.waitingReview, withChanges: plan.withChanges, cleanBytes: plan.freeBytes, cleanCount: plan.go.length, cleanup: plan.cleanup };

package/dist/orphan-sweep.d.ts

@@ -57,6 +57,8 @@ export type OrphanOptions = StopOptions & {
     tempRoots?: readonly string[];
     locate?: (pids: readonly number[]) => Map<number, Located>;
     self?: number;
+    /** A root live work uses (storage-sweep.ts): asked at both looks; true leaves everything in it running. */
+    spare?: (path: string) => boolean;
 };
 /** Stop the orphans Toolroll left (see the top of this file), each in the ledger. */
 export declare function sweepOrphans(store: Store, now: () => Date, options?: OrphanOptions): Promise<OrphanSweep>;

package/dist/orphan-sweep.js

@@ -180,7 +180,8 @@ export async function sweepOrphans(store, now, options = {}) {
     catch {
         return { stopped: [], failed: ["the process list couldn't be read"] };
     }
-    const roots = sweepRoots(store, options.pool ?? null, census, options.tempRoots ?? [], now());
+    const rootsNow = (rows) => sweepRoots(store, options.pool ?? null, rows, options.tempRoots ?? [], now()).filter(root => options.spare?.(root.path) !== true);
+    const roots = rootsNow(census);
     if (roots.length === 0)
         return { stopped: [], failed };
     const guard = protectedProcesses(census, options.self);
@@ -195,14 +196,15 @@ export async function sweepOrphans(store, now, options = {}) {
     const first = orphanTargets(census, located, roots, guard);
     if (first.length === 0)
         return { stopped: [], failed };
-    // Right before the signal, everything again: the same process, still an orphan (or under one), still inside.
+    // Right before the signal, everything again: the same process, still an orphan (or under one), still inside a root
+    // that is still one (no run or lease took its checkout since, nothing live uses it).
     let again;
     try {
         const fresh = read();
         const freshGuard = protectedProcesses(fresh, options.self);
         const freshLocated = locate(fresh.filter(row => row.ppid === 1).map(row => row.pid));
         const before = new Map(first.map(one => [one.row.pid, one]));
-        again = orphanTargets(fresh, freshLocated, roots, freshGuard).filter(one => {
+        again = orphanTargets(fresh, freshLocated, rootsNow(fresh), freshGuard).filter(one => {
             const was = before.get(one.row.pid);
             return was !== undefined && Math.abs(was.row.bornAt - one.row.bornAt) <= BIRTH_SLACK_MS && was.root.path === one.root.path;
         });

package/dist/project-delete-ui.d.ts

@@ -20,6 +20,17 @@ export type ProjectSettingsView = {
         building: number;
         canChange: boolean;
     };
+    /** What its builds can reach: the project's named tools and whether each loads (names and words only, never a
+     * secret), or why they couldn't be read. */
+    access?: {
+        tools: {
+            name: string;
+            loads: boolean;
+            words: string;
+        }[];
+    } | {
+        problem: string;
+    };
 };
 /** The project's page: its path, what Toolroll holds for it, and (for an instance operator) Delete project. */
 export declare function projectSettingsHtml(view: ProjectSettingsView, notice: {

package/dist/project-delete-ui.js

@@ -14,7 +14,34 @@ export const PROJECT_DELETE_CSS = `.project-settings,.project-delete{max-width:7
     `.project-settings button,.project-delete button{justify-self:start;min-height:36px;white-space:nowrap}.project-delete .actions a{min-height:36px;display:inline-flex;align-items:center}` +
     `.project-settings .builds-at-once{margin-top:20px}.project-settings .builds-at-once h2{font-size:1rem;margin:0 0 4px}.project-settings .builds-at-once form{margin-top:4px;gap:4px}` +
     `.project-settings .builds-at-once .builds-row{display:flex;gap:8px;align-items:stretch}.project-settings .builds-at-once input{width:5.5rem;min-height:44px;margin:0;box-sizing:border-box}.project-settings .builds-at-once button{min-height:44px;margin:0}` +
-    `.project-settings .builds-at-once .meta{margin:0}.project-settings form.remove-project{margin-top:20px;gap:4px}.project-settings form.remove-project button{min-height:44px}.project-settings form.remove-project .meta{margin:0}`;
+    `.project-settings .builds-at-once .meta{margin:0}.project-settings form.remove-project{margin-top:20px;gap:4px}.project-settings form.remove-project button{min-height:44px}.project-settings form.remove-project .meta{margin:0}` +
+    `.project-settings .build-access{margin-top:20px;min-width:0;overflow-wrap:anywhere}.project-settings .build-access h2{font:var(--so-typography-title-sm);margin:0 0 4px}.project-settings .build-access p{margin:0}` +
+    `.project-settings .build-access .tool-name{font:var(--so-typography-mono)}.project-settings .build-access details{margin:4px 0 0}.project-settings .build-access summary{min-height:44px;display:inline-flex;align-items:center;cursor:pointer;color:var(--so-muted);font:var(--so-typography-label)}` +
+    `.project-settings .build-access ul{margin:0 0 4px;padding-left:20px;font:var(--so-typography-body);color:var(--so-ink)}.project-settings .build-access li{margin:2px 0}.project-settings .build-access li .meta{color:var(--so-muted)}` +
+    `.project-settings .build-access a.manage-tools{display:inline-flex;align-items:center;justify-content:center;min-height:44px;margin-top:4px;padding:0 14px;white-space:nowrap;background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line);border-radius:var(--so-radius-md);font:var(--so-typography-label);text-decoration:none}` +
+    `.project-settings .build-access a.manage-tools:hover{background:var(--so-raised)}.project-settings .build-access a.manage-tools:focus-visible,.project-settings .build-access summary:focus-visible{outline:2px solid var(--so-ink);outline-offset:2px}`;
+/** Build access: one sentence for what a build gets, the detail on demand, and the way to change it. */
+function accessHtml(view) {
+    const access = view.access;
+    if (access === undefined)
+        return "";
+    const manage = html `<a class="manage-tools" href="/settings/tools?repo=${encodeURIComponent(view.repo)}">Manage tools</a>`;
+    const always = [
+        "Your other projects, keys and sign-in files are out of reach.",
+        "Your own Claude and Codex hooks, plugins and MCP servers don't load.",
+        "Builds sign in with your existing Claude or Codex login.",
+    ];
+    if ("problem" in access) {
+        return html `<section class="build-access" aria-labelledby="build-access-title"><h2 id="build-access-title">Build access</h2><p class="problem" role="alert">${access.problem}</p><details><summary>Details</summary><ul>${always.map(one => html `<li>${one}</li>`)}</ul></details>${manage}</section>`;
+    }
+    const loading = access.tools.filter(one => one.loads);
+    const names = loading.map((one, at) => html `${at === 0 ? "" : ", "}<span class="tool-name">${one.name}</span>`);
+    const outcome = loading.length === 0
+        ? html `<p>Builds work in their task's folder, with no extra tools.</p>`
+        : html `<p>Builds work in their task's folder, with ${loading.length === 1 ? "one tool" : `${loading.length} tools`}: ${names}.</p>`;
+    const tools = access.tools.map(one => html `<li><span class="tool-name">${one.name}</span> <span class="meta">· ${one.words}</span></li>`);
+    return html `<section class="build-access" aria-labelledby="build-access-title"><h2 id="build-access-title">Build access</h2>${outcome}<details><summary>Details</summary><ul>${always.map(one => html `<li>${one}</li>`)}${tools}</ul></details>${manage}</section>`;
+}
 /** Builds at once: one number, one Save. The worker's cap is said only when it lowers the number. */
 function buildsHtml(view) {
     const b = view.builds;
@@ -30,7 +57,7 @@ const note = (notice) => notice.problem ? html `<p class="problem" role="alert">
 /** The project's page: its path, what Toolroll holds for it, and (for an instance operator) Delete project. */
 export function projectSettingsHtml(view, notice) {
     const held = html `<p>Toolroll holds ${holdingsWords(view.holdings)} for <strong>${view.name}</strong>.</p>`;
-    const head = html `${note(notice)}<p class="path">${view.repo}</p>${held}${buildsHtml(view)}`;
+    const head = html `${note(notice)}<p class="path">${view.repo}</p>${held}${buildsHtml(view)}${accessHtml(view)}`;
     if (!view.canDelete)
         return html `<section class="project-settings">${head}<p class="meta">An instance operator can delete a project.</p></section>`;
     const body = view.running.length > 0

package/dist/project-tools.d.ts

@@ -142,22 +142,19 @@ export type ToolLaunchArgs = {
     cleanup: () => void;
     privateDir?: string;
 };
-/** Claude: only these servers (`--strict-mcp-config`), written to a private 0600 file removed after the run. */
+/** Claude: only these servers, written to a private 0600 file removed after the run (the provider adds `--strict-mcp-config`). */
 export declare function claudeToolArgs(launch: ToolLaunch): ToolLaunchArgs;
-export declare function carriedCodexSettings(includeModel: boolean, codexHome?: string): string[];
 /** Where the tool launcher lives beside this module, built. */
 export declare function toolLauncherPath(): string;
 /**
- * Codex: the operator's config.toml is ignored whole (its MCP servers
- * with it), ChatGPT apps and plugins are off, the model settings above
- * are carried, and each tool is named by `-c` and started through the
- * launcher. Codex gives its own environment to the agent's shell whatever
+ * Codex: each tool is named by `-c` and started through the launcher. The
+ * operator's config.toml, rules, apps, plugins and hooks are already off
+ * (the provider's CODEX_BUILD_ISOLATION_ARGV), and nothing of config.toml
+ * is carried. Codex gives its own environment to the agent's shell whatever
  * its policy says, so no secret rides it: each tool's values sit in the
  * run's private 0600 file and reach only that tool's process.
  */
-export declare function codexToolArgs(launch: ToolLaunch, options: {
-    includeModel: boolean;
-    codexHome?: string;
+export declare function codexToolArgs(launch: ToolLaunch, options?: {
     launcher?: string;
     node?: string;
     enabledTools?: Readonly<Record<string, readonly string[]>>;
@@ -182,12 +179,11 @@ export declare function toolLaunchFor(store: Pick<Store, "projectTools" | "getRu
 export declare function prepareRunTools(store: Pick<Store, "projectTools" | "getRun" | "refById" | "getScope" | "toolSealFor" | "recordRunTools" | "orgPolicy">, runId: number, provider: "claude" | "codex" | "openrouter" | "gemini", options: {
     home?: string;
     now: Date;
-    includeModel: boolean;
     readOnly?: Readonly<Record<string, readonly string[]>>;
     withheld?: Readonly<Record<string, string>>;
 }): ToolLaunchArgs;
 /** When a launch's tools cannot be prepared, it still gets none of anything else's: the same isolation with an empty list. */
-export declare function noToolsArgs(provider: "claude" | "codex" | "openrouter" | "gemini", includeModel: boolean): ToolLaunchArgs;
+export declare function noToolsArgs(provider: "claude" | "codex" | "openrouter" | "gemini"): ToolLaunchArgs;
 type ToolWrites = Pick<Store, "projectTools" | "addProjectTool" | "removeProjectTool" | "recordProjectToolTest">;
 /** Add one tool (and, for an import, the values it brings) to a project's builds. */
 export declare function addToolTo(store: ToolWrites, repo: string, input: ToolSpec, source: string, by: string, now: Date, options?: {