toolroll 0.9.28 → 0.9.29

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.9.29 — 2026-10-04
+
+- **Tasks filed from the command line get sized too.** `task scope` now sizes
+  the task from its goal before the plan is sealed, so work the lead files
+  gets the same fast-or-strong model choice as work filed in the console.
+- **A reused process ID no longer blocks finishing a release.** Once
+  Toolroll has recorded that a process exited, a new program taking its
+  number doesn't count as the old one. Leftover process records close when the
+  run ends, and a wait that clears by itself says so instead of asking you to
+  confirm.
+- **Status shows each task once.** A task that is building appears only under
+  Building, an approved plan no longer reads as waiting for review, and risky
+  routes say "Risky" instead of "routine".
+
 ## 0.9.28 — 2026-10-04
 
 - **Each task gets the right model.** When a task is filed, a fast

package/dist/lead-status.js

@@ -114,19 +114,21 @@ export function taskWaitSnapshot(store, taskId, now, watchedRun) {
         const next = holdKind === "operator" ? "Remove hold" : holdKind === "revision" ? "Review plan" : holdKind === "stop" ? "Resume or close attempt" : holdKind === "contest" ? "Choose a result" : "Review task";
         return answer("Needs a person", next, true, 1, "needs-person");
     }
-    if (task["plan"] === "drafted")
-        return answer("Needs a person", "Approve plan", true, 1, "needs-person");
-    if (Number(task["strikes"] ?? 0) >= 3)
-        return answer("Needs a person", "Review repeated failures", true, 1, "needs-person");
     // An admitted attempt is already the work being watched. Its immutable
     // approval snapshot lives on the run, so a damaged or later-edited current
     // scope must not make `wait` abandon that attempt before it settles.
     if (attempt !== undefined)
         return answer("Running", phase === null ? "Wait for attempt" : `Wait — ${phase}`, false, null, null);
-    const scope = store.handle.prepare("SELECT digest, approved_digest, profile_state FROM task_scope WHERE task_id = ?").get(taskId);
+    const scope = store.handle.prepare(`SELECT digest, approved_digest, profile_state,
+    (approved_at IS NOT NULL AND approved_by IS NOT NULL AND approved_digest = digest) AS approved
+    FROM task_scope WHERE task_id = ?`).get(taskId);
+    if (task["plan"] === "drafted" && Number(scope?.["approved"]) !== 1)
+        return answer("Needs a person", "Approve plan", true, 1, "needs-person");
+    if (Number(task["strikes"] ?? 0) >= 3)
+        return answer("Needs a person", "Review repeated failures", true, 1, "needs-person");
     if (scope === undefined)
         return answer("Needs a person", "Add scope", true, 1, "needs-person");
-    if (scope["approved_digest"] !== scope["digest"] || scope["profile_state"] !== "resolved")
+    if (Number(scope["approved"]) !== 1 || scope["profile_state"] !== "resolved")
         return answer("Needs a person", "Approve task", true, 1, "needs-person");
     if (state === "running" && attempt === undefined) {
         const liveClaim = store.handle.prepare(`SELECT 1 AS hit FROM claim INDEXED BY claim_by_task
@@ -157,7 +159,7 @@ function queueReason(row) {
         return "needs a result choice";
     if (hold === "backoff")
         return "retrying later";
-    if (row["plan"] === "drafted")
+    if (row["plan"] === "drafted" && Number(row["approved"]) !== 1)
         return "needs plan review";
     if (Number(row["strikes"] ?? 0) >= 3)
         return "stalled after failures";
@@ -165,7 +167,7 @@ function queueReason(row) {
         return "waiting for another task";
     if (row["scope_digest"] == null)
         return "needs a scope";
-    if (row["approved_digest"] !== row["scope_digest"] || row["profile_state"] !== "resolved")
+    if (Number(row["approved"]) !== 1 || row["profile_state"] !== "resolved")
         return "needs approval";
     return "ready for a worker";
 }
@@ -181,7 +183,7 @@ export function repairStaleStatuses(store, now) {
 }
 /** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead. */
 export function installationStatus(store, now, viewer = currentActor()?.account ?? null) {
-    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.external_id AS task
+    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.id AS task_ref, ref.external_id AS task
     FROM run INDEXED BY work_unfinished
     JOIN task_ref AS ref ON ref.id = run.task_ref
     JOIN claim ON claim.lease_id = run.lease_id
@@ -194,8 +196,10 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         phases.set(phase, (phases.get(phase) ?? 0) + 1);
         return { task: String(row["task"]), run: Number(row["id"]), phase };
     });
-    const queuedRows = store.handle.prepare(`SELECT task.id, ref.plan, ref.strikes, scope.digest AS scope_digest,
-      scope.approved_digest, scope.profile_state,
+    const runningRefs = new Set(runningRows.map(row => Number(row["task_ref"])));
+    const queuedRows = store.handle.prepare(`SELECT task.id, ref.id AS task_ref, ref.plan, ref.strikes, scope.digest AS scope_digest,
+      scope.profile_state,
+      (scope.approved_at IS NOT NULL AND scope.approved_by IS NOT NULL AND scope.approved_digest = scope.digest) AS approved,
       EXISTS (SELECT 1 FROM task_edge WHERE task_edge.blocked = task.id
         AND EXISTS (SELECT 1 FROM task AS blocker WHERE blocker.id = task_edge.blocker AND blocker.state <> 'done')) AS blocked,
       (SELECT owner_kind FROM hold INDEXED BY hold_by_task WHERE hold.task_ref = ref.id AND (hold.until IS NULL OR hold.until > ?)
@@ -203,7 +207,8 @@ export function installationStatus(store, now, viewer = currentActor()?.account
     FROM task INDEXED BY task_by_state
     JOIN task_ref AS ref INDEXED BY sqlite_autoindex_task_ref_1 ON ref.backend = ? AND ref.external_id = task.id
     LEFT JOIN task_scope AS scope ON scope.task_id = task.id
-    WHERE task.state = 'queued'`).all(now.toISOString(), BUILT_IN);
+    WHERE task.state = 'queued'`).all(now.toISOString(), BUILT_IN)
+        .filter(row => !runningRefs.has(Number(row["task_ref"])));
     const reasons = new Map();
     const queuedTasks = [];
     const pauses = openAuthPauses(store);

package/dist/needs-you.d.ts

@@ -8,7 +8,7 @@
 /** What a person is asked for. */
 export type NeedKey = "approval" | "card" | "answer" | "questions" | "sign-in" | "confirm-stopped" | "check-stopped" | "hold" | "choose-project" | "define-task" | "fix-request" | "choose-agent" | "fix-dependency" | "add-requirement" | "connect-builder" | "start-builder" | "vanished" | "review-result" | "rebuild" | "earlier-version" | "other";
 /** What the work waits for when no person can act. */
-export type WaitKey = "build-stopping" | "other-computer" | "card-reply" | "card-time" | "card-ci";
+export type WaitKey = "build-stopping" | "build-finishing" | "other-computer" | "card-reply" | "card-time" | "card-ci";
 /** The action's code: the WorkAction that owns the act, or one of the acts a surface renders itself. */
 export type NeedActionCode = "approve-scope" | "approve-card" | "answer-decision" | "inspect-decisions" | "sign-in" | "confirm-stopped" | "inspect-hold" | "place-task" | "write-scope" | "select-agent" | "repair-dependency" | "repair-capability" | "start-worker" | "reconcile-run" | "open-result" | "retry-task" | "inspect-task";
 export type NeedAction = {
@@ -73,7 +73,7 @@ export declare function waitSentence(key: WaitKey | undefined, reason: string |
  * `unknown`: Toolroll can't check, so the person confirms they checked. */
 export declare function processNeedOf(fact: {
     run: number;
-    kind: "open" | "alive" | "elsewhere" | "unprovable" | "unknown";
+    kind: "open" | "alive" | "elsewhere" | "unprovable" | "unknown" | "settling";
 } | null): {
     need: "confirm-stopped" | "check-stopped";
     build: number;

package/dist/needs-you.js

@@ -79,6 +79,7 @@ export const NEED_ASK = {
     "add-requirement": "unblock", "connect-builder": "unblock", "start-builder": "unblock", vanished: "unblock", "earlier-version": "unblock", other: "unblock",
 };
 export const WAITS = {
+    "build-finishing": () => "Finishing up; this clears on its own.",
     "build-stopping": context => `Waiting for ${build(context)} to stop. Nothing is needed from you.`,
     "other-computer": context => `Waiting for the computer that ran ${build(context)} to confirm it stopped.`,
     "card-reply": () => "Waiting for a reply.",
@@ -110,6 +111,8 @@ export function waitSentence(key, reason, context = {}) {
 export function processNeedOf(fact) {
     if (fact === null)
         return null;
+    if (fact.kind === "settling")
+        return { wait: "build-finishing", build: fact.run };
     if (fact.kind === "unprovable")
         return { need: "confirm-stopped", build: fact.run };
     if (fact.kind === "unknown")

package/dist/operate.js

@@ -26,7 +26,7 @@ import { checkIntegrations, integrationsBrokenLine, integrationsNow, renderInteg
 import { buildHandoff, handoffLines, loginAccount, runOnboard } from "./agent-onboard.js";
 import { backupFiles, backupFolderOf, backupOwner, backupNow, restoreDatabase, startBackups } from "./backup.js";
 import { pushLimitSink } from "./provider-limits.js";
-import { installFilingSizer, ownerSizer, settleSizings } from "./task-sizing.js";
+import { heuristicSizing, installFilingSizer, ownerSizer, refineFiledSizing, settleSizings } from "./task-sizing.js";
 import { tierLines, tierReport } from "./tier-report.js";
 import { limitsView } from "./limits-ui.js";
 import { startCodexLimits } from "./codex-limits.js";
@@ -11110,7 +11110,7 @@ async function syncCommand(flags, context) {
  * separate acts by, usually, separate parties: an agent may draft a scope, and
  * only a person may agree to it.
  */
-function scopeTask(positional, flags, context) {
+async function scopeTask(positional, flags, context) {
     const { store, write, json, now } = context;
     const id = positional[0];
     const goal = text(flags, "goal");
@@ -11265,6 +11265,27 @@ function scopeTask(positional, flags, context) {
     const actor = asGiven !== undefined && tokenGiven !== undefined && authenticateApprover(store, asGiven, tokenGiven).ok
         ? asGiven
         : null;
+    // Size the new goal before filing its route. A replay must not classify
+    // again or change the task behind the original answer. This probe does
+    // not record a result; the composite filing below still owns the receipt.
+    let refinement = null;
+    store.replay(mutationFrom(flags, now), "task-scope-filed", () => {
+        const ref = store.lookupRef(id);
+        const previous = store.getScope(id);
+        if (ref === null || ref.deliverable === "report" || candidateGiven !== undefined ||
+            ref.sizing?.source === "person" || approvalOf(previous).approved ||
+            previous?.proposedVia === "coordinator" || store.filedViaOf(id)?.startsWith("mcp:") ||
+            ((plannedRace !== null || plannedComparison !== null) && store.openAuthorizationFor(ref.id) !== null))
+            return null;
+        const input = { title: store.getTask(id).title, goal, outOfScope: text(flags, "not") ?? null, touches };
+        const sized = store.applySizing(id, heuristicSizing(input), { followPlanning: true }, now);
+        if (sized.ok)
+            refinement = refineFiledSizing(store, id, input, true, context.clock);
+        return null;
+    }, () => false);
+    // Wait for bounded classification before filing so any approval in the
+    // transaction below binds the final size and route.
+    await refinement;
     // ONE replayed composite (surfaces round 1, finding 3): the filing, any
     // race/comparison terms, AND the mode seal record as a single operation —
     // a replayed key returns the FIRST answer whole instead of re-sealing

package/dist/phase-routing.js

@@ -806,7 +806,7 @@ export function projectRoute(route, readiness) {
     return {
         digest: routeDigestOf(route),
         risk: route.risk,
-        riskTitle: riskTitle(route.risk),
+        riskTitle: route.risk === "routine" && route.size?.risky ? "Risky" : riskTitle(route.risk),
         posture: drawsStrong(legs) ? "strong" : "economy",
         postureWords: postureWords(route),
         demands: route.demands.filter(reason => !/review/i.test(reason)),

package/dist/process-liveness.d.ts

@@ -1,6 +1,7 @@
 type HistoricalWitness = {
     observedAt: unknown;
     finishedAt: unknown;
+    exitedAt?: unknown;
 };
 /** Read-only checks of retained process witnesses. Saved PIDs authorize no
  * signal. ESRCH or proven macOS PID reuse establishes absence; everything

package/dist/process-liveness.js

@@ -43,6 +43,11 @@ function newerMacProcess(pid, witness) {
  * unknown stays occupied. This concerns the historical identity, not whether
  * the numeric PID/PGID is currently populated by unrelated processes. */
 export function processMayBeAlive(pid, group, witness) {
+    // A recorded single-process exit is final: this number can now belong to
+    // someone else, even before the run ends. A leader's exit proves nothing
+    // about its group's remaining members, so groups keep the OS probe.
+    if (!group && witness?.exitedAt != null)
+        return false;
     if (!Number.isSafeInteger(pid) || pid <= 0)
         return true;
     if (group && process.platform !== "win32") {

package/dist/serve.js

@@ -12687,7 +12687,7 @@ function approvalSheetHtml(input) {
         : projection === null
             ? route.legacy === null ? "" : `<p>${escape(agentsSummaryWords(route))}</p>`
             : `<p>${escape(projection.summary)}</p>` +
-                `<p class="meta">${escape(riskTitle(route.riskLevel))}: ${escape(riskConsequence(route.riskLevel))}. Uses ${escape(projection.postureWords)}.</p>` +
+                `<p class="meta">${escape(agentsRiskWords(projection))}. Uses ${escape(projection.postureWords)}.</p>` +
                 (projection.demands.length === 0 ? "" : `<ul class="meta">${projection.demands.map(one => `<li>${escape(one)}</li>`).join("")}</ul>`) +
                 `<dl class="approval-roles">${projection.legs.map(leg => `<div><dt>${escape(ROLE_NOUN[leg.phase])}</dt><dd><span class="mono">${escape(leg.provider)} · ${escape(leg.model)}</span> <span class="meta">${escape(chosenWords(leg))}</span>` +
                     `<ul>${leg.reasons.map(reason => `<li>${escape(reason)}</li>`).join("")}${leg.problem === null ? "" : `<li><strong>${escape(leg.problem)}</strong></li>`}</ul></dd></div>`).join("")}</dl>` +
@@ -12945,10 +12945,16 @@ function agentsSummaryWords(view) {
         return `${view.legacy.provider} · ${view.legacy.model} builds and repairs (repair model ${view.legacy.repairModel}); the planner and reviewer come from configuration at run time`;
     return view.problem ?? "the agents cannot be read";
 }
+function agentsRiskWords(projection) {
+    const consequence = projection.risk === "routine" && projection.size?.risky
+        ? riskConsequence("elevated")
+        : riskConsequence(projection.risk);
+    return `${projection.riskTitle}: ${consequence}`;
+}
 /** Neutral metadata badges: risk, posture, and standing. */
 function agentsBadgesHtml(view) {
     const p = view.projection;
-    return (`<span class="badge">${escape(sentenceCase(riskTitle(view.riskLevel)))}</span>` +
+    return (`<span class="badge">${escape(sentenceCase(p?.riskTitle ?? riskTitle(view.riskLevel)))}</span>` +
         (p === null ? "" : `<span class="badge">${escape(sentenceCase(p.postureWords))}</span>`) +
         `<span class="badge">${escape(sentenceCase(agentsStandingWords(view)))}</span>`);
 }
@@ -12997,8 +13003,8 @@ function agentsCeremonyHtml(view) {
     return (`<div class="agents-ceremony"><p class="approval-label">agents</p>` +
         sizeLineHtml(view.projection) +
         `<p class="agents-summary">${escape(view.projection.summary)}</p>` +
-        `<div class="agents-badges"><span class="badge">${escape(sentenceCase(riskTitle(view.riskLevel)))}</span><span class="badge">${escape(sentenceCase(view.projection.postureWords))}</span></div>` +
-        `<p class="meta agents-risk-line">${escape(riskTitle(view.riskLevel))}: ${escape(riskConsequence(view.riskLevel))}.</p>` +
+        `<div class="agents-badges"><span class="badge">${escape(sentenceCase(view.projection.riskTitle))}</span><span class="badge">${escape(sentenceCase(view.projection.postureWords))}</span></div>` +
+        `<p class="meta agents-risk-line">${escape(agentsRiskWords(view.projection))}.</p>` +
         agentsWhyHtml(view.projection) +
         `<p class="meta">These exact agents are part of what you approve; changing any of them asks for a fresh approval.</p></div>`);
 }
@@ -13024,7 +13030,7 @@ function routineAgentsHtml(routine, approved, ceremony = false) {
     const projection = projectRoute(route, () => null);
     return (`<div class="agents-ceremony"><p class="approval-label">agents</p>` +
         `<p class="agents-summary">${escape(agentsSummary(route))}</p>` +
-        `<div class="agents-badges"><span class="badge">${escape(sentenceCase(riskTitle(route.risk)))}</span><span class="badge">${escape(sentenceCase(postureWords(route)))}</span><span class="badge">${approved ? "frozen by the approval" : "frozen when you approve"}</span></div>` +
+        `<div class="agents-badges"><span class="badge">${escape(sentenceCase(projection.riskTitle))}</span><span class="badge">${escape(sentenceCase(postureWords(route)))}</span><span class="badge">${approved ? "frozen by the approval" : "frozen when you approve"}</span></div>` +
         (ceremony ? agentsWhyHtml(projection) : "") +
         `<p class="meta">${approved ? "Every firing runs on exactly these agents; a configuration change cannot re-route it." : "Approving freezes exactly these agents for every firing; a configuration change afterwards cannot re-route one."}</p></div>`);
 }

package/dist/store.d.ts

@@ -26,7 +26,7 @@ import { type ApprovalGate, type ApprovalRules, type ApproverKind, type Filer }
  * next; `channel` is where it reports (`chat`: the conversation it was promised in); a promise lapses at `expires_at`. */
 export declare const LEAD_COMMITMENT_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_commitment (\n  id             INTEGER PRIMARY KEY AUTOINCREMENT,\n  owner          TEXT NOT NULL,\n  repo           TEXT,\n  thread         INTEGER NOT NULL,\n  turn           INTEGER,\n  channel        TEXT NOT NULL DEFAULT 'chat',\n  what           TEXT NOT NULL,\n  condition_json TEXT NOT NULL,\n  check_at       TEXT NOT NULL,\n  expires_at     TEXT NOT NULL,\n  state          TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('open', 'done', 'cancelled', 'expired')),\n  created_at     TEXT NOT NULL,\n  checked_at     TEXT,\n  closed_at      TEXT,\n  closed_by      TEXT,\n  outcome        TEXT\n);\nCREATE INDEX IF NOT EXISTS lead_commitment_due ON lead_commitment (state, check_at);\nCREATE INDEX IF NOT EXISTS lead_commitment_owner ON lead_commitment (owner, state, id);\n";
 /** What stops a finished run reading stopped (Store.stopQuiescenceFact). */
-export type StopFactKind = "open" | "alive" | "elsewhere" | "unprovable" | "unknown";
+export type StopFactKind = "open" | "alive" | "elsewhere" | "unprovable" | "unknown" | "settling";
 export type TaskAct = "filed" | "approved" | "cancelled" | "completed" | "asked";
 /** Store.stopQuiescenceFact, read safely: a deploy proves completion with this code over the INSTALLED runtime's store,
  * which may predate the method. There the older stopQuiescenceProblem decides, and its words give the kind. */
@@ -7274,7 +7274,8 @@ export declare class Store {
      * another computer can tell, `unprovable` when nothing is known to run
      * but its exit was never recorded, `unknown` when this computer can't
      * check at all (both are what `run settle` resolves; only the first may
-     * be called not running). */
+     * be called not running). `settling` already meets the automatic
+     * reconciliation proof, so no confirmation is needed. */
     stopQuiescenceFact(runId: number): {
         run: number;
         kind: StopFactKind;
@@ -7306,7 +7307,11 @@ export declare class Store {
      * process groups is alive, it settles as never started, with a ledger
      * entry. A sole pid-less witness has no group to prove gone and stays for
      * `run settle`. Native witnesses keep their OS-only road. */
-    settleUnspawnedWitnesses(now: Date): number;
+    settleUnspawnedWitnesses(now: Date, onlyRun?: number): number;
+    /** The existing automatic settlement proof, shared with its read-only
+     * status. Unknown-only, foreign, native and still-running custody keep
+     * their fences; only an observed single-process exit avoids a new probe. */
+    private settleableUnspawnedWitnesses;
     /** `run settle` (an approver's last resort): every witness of a finished
      * run that cannot be proven either way is recorded settled under the
      * approver's reason, in the ledger. Refuses while anything of the run is

package/dist/store.js

@@ -16479,6 +16479,9 @@ export class Store {
             // retained witnesses and every owned run; recovery revisits a pending
             // stop after an orphan or held supervisor finishes shutdown.
             this.recordRunProcessExits(id, result.now);
+            // Use the existing reconciliation proof now, while exits are fresh. In
+            // particular, a returned --candidate check need not await the next scan.
+            this.settleUnspawnedWitnesses(result.now, id);
             this.settleRunStop(id, result.stopSettlement ?? "finished", result.now);
             // The first Ready result is an installation fact the moment it lands,
             // not only when something later looks for it. A run that changed
@@ -21473,7 +21476,8 @@ export class Store {
      * another computer can tell, `unprovable` when nothing is known to run
      * but its exit was never recorded, `unknown` when this computer can't
      * check at all (both are what `run settle` resolves; only the first may
-     * be called not running). */
+     * be called not running). `settling` already meets the automatic
+     * reconciliation proof, so no confirmation is needed. */
     stopQuiescenceFact(runId) {
         const fact = (run, kind, problem) => ({ run, kind, problem });
         const ids = this.ownedRunsOf(runId);
@@ -21489,10 +21493,13 @@ export class Store {
             if (held !== null && held.endedAt === null)
                 return fact(id, "alive", `run #${id}'s held supervisor has not finished shutdown`);
             const witnesses = this.db.prepare("SELECT * FROM run_process WHERE run = ? ORDER BY id").all(id);
+            let incompleteSpawn = false;
             if (run.providerStartedAt !== null && witnesses.length === 0) {
                 return fact(id, "unprovable", `run #${id} may have spawned before its process witness was recorded; exit is unproven`);
             }
             for (const witness of witnesses) {
+                // A recorded group exit proves the whole group ended, not just its
+                // leader. Re-probing its number could mistake reuse for the old group.
                 if (witness["exited_at"] !== null)
                     continue;
                 const host = String(witness["host"]);
@@ -21522,10 +21529,12 @@ export class Store {
                         return fact(id, "unknown", `run #${id}'s ${backend} object ${container} cannot be proven empty from here`);
                     continue;
                 }
-                if (witness["pid"] === null)
-                    return fact(id, "unprovable", `run #${id} has an incomplete spawn witness; exit is unproven`);
+                if (witness["pid"] === null) {
+                    incompleteSpawn = true;
+                    continue;
+                }
                 const pid = Number(witness["pid"]);
-                if (processMayBeAlive(pid, witness["process_group"] === 1, { observedAt: witness["observed_at"], finishedAt: run.finishedAt }))
+                if (processMayBeAlive(pid, witness["process_group"] === 1, { observedAt: witness["observed_at"], finishedAt: run.finishedAt, exitedAt: witness["exited_at"] }))
                     return fact(id, "alive", `run #${id}'s process ${pid} may still be running`);
             }
             if (run.worktree !== null) {
@@ -21540,6 +21549,8 @@ export class Store {
                         return fact(id, "unknown", `run #${id}'s workspace occupancy could not be established`);
                 }
             }
+            if (incompleteSpawn)
+                return fact(id, this.settleableUnspawnedWitnesses(run, witnesses).length > 0 ? "settling" : "unprovable", `run #${id} has an incomplete spawn witness; exit is unproven`);
         }
         return null;
     }
@@ -21618,10 +21629,11 @@ export class Store {
      * process groups is alive, it settles as never started, with a ledger
      * entry. A sole pid-less witness has no group to prove gone and stays for
      * `run settle`. Native witnesses keep their OS-only road. */
-    settleUnspawnedWitnesses(now) {
+    settleUnspawnedWitnesses(now, onlyRun) {
         const candidates = this.db.prepare(`SELECT DISTINCT p.run FROM run_process p JOIN run r ON r.id = p.run
       WHERE p.exited_at IS NULL AND p.pid IS NULL AND p.containment IS NULL AND p.container IS NULL
-        AND p.host = ? AND r.outcome IS NOT NULL AND r.finished_at IS NOT NULL ORDER BY p.run`).all(hostname());
+        AND p.host = ? AND r.outcome IS NOT NULL AND r.finished_at IS NOT NULL
+        AND (? IS NULL OR p.run = ?) ORDER BY p.run`).all(hostname(), onlyRun ?? null, onlyRun ?? null);
         let settled = 0;
         for (const candidate of candidates) {
             const runId = Number(candidate["run"]);
@@ -21630,22 +21642,8 @@ export class Store {
                 const run = this.getRun(runId);
                 if (run === null || run.outcome === null)
                     return 0;
-                if (ownedProcessCount(runOwnerTag(this, runId)) > 0)
-                    return 0;
-                const held = this.heldSessionOf(runId);
-                if (held !== null && held.endedAt === null)
-                    return 0;
                 const rows = this.db.prepare("SELECT * FROM run_process WHERE run = ? ORDER BY id").all(runId);
-                const pidless = rows.filter(row => row["exited_at"] === null && row["pid"] === null && row["containment"] === null && row["container"] === null && row["host"] === hostname());
-                const others = rows.filter(row => !pidless.includes(row));
-                if (pidless.length === 0 || others.length === 0)
-                    return 0;
-                if (others.some(row => row["exited_at"] === null))
-                    return 0;
-                // Exit was recorded once; the group's members are asked again now.
-                const groups = others.filter(row => row["pid"] !== null && row["host"] === hostname());
-                if (groups.length === 0 || groups.some(row => processMayBeAlive(Number(row["pid"]), row["process_group"] === 1, { observedAt: row["observed_at"], finishedAt: run.finishedAt })))
-                    return 0;
+                const pidless = this.settleableUnspawnedWitnesses(run, rows);
                 const ref = this.refById(run.taskRef);
                 let count = 0;
                 for (const row of pidless) {
@@ -21664,6 +21662,24 @@ export class Store {
         }
         return settled;
     }
+    /** The existing automatic settlement proof, shared with its read-only
+     * status. Unknown-only, foreign, native and still-running custody keep
+     * their fences; only an observed single-process exit avoids a new probe. */
+    settleableUnspawnedWitnesses(run, rows) {
+        if (run.outcome === null || run.finishedAt === null || ownedProcessCount(runOwnerTag(this, run.id)) > 0)
+            return [];
+        const held = this.heldSessionOf(run.id);
+        if (held !== null && held.endedAt === null)
+            return [];
+        const pidless = rows.filter(row => row["exited_at"] === null && row["pid"] === null && row["containment"] === null && row["container"] === null && row["host"] === hostname());
+        const others = rows.filter(row => !pidless.includes(row));
+        if (pidless.length === 0 || others.length === 0 || others.some(row => row["exited_at"] === null))
+            return [];
+        const known = others.filter(row => row["pid"] !== null && row["host"] === hostname());
+        if (known.length === 0 || known.some(row => processMayBeAlive(Number(row["pid"]), row["process_group"] === 1, { observedAt: row["observed_at"], finishedAt: run.finishedAt, exitedAt: row["exited_at"] })))
+            return [];
+        return pidless;
+    }
     /** `run settle` (an approver's last resort): every witness of a finished
      * run that cannot be proven either way is recorded settled under the
      * approver's reason, in the ledger. Refuses while anything of the run is
@@ -21691,7 +21707,7 @@ export class Store {
                         return alive(`run #${args.runId}'s process ${String(row["pid"])} belongs to ${String(row["host"])}; settle it there`);
                     continue;
                 }
-                if (processMayBeAlive(Number(row["pid"]), row["process_group"] === 1, { observedAt: row["observed_at"], finishedAt: run.finishedAt }))
+                if (processMayBeAlive(Number(row["pid"]), row["process_group"] === 1, { observedAt: row["observed_at"], finishedAt: run.finishedAt, exitedAt: row["exited_at"] }))
                     return alive(`run #${args.runId}'s process ${String(row["pid"])} is still running`);
             }
             for (const row of open) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.28",
+  "version": "0.9.29",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"