toolroll 0.9.60 → 0.9.62

package/dist/maintenance.js

@@ -27,8 +27,11 @@ export function startMaintenance(args) {
     return {
         runNow,
         stop: async () => {
-            stopped = true;
-            clearInterval(timer);
+            if (!stopped) {
+                stopped = true;
+                clearInterval(timer);
+                args.onStop?.();
+            }
             await pending;
         },
     };

package/dist/operate-remote-arguments.js

@@ -29,7 +29,11 @@ export const REMOTE_ARGUMENTS = new Map([
     ['task block', args('id:task', 'key', { on: 'task' })],
     ['task unblock', args('id:task', 'key', { on: 'task' })],
     ['task next', args('id:task', 'key undo')],
-    ['task steer', args('id:task', 'note')],
+    // Live steering: --now pauses the running Claude build first; pause and continue name the exact attempt like stop and
+    // resume, and a repeated --request (or --key) id is the same request.
+    ['task steer', args('id:task', 'note now request key', { run: 'run' })],
+    ['task pause', args('id:task', 'request key', { run: 'run' })],
+    ['task continue', args('id:task', 'request key', { run: 'run' })],
     ['task assign', args('id:task', 'key runner anyone')],
     ['task scope', args('id:task', 'key goal not touches budget-usd risk acceptance candidate model provider repair-model')],
     ['task plan', args('id:task', 'key provider model')],

package/dist/operate-remote.js

@@ -37,7 +37,7 @@ const references = { kind: "references" }, listing = { kind: "listing" };
 export const REMOTE_SCOPES = new Map([
     ["status", listing], ["integrations", installation], ["ready", listing], ["grants", installation], ["sync", installation],
     ["gaps", repo], ["task add", repo],
-    ...["ask", "checks", "add-tests", "show", "wait", "complete", "revise", "state", "block", "unblock", "next", "steer", "assign", "scope", "plan", "hold",
+    ...["ask", "checks", "add-tests", "show", "wait", "complete", "revise", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign", "scope", "plan", "hold",
         "unhold", "require", "requeue", "review", "repair", "route", "reopen", "stop", "resume"].map(action => [`task ${action}`, references]),
     ["check-progress", references],
     ["task list", listing],

package/dist/operate.d.ts

@@ -102,7 +102,7 @@ type Args = {
  * exports are behavior, not commentary — and the declared command guide
  * (surface.ts) is tested for exact equality against them.
  */
-export declare const TASK_ACTIONS: readonly ["add", "list", "show", "wait", "state", "block", "unblock", "next", "steer", "assign", "reopen", "scope", "approve", "hold", "unhold", "require", "requeue", "regate", "plan", "review", "accept", "repair", "route", "stop", "resume", "complete", "revise", "merge", "ask", "checks", "add-tests"];
+export declare const TASK_ACTIONS: readonly ["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"];
 export declare const PUBLISH_ACTIONS: readonly ["setup", "grant", "revoke", "status", "unblock", "rearm", "merge", "refire"];
 export declare const CONFIG_ACTIONS: readonly ["show", "set", "clear"];
 export declare const APPROVER_ACTIONS: readonly ["list", "add"];

package/dist/operate.js

@@ -18,8 +18,12 @@ import { evidencePack, exportDay, ledgerExportChunks, standaloneEvidenceHtml } f
 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 { dailyStorageSweep, lastSweep, nextSweepAt, saveSweep, storageSweepOff as storageSweepOffNow, sweepDetails, sweepWords as storageSweepWords } from "./storage-sweep.js";
+import { storageSweepSupervisor } from "./storage-sweep-process.js";
+import { idleStorageSweep, sweepSchedule, sweepScheduleWords } from "./storage-sweep-schedule.js";
+import { lastSweep, saveSweep, 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 { RemoteMains } from "./remote-main.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";
@@ -180,6 +184,7 @@ import { createInterface } from "node:readline";
 import { propose, approve, addApprover, authenticateAccount, authenticateApprover as passwordApprover, describeScope, approvalOf, hashToken as hashApproverToken, fileAndSealUnderMode, modeFilingCoverage, acceptanceLinesToInput, parseAcceptanceCriteria, splitAcceptanceRubric, rubricIsPlaceholder, isCommitSha } from "./scope.js";
 import { CHAT_APPROVE_ALL, presetTerms, modeTermsJson, modeDigestOf, modeTermsFromJson, modeWords, MODE_MAX_DAYS } from "./modes.js";
 import { WorktreePool } from "./worktree.js";
+import { baseStandingWords, freshBaseFor, taskBaseOf } from "./task-base.js";
 import { requestTaskStop, resumeTaskStop, taskControlOf } from "./task-control.js";
 import { worktreeAdoptionNotice } from "./worktree-notices.js";
 import { workIndexPage, workIndexTask, WorkIndexCursorError } from "./work-index.js";
@@ -254,6 +259,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)
@@ -309,9 +315,17 @@ export const OPERATE_HELP = `toolroll — operating the queue
                                         back in filing order
   toolroll task steer <id> --note "..."
                                         guidance for the agent — a running
-                                        build reads it when it next checks
-                                        for notes, otherwise the next
-                                        attempt does
+                                        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
@@ -600,7 +614,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",
@@ -653,6 +667,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",
@@ -666,6 +682,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.
@@ -676,6 +694,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 = [];
@@ -1035,6 +1055,19 @@ function telegramConversation(context, options = {}) {
         phoneOrigin: () => phoneOrigin(process.env, dirname(context.databaseFile), { serverOrigin: options.serverOrigin ?? null }),
     };
 }
+/** The attempt's history says where it started when that is news: moved to current main, or kept on an older one. */
+function noteBaseStanding(store, runId, standing, main, now) {
+    if (standing == null)
+        return;
+    const commits = (count) => `${count} commit${count === 1 ? "" : "s"}`;
+    if (standing.moved !== null) {
+        store.addRunNote(runId, "Toolroll", `Started from current ${main} (${standing.main.slice(0, 8)}). The branch had no commits or changes of its own and was ${commits(standing.moved.behind)} behind at ${standing.moved.from.slice(0, 8)}.`, now);
+    }
+    else if (standing.kept !== null && standing.behind > 0) {
+        const why = standing.kept === "has commits" ? "it has commits of its own" : standing.kept === "has changes" ? "it has uncommitted changes" : "its checkout is not on the task branch";
+        store.addRunNote(runId, "Toolroll", `Based on an older ${main}: ${standing.head.slice(0, 8)} is ${commits(standing.behind)} behind. It was not moved because ${why}.`, now);
+    }
+}
 /** A revision's verified start: its source build's sealed head, while the revision brief still binds that head and scope. */
 function revisionSourceHead(store, evidenceRoot, taskRef, revisionOf) {
     const source = store.revisionSourceOf(taskRef);
@@ -1720,9 +1753,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);
@@ -1734,6 +1767,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.`
@@ -2705,6 +2744,8 @@ async function tickCommand(flags, context) {
                 // A plan branch from an earlier plan (its checkout removed by storage retention) is reused, as its kept checkout was.
                 reuseBranch: true,
                 reclaim: { evidenceRoot: context.evidenceRoot },
+                // Each plan starts from current main unless it revises earlier work, which keeps that work's head.
+                ...freshBaseFor(store, id, planBranch, base),
             });
             if (!planLeased.ok) {
                 release(store, lease, clock());
@@ -2728,6 +2769,7 @@ async function tickCommand(flags, context) {
                 now: clock(),
                 ...(planStamp === null ? {} : { route: planStamp }),
             });
+            noteBaseStanding(store, planRunId, planLeased.base, base, clock());
             // The source is RECORDED on the attempt before the brief is even
             // composed: the exact bytes the planner reads, sealed as evidence,
             // and the filed scope's digest stamped as what this run was proved
@@ -3031,6 +3073,7 @@ async function tickCommand(flags, context) {
                 continue;
             }
         }
+        // An existing branch with no commits of its own starts from current main (a new one already does).
         const leased = await worktrees.lease({
             repo,
             branch,
@@ -3039,6 +3082,7 @@ async function tickCommand(flags, context) {
             now: clock(),
             ...(exists.code === 0 ? {} : { base: buildBase }),
             reclaim: { evidenceRoot: context.evidenceRoot },
+            ...(exists.code === 0 ? freshBaseFor(store, id, branch, base) : {}),
         });
         if (!leased.ok) {
             // The task is fine; this machine's pool is not. Hand the claim back so
@@ -3099,6 +3143,7 @@ async function tickCommand(flags, context) {
             dispatched.push({ id, outcome: "skipped", reason: "admission-refused", detail: error instanceof Error ? error.message : String(error) });
             continue;
         }
+        noteBaseStanding(store, runId, leased.base, base, clock());
         if (leased.resumedFromRun !== undefined) {
             store.addRunNote(runId, "Toolroll", `Recovered the ${leased.recoveryKind === "completed" ? "completed source draft" : "work-in-progress draft"} from interrupted attempt #${leased.resumedFromRun}. This fresh attempt is reviewing and verifying it; the safety patch is retained.`, clock());
         }
@@ -3422,6 +3467,19 @@ 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: [] };
+    // Completion trusts only the recorded remote's main, fetched by this process into a private folder it removes after.
+    const remotes = new RemoteMains(store, context.gitRunner, context.evidenceRoot);
+    try {
+        landed = await reconcileLanded(store, worktrees, gitOf(context.gitRunner), remotes, repo, context.evidenceRoot, clock);
+    }
+    catch { /* the next pass tries again */ }
+    finally {
+        remotes.close();
+    }
+    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.
@@ -3438,14 +3496,19 @@ async function reconcileCommand(flags, context) {
         retention = null; /* the next pass tries again */
     }
     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
+    // The 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.
+    // Only the long-lived service (its watch passes `sweepOwner`) starts one, once due and while nothing is running or
+    // waiting (storage-sweep-schedule.ts). A one-shot reconcile would exit and lose the claimed sweep, so it leaves it.
+    // 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);
-    }
-    catch {
-        storageSwept = null; /* the next pass tries again */
+    if (context.sweepOwner !== undefined) {
+        try {
+            storageSwept = idleStorageSweep(store, { databaseFile: context.databaseFile, pool: worktrees, tempRoots: context.tempRoots ?? tempRoots(), owner: context.sweepOwner }, clock);
+        }
+        catch {
+            storageSwept = null; /* the next pass tries again */
+        }
     }
     const swept = storageSwept === null ? [] : storageSwept.parts.filter(one => one.count > 0);
     const nothing = retained.length === 0 &&
@@ -3458,6 +3521,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,
@@ -3468,6 +3533,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,
@@ -3481,6 +3547,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)}.`]),
@@ -4346,8 +4414,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");
@@ -5984,7 +6054,8 @@ async function runWatchLoop(args) {
     if (!Number.isSafeInteger(reconcileEveryMs) || reconcileEveryMs < 1 || reconcileEveryMs > 2_147_483_647) {
         throw new Error("--reconcile-every must be an integer from 1 to 2147483647 milliseconds");
     }
-    const incarnation = randomUUID();
+    // The owner carries lifetime without changing the lease schema. Bounded watches cannot host automatic sweeps.
+    const incarnation = `${runFor === null ? "toolroll-service:" : ""}${randomUUID()}`;
     const lease = acquireWatchLeaseAuthed(store, { runner, token, repo, owner: incarnation, ttlMs: WATCH_LEASE_MS }, new Date());
     if (!lease.ok) {
         return {
@@ -6105,8 +6176,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;
@@ -6117,7 +6190,9 @@ async function runWatchLoop(args) {
         },
         run: async () => {
             const maintenanceLines = [];
-            const maintenanceContext = { ...quietContext, write: line => maintenanceLines.push(line) };
+            const maintenanceContext = { ...quietContext, ...(runFor === null ? { sweepOwner } : {}), write: line => maintenanceLines.push(line) };
+            if (runFor !== null)
+                delete maintenanceContext.sweepOwner;
             const code = await reconcileCommand(passFlags(), maintenanceContext);
             if (code !== EXIT.ok)
                 throw new Error(maintenanceLines.join(" "));
@@ -7171,6 +7246,9 @@ async function upCommand(flags, context) {
     }
     const loopFlagsFor = (repo) => {
         const copy = new Map();
+        // A bounded `up` must not advertise its child watches as an unbounded sweep service either.
+        if (forGiven !== undefined)
+            copy.set("for", forGiven);
         copy.set("runner", runnerName);
         copy.set("token", runnerToken);
         copy.set("repo", repo);
@@ -8472,7 +8550,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":
@@ -8513,6 +8591,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":
@@ -9009,6 +9091,7 @@ function showTask(positional, context) {
     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 base = taskBaseOf(store, id);
     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 },
@@ -9024,6 +9107,8 @@ function showTask(positional, context) {
         scope,
         approval: approvalOf(scope),
         route: taskRouteView(routed, readiness),
+        // Fresh base: the commit this task's work starts from, and how far current main has moved past it.
+        base,
         runs: runs.map(one => ({ ...one, route: store.runRoute(one.id) })),
         deliverable: ref.deliverable,
         report: readVerifiedReport(store, context.evidenceRoot, ref.id),
@@ -9080,6 +9165,7 @@ function showTask(positional, context) {
                 ]
                 : [`  report: ${detail.report.problem} (run ${detail.report.run})`]),
         ...pullRequestLines(detail.pullRequest),
+        ...(base === null ? [] : [`  base: ${baseStandingWords(base)}`]),
         ...(detail.blockedBy.length > 0 ? [`  waits for ${detail.blockedBy.join(", ")}`] : []),
         ...(detail.position === null
             ? []
@@ -9454,6 +9540,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"
@@ -9465,8 +9554,87 @@ async function steerTask(positional, flags, context) {
     }
     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)} \`task show ${id}\` says when it has been read.`,
+        `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. */
@@ -10991,7 +11159,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) {
@@ -10999,7 +11167,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);
@@ -11038,15 +11206,15 @@ async function storageCommand(positional, flags, context) {
     const sweepFacts = () => {
         const last = lastSweep(store);
         const automatic = last?.source === "automatic" ? last : lastSweep(store, "automatic");
-        return { last, lastAutomatic: automatic, next: nextSweepAt(store) };
+        return { last, lastAutomatic: automatic, schedule: sweepSchedule(store, context.clock()) };
     };
     const sweepLines = (facts) => {
         const when = (at) => new Date(at).toLocaleString("en-US", { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
         const one = facts.last;
-        const head = one === null ? (facts.next === null && storageSweepOffNow() ? "Automatic sweep: off." : "Automatic sweep: not run yet; it runs once a day.")
+        const head = one === null ? "Not swept yet."
             : `Last swept ${when(one.at)}${one.source === "manual" ? ` by ${one.actor}` : " automatically"}: ${storageSweepWords(one.parts)}`;
         const auto = one !== null && one.source === "manual" && facts.lastAutomatic !== null ? [`Last automatic sweep ${when(facts.lastAutomatic.at)}: ${storageSweepWords(facts.lastAutomatic.parts)}`] : [];
-        return [head, ...auto, ...(one === null ? [] : sweepDetails(one.parts).slice(0, 8).map(line => `  ${line}`))];
+        return [head, ...auto, `Automatic sweep: ${sweepScheduleWords(facts.schedule, when)}`, ...(one === null ? [] : sweepDetails(one.parts).slice(0, 8).map(line => `  ${line}`))];
     };
     if (action === undefined) {
         const plan = await checkoutPlan(store, pool, context.clock(), { manual: true });
@@ -11077,6 +11245,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);
@@ -11102,7 +11275,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`}` });
@@ -11150,7 +11323,57 @@ 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) {
+    // Completion trusts only the recorded remote's main, fetched by this process into a private folder it removes after.
+    const remotes = new RemoteMains(context.store, context.gitRunner, context.evidenceRoot);
+    try {
+        return await landedCommandWith(remotes, yes, operator, refused, pool, context);
+    }
+    finally {
+        remotes.close();
+    }
+}
+async function landedCommandWith(remotes, 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, remotes, 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, remotes, context.evidenceRoot, context.clock());
+    const done = await cleanLandedBacklog(context.store, pool, git, remotes, 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>;