@henryqw/pi-subagent 22.1.0 → 22.2.1

package/README.md

@@ -21,7 +21,9 @@ pi install npm:pi-mcp-adapter
 
 ## Use
 
-![Delegation mode routing and the checked changeset lifecycle through recovery, validation, and promotion](./docs/delegation-routing.svg)
+![Main, its coordinator extension, and a Herdr subagent through checked work, worker failure, and coordinator interruption](./docs/worker-lifecycle.svg)
+
+The coordinator is extension code running in Main's Pi process, not another agent. It persists the request, launches the Herdr subagent, checks its committed work, and reports saved results; Main chooses what to stage and promote. If a worker fails, the coordinator reports attention after the wave settles, not necessarily immediately while siblings work. If Main's Pi process stops, no follow-up is guaranteed: restart and run `/subagent recover` in the canonical repository to classify orphaned interruptions and send Main one recovery report. Main then uses `subagent_status` for exact evidence and deliberate next actions. A stale `running` state does not prove a worker is still active; interrupted or ambiguous actions are never replayed automatically.
 
 Ask Main to delegate a bounded task, such as “Have a scout trace sign-in without editing files.” Main uses `delegate_task`; you receive progress and a result or an actionable failure while Main remains available.
 
@@ -31,7 +33,8 @@ In the TUI, the compact widget uses one row per visible agent/task: `D` or `I` m
 
 | Surface | Type | Purpose |
 | --- | --- | --- |
-| `/subagent` | command | Pick direct or isolated work to inspect; send or edit pending instructions for a locally active isolated changeset. Requires interactive TUI or RPC. |
+| `/subagent` | command | Browse work, launch isolated status inspection in a separate Herdr tab with the `fast` model, or send/edit pending instructions. Requires interactive TUI or RPC; inspection also requires a Herdr-managed pane and a read-only `scout` Role. |
+| `/subagent recover` | command | Classify orphaned isolated work in the current canonical repository and send Main one follow-up with request IDs, blockers, and reported next actions. No UI or Herdr pane required. |
 | `delegate_task` | tool | Start read-only direct work or a durable isolated checked graph. |
 | `subagent_status` | tool | Read durable isolated state and the exact allowed continuation without replaying work. |
 | `subagent_resume` | tool | Perform the reported `retry`, `verify`, or `finalize` continuation; does not replace staging or integration. |
@@ -123,21 +126,23 @@ An isolated request has one durable ID, one goal, and 1–8 typed tasks:
 
 `dependsOn` controls scheduling. `contextFrom` may name completed text tasks and preserves the declared order. Changesets require focused task checks; a graph with changesets requires final checks. A canonical root `package.json` test script is required: the runner adds `pnpm test` to final checks if missing, and Main runs it on the combined integration checkout before promotion. Checks and judgments bind to exact Git identities; candidate drift, Main drift, mutation during validation, ambiguity, or conflicts stop promotion and retain evidence.
 
-`delegate_task` and `subagent_resume` return a durable request ID after its state is saved; productive work continues while Main is free. Pi delivers completion or attention as a follow-up message in the launching session. Use `subagent_status` if delivery is missed or you need current state.
+`delegate_task`, `subagent_resume`, and `subagent_integrate advance` return a durable request ID after the wave is saved; productive work continues while Main is free. Pi sends a follow-up in the launching session whenever a checked worker becomes ready, and again when the wave finishes or needs attention. Use `subagent_status` if delivery is missed or you need current state.
 
-The worker produces a clean committed candidate, then runs focused preliminary checks and optional judgment. The runner records a ready candidate but **does not integrate it automatically**. Main inspects `subagent_status`, selects each exact candidate with `subagent_stage` in an owned integration worktree, and resolves conflicts there. `subagent_integrate` can advance dependent tasks from a staged snapshot, validate the combined tip with full root checks and optional final judgment, and promote it to Main only after exact validation. A definitive failed combined check/review allows one committed correction in the integration checkout followed by another validation. Main must explicitly promote; promotion and cleanup never silently discard retained work.
+The worker produces a committed candidate without tracked or untracked changes, then runs focused preliminary checks and optional judgment. Ignored generated files do not block candidacy, but prevent automatic worktree cleanup; inspect them before deleting retained work. The runner records each ready candidate immediately but **does not integrate it automatically**. Main can inspect `subagent_status` and use `subagent_stage` to select the exact candidate in an owned integration worktree while siblings are still working; conflicts are resolved there. Stage and resolve are available during an active wave, but rejection and revision wait for the wave to settle. `subagent_integrate` can advance dependent tasks from a staged snapshot, validate the combined tip with full root checks and optional final judgment after the wave settles, and promote it to Main only after exact validation. A definitive failed combined check/review allows one committed correction in the integration checkout followed by another validation. Main must explicitly promote; promotion and cleanup never silently discard retained work.
 
-Open `/subagent` without arguments to pick work by label. The menu shows direct records on this session branch and isolated requests in the current canonical Git checkout (including requests launched in other sessions). Pick a task to inspect status and recovery in separate notices; retained paths and worker identities remain exact even when the request has many attempts or generations. Refresh or choose completed/history for older work. Invalid state IDs are warned about and preserved. Outside Git or when isolated inventory is unavailable, direct recovery still works. Browsing does not resume work or change resources.
+Open `/subagent` without arguments to pick work by label. The menu shows direct records on this session branch and isolated requests in the current canonical Git checkout (including requests launched in other sessions). Pick an isolated request and **Inspect status and recovery** to launch a non-focused Herdr tab with a read-only `scout` Role on the configured `fast` route. Its prompt contains bounded saved status (including retained paths, but not raw launch environment or session transcripts); the analysis stays in that tab and does not queue a Main turn. The tab and session file are recorded for recovery even if launch becomes uncertain. The read-only `subagent_status` tool remains Main's authority for exact identities before any stage or recovery action. If Herdr or the read-only fast route is unavailable, inspection fails without changing the request; Main can use `subagent_status`. Refresh or choose completed/history for older work. Invalid state IDs are warned about and preserved. Outside Git or when isolated inventory is unavailable, direct recovery still works. Browsing does not resume work or change resources.
 
-For a locally active unsealed isolated changeset, choose **Send follow-up instructions** to open a native multiline editor; submission queues the instruction, not a completed revision. Choose **Edit queued instructions** to withdraw *all still-pending* instructions for that selected task before the editor opens. Their full text appears in FIFO order separated by blank lines. Explicit submission queues **one replacement** at the tail. Cancel leaves the withdrawn instructions removed; already-claimed instructions, initial prompts, and automatic corrections cannot be recalled. A worker may seal during editing: failed submission reopens the full submitted text for deliberate editing or copying, never automatically requeues it. Combined text above the single-instruction limit is preserved in the editor but rejected until shortened. Cancelling before withdrawal makes no change. Neither action touches Main's editor or Pi's global Option+Up queue shortcut. No-UI sessions must use the agent tools for inspection and recovery.
+For a locally active unsealed isolated changeset, choose **Send follow-up instructions** to open a native multiline editor; submission queues the instruction, not a completed revision. Choose **Edit queued instructions** to withdraw *all still-pending* instructions for that selected task before the editor opens. Their full text appears in FIFO order separated by blank lines. Explicit submission queues **one replacement** at the tail. Cancel leaves the withdrawn instructions removed; already-claimed instructions, initial prompts, and automatic corrections cannot be recalled. A worker may seal during editing: failed submission reopens the full submitted text for deliberate editing or copying, never automatically requeues it. Combined text above the single-instruction limit is preserved in the editor but rejected until shortened. Cancelling before withdrawal makes no change. Neither action touches Main's editor or Pi's global Option+Up queue shortcut. No-UI sessions can run `/subagent recover` or use agent tools for individual inspection and recovery.
 
 A queued follow-up runs after the current turn settles and must produce a new clean commit that passes preliminary checks again. When no queued revision remains, the checked candidate seals immediately; there is no guaranteed post-completion editing window. Late follow-ups fail visibly.
 
 ### Isolated recovery
 
-Main uses the recovery tools in the interface table above. The following details describe their exact identity and retained-work requirements.
+After a coordinator interruption, run `/subagent recover` once. It acquires the repository productive lease before changing any orphaned `pending` or `running` state, preserves unreadable state files and retained candidates, and reports blockers and existing continuations to Main without replaying prompts, merges, promotion, or cleanup. If another productive run holds the lease, it only reads status and reports the live owner; wait rather than taking over. Repeating the command is safe. Main uses `subagent_status` for exact identities and the recovery tools in the interface table above for deliberate decisions; the command never stages or promotes. Direct Herdr tab recovery remains in `/subagent`.
+
+The following details describe exact identity and retained-work requirements.
 
-Pass the exact `generation`, candidate (`taskId`, `attempt`, `candidate`) and `expectedTip` identities reported by status to stage; pass the generation and combined `expectedTip` to integrate. If Main advances cleanly before promotion, call `subagent_integrate refresh` with the recorded `expectedMain`, old `expectedTip`, and new clean `newMain`. Main must restage selected immutable candidates into the new generation and rerun combined checks. Dirty or divergent Main blocks refresh. Stale identities fail. At most two integration worktrees may remain unreleased per request; a superseded generation is read-only. To release a superseded *clean* integration checkout, call `subagent_integrate` with `{ id, action: "release", generation, expectedTip }`, using that generation's last staged tip (or integration base when no stage completed). To release a rejected candidate after its worker has terminated and all generations using it are released, pass `{ id, action: "release", generation: <latest generation number, or 1>, taskId, attempt, expectedTip: <candidate tip> }`. Release persists each host/checkout/branch step, verifies ownership and cleanliness (including ignored files), and deletes the branch only if its ref still names the exact tip. Dirty, conflicted, changed, or uncertain resources remain for manual inspection; retry the same release after resolving the obstacle. Released checkouts free a retained slot; abort is available after every retained resource is released. Rejection can invalidate dependent work; if fresh dependent execution is impossible, start a new request instead of forcing promotion. Productive requests have no whole-run wall-clock deadline. Resume does not reset the recorded policy or correction count. Child limits, abort signals, process I/O, status inspection, exact termination, and cleanup retain finite safety bounds.
+Pass the exact `generation`, candidate (`taskId`, `attempt`, `candidate`) and `expectedTip` identities reported by status to stage; pass the generation and combined `expectedTip` to integrate. If Main advances cleanly before promotion, call `subagent_integrate refresh` with the recorded `expectedMain`, old `expectedTip`, and new clean `newMain`. Main must restage selected immutable candidates into the new generation and rerun combined checks. Dirty or divergent Main blocks refresh. Stale identities fail. If integration allocation was uncertain, `subagent_stage resolve` first proves the owned checkout is still at its base before starting the selected merge; otherwise it retains the intent. At most two integration worktrees may remain unreleased per request; a superseded generation is read-only. To release a superseded *clean* integration checkout, call `subagent_integrate` with `{ id, action: "release", generation, expectedTip }`, using that generation's last staged tip (or integration base when no stage completed). To release a rejected candidate after its worker has terminated and all generations using it are released, pass `{ id, action: "release", generation: <latest generation number, or 1>, taskId, attempt, expectedTip: <candidate tip> }`. Release persists each host/checkout/branch step, verifies ownership and cleanliness (including ignored files), and deletes the branch only if its ref still names the exact tip. Dirty, conflicted, changed, or uncertain resources remain for manual inspection; retry the same release after resolving the obstacle. Released checkouts free a retained slot; abort is available after every retained resource is released. Rejection can invalidate dependent work; if fresh dependent execution is impossible, start a new request instead of forcing promotion. Productive requests have no whole-run wall-clock deadline. Resume does not reset the recorded policy or correction count. Child limits, abort signals, process I/O, status inspection, exact termination, and cleanup retain finite safety bounds.
 
 The extension never pushes, opens a pull request, publishes, deploys, force-cleans recoverable work, or silently falls back to Main.
 

package/dist/git-runtime.js

@@ -339,24 +339,27 @@ export class CheckedGitRuntime {
         return worktree;
     }
     async inspectInFlightWorkspace(cwd, context) {
-        const branch = oneLine(await this.requireGit(["symbolic-ref", "--quiet", "HEAD"], cwd, context), "branch reference");
-        const head = oid(await this.requireGit(["rev-parse", "--verify", "HEAD^{commit}"], cwd, context), "HEAD");
-        const hadGitlinks = await this.hasGitlinks(cwd, context);
-        const inspection = await inspectWorktreeDirty(cwd, this.gitRunner(context));
-        if (inspection.failure)
-            throw new Error(`Worktree inspection failed: ${inspection.failure}`);
-        const index = oid(await this.requireGit(["write-tree"], cwd, context), "index tree");
-        const tree = oid(await this.requireGit(["rev-parse", "--verify", "HEAD^{tree}"], cwd, context), "HEAD tree");
-        const hasGitlinks = hadGitlinks || await this.hasGitlinks(cwd, context);
-        const finalBranch = oneLine(await this.requireGit(["symbolic-ref", "--quiet", "HEAD"], cwd, context), "branch reference");
-        const finalHead = oid(await this.requireGit(["rev-parse", "--verify", "HEAD^{commit}"], cwd, context), "HEAD");
-        if (branch !== finalBranch || head !== finalHead)
-            throw new Error("Git workspace changed during in-flight identity inspection.");
-        return {
-            candidate: { branch, head, index, tree },
-            clean: !inspection.dirty,
-            supported: !hasGitlinks,
-        };
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const branch = oneLine(await this.requireGit(["symbolic-ref", "--quiet", "HEAD"], cwd, context), "branch reference");
+            const head = oid(await this.requireGit(["rev-parse", "--verify", "HEAD^{commit}"], cwd, context), "HEAD");
+            const hadGitlinks = await this.hasGitlinks(cwd, context);
+            const inspection = await inspectWorktreeDirty(cwd, this.gitRunner(context), false);
+            if (inspection.failure)
+                throw new Error(`Worktree inspection failed: ${inspection.failure}`);
+            const index = oid(await this.requireGit(["write-tree"], cwd, context), "index tree");
+            const tree = oid(await this.requireGit(["rev-parse", "--verify", "HEAD^{tree}"], cwd, context), "HEAD tree");
+            const hasGitlinks = hadGitlinks || await this.hasGitlinks(cwd, context);
+            const finalBranch = oneLine(await this.requireGit(["symbolic-ref", "--quiet", "HEAD"], cwd, context), "branch reference");
+            const finalHead = oid(await this.requireGit(["rev-parse", "--verify", "HEAD^{commit}"], cwd, context), "HEAD");
+            if (branch !== finalBranch || head !== finalHead)
+                continue;
+            return {
+                candidate: { branch, head, index, tree },
+                clean: !inspection.dirty,
+                supported: !hasGitlinks,
+            };
+        }
+        throw new Error("Git workspace changed during in-flight identity inspection.");
     }
     async inspectWorkspace(cwd, strictIgnored, context) {
         const branch = oneLine(await this.requireGit(["symbolic-ref", "--quiet", "HEAD"], cwd, context), "branch reference");

package/dist/herdr-runtime.d.ts

@@ -1,5 +1,6 @@
 import { type ExecuteRequest, type HostAllocationIntent, type HostAllocationPlan, type TaskAttempt, type TaskRequest, type WorkspaceIdentity } from "./schema.ts";
 import { type AllocationReconciliation, type HostAllocationKind, type HostAllocationResult, type HostCleanupKind, type HostRuntime, type InFlightTaskCandidateInspector, type OperationContext, type TextTaskContext, type TransientLaunchHandle, type VerifiedLaunch, type WorkerResult } from "./runner.ts";
+import { type EphemeralSubagentExecutionBudget } from "./ephemeral.ts";
 export interface HostProcessOptions {
     cwd: string;
     signal: AbortSignal;
@@ -21,6 +22,7 @@ export interface HerdrHostRuntimeOptions {
     env?: NodeJS.ProcessEnv;
     leaseDirectory?: string;
     lsofCommand?: string;
+    executionBudget?: () => Omit<EphemeralSubagentExecutionBudget, "startedAt">;
 }
 export declare function workspaceLabel(attempt: Pick<TaskAttempt, "correlationToken">): string;
 export declare class HerdrHostRuntime implements HostRuntime {
@@ -34,6 +36,7 @@ export declare class HerdrHostRuntime implements HostRuntime {
     private readonly env;
     private readonly leaseDirectory;
     private readonly lsofCommand;
+    private readonly executionBudget?;
     constructor(options: HerdrHostRuntimeOptions);
     /** Fail-closed Herdr caller/capability gate. This method creates no state or host resource. */
     preflightHost(input: {

package/dist/herdr-runtime.js

@@ -8,6 +8,7 @@ import { createHerdrClient, hasHerdrErrorCode, herdrCommandFailure, startPiAgent
 import { isCleanCommitted, } from "./schema.js";
 import { buildChangesetTaskPrompt, withTransientLaunch, } from "./runner.js";
 import { runProcess as defaultRunProcess } from "./process.js";
+import { EXECUTION_BUDGET_ENV } from "./ephemeral.js";
 const MIN_HERDR_VERSION = [0, 9, 0];
 const MIN_HERDR_PROTOCOL = 22;
 const HERDR_OPERATION_CAP_MS = 30_000;
@@ -252,6 +253,7 @@ export class HerdrHostRuntime {
     env;
     leaseDirectory;
     lsofCommand;
+    executionBudget;
     constructor(options) {
         this.inspectInFlightCandidate = options.inspectInFlightTaskCandidate;
         this.execute = options.runProcess ?? defaultRunProcess;
@@ -263,6 +265,7 @@ export class HerdrHostRuntime {
         this.env = options.env ?? process.env;
         this.leaseDirectory = resolve(options.leaseDirectory ?? join(extensionConfigDir("pi-subagent"), "leases"));
         this.lsofCommand = options.lsofCommand ?? "lsof";
+        this.executionBudget = options.executionBudget;
     }
     /** Fail-closed Herdr caller/capability gate. This method creates no state or host resource. */
     async preflightHost(input, context) {
@@ -741,9 +744,12 @@ export class HerdrHostRuntime {
         assertWorkerTabIntent(allocation, task, attempt);
         await this.createPrivateLease(allocation.leasePath, allocation.token);
         await this.waitForStableWorkspacePanes(allocation.workspaceId, allocation.worktreeCwd, context);
+        const budget = this.executionBudget?.();
         const args = [
             "tab", "create", "--workspace", allocation.workspaceId, "--cwd", allocation.worktreeCwd,
-            "--label", allocation.label, "--env", `${PROCESS_LEASE_ENV}=${allocation.leasePath}`, "--no-focus",
+            "--label", allocation.label, "--env", `${PROCESS_LEASE_ENV}=${allocation.leasePath}`,
+            ...(budget ? ["--env", `${EXECUTION_BUDGET_ENV}=${JSON.stringify({ ...budget, startedAt: this.now() })}`] : []),
+            "--no-focus",
         ];
         const response = await this.herdr.exec(args, this.processOptions(allocation.worktreeCwd, context, HERDR_OPERATION_CAP_MS));
         if (response.code !== 0 || response.killed) {
@@ -783,8 +789,9 @@ export class HerdrHostRuntime {
         return await withTransientLaunch(handle, async (launch) => {
             if (launch.role !== expectedRole)
                 throw new Error("Agent start acquisition returned the wrong Role.");
-            if (Object.keys(launch.env).length)
+            if (Object.keys(launch.env).some((name) => name !== EXECUTION_BUDGET_ENV || !this.executionBudget)) {
                 throw new Error("Herdr agent launch must not receive caller Role environment variables.");
+            }
             const response = await startPiAgent(this.herdr, {
                 name: allocation.agentName,
                 pane: allocation.paneId,
@@ -827,6 +834,15 @@ export class HerdrHostRuntime {
             if (lifecycle.status === "unknown") {
                 return { outcome: "unknown", diagnostic: "Delivered prompt lifecycle is unknown." };
             }
+            if (lifecycle.status === "working") {
+                try {
+                    await this.delay(STALLED_PROMPT_POLL_MS, context.signal);
+                }
+                catch (error) {
+                    return { outcome: this.contextInterrupted(context) ? "interrupted" : "unknown", diagnostic: `Delivered prompt polling failed: ${safeText(error)}` };
+                }
+                continue;
+            }
             let inspection;
             try {
                 inspection = await this.inspectInFlightCandidate({ root: allocation.worktreeCwd, task: input.task, attempt: input.attempt }, this.childContext(context, GIT_INSPECTION_CAP_MS));

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { captureWorkingCheckoutBaseline, captureWorkingCheckoutState, prepareWor
 export declare const PI_SUBAGENT_PROCESS_LEASE = "PI_SUBAGENT_PROCESS_LEASE";
 export declare const ROLE_MCP_POLICY_FLAG = "pi-subagent-role-mcps";
 export declare const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
+export declare const EXECUTION_BUDGET_FLAG = "pi-subagent-execution-budget";
 export declare const CHILD_EXCLUDED_TOOL_NAMES: readonly ["delegate_task", "ask_question", "subagent_status", "subagent_resume", "subagent_stage", "subagent_abort"];
 export declare const CHILD_EXCLUDED_TOOLS: string;
 export declare const DELEGATE_TASK: {

package/dist/index.js

@@ -19,6 +19,7 @@ const ROLE_TOOLS_EXTENSION = fileURLToPath(new URL("../extensions/role-tools.ts"
 export const PI_SUBAGENT_PROCESS_LEASE = "PI_SUBAGENT_PROCESS_LEASE";
 export const ROLE_MCP_POLICY_FLAG = "pi-subagent-role-mcps";
 export const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
+export const EXECUTION_BUDGET_FLAG = "pi-subagent-execution-budget";
 export const CHILD_EXCLUDED_TOOL_NAMES = [
     "delegate_task",
     "ask_question",

package/dist/integration-git.js

@@ -45,10 +45,15 @@ async function sharedHistory(base, tip, cwd, signal) {
 /** Check helper-derived names even after a safely removed checkout is no longer present. */
 async function ownershipMetadata(root, info, signal) {
     const canonical = await realpath(root);
+    const listed = await requireGit(["worktree", "list", "--porcelain", "-z"], root, signal);
+    const primary = listed.split("\0", 1)[0];
+    if (!primary?.startsWith("worktree "))
+        throw new Error("Primary Git worktree is unavailable.");
+    const repoRoot = await realpath(primary.slice("worktree ".length));
     if (await realpath(await requireGit(["rev-parse", "--show-toplevel"], root, signal)) !== canonical
-        || info.repoRoot !== canonical || info.cwd !== info.path
+        || info.repoRoot !== repoRoot || info.cwd !== info.path
         || !/^pi-subagent\/subagent-[0-9a-f]{24}$/.test(info.branch)
-        || info.path !== join(canonical, ".worktrees", basename(info.branch))) {
+        || info.path !== join(repoRoot, ".worktrees", basename(info.branch))) {
         throw new Error("Git worktree is not an exact owned checkout of Main.");
     }
 }

package/dist/launch-runtime.d.ts

@@ -1,5 +1,5 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type EphemeralSubagentExecutionBudget } from "./ephemeral.ts";
+import type { EphemeralSubagentExecutionBudget } from "./ephemeral.ts";
 import type { CoordinatorRuntime, OperationContext, TransientLaunchHandle, VerifiedLaunch } from "./runner.ts";
 import { type ExecuteRequest, type ModelClass, type WorkspaceIdentity } from "./schema.ts";
 export declare const ISOLATED_MODEL_TASK: {

package/dist/launch-runtime.js

@@ -3,8 +3,7 @@ import { constants } from "node:fs";
 import { chmod, lstat, mkdtemp, open, realpath, rmdir, unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, normalize, relative, sep } from "node:path";
-import { resolveConfiguredRoleLaunch } from "./index.js";
-import { EXECUTION_BUDGET_ENV } from "./ephemeral.js";
+import { EXECUTION_BUDGET_FLAG, resolveConfiguredRoleLaunch } from "./index.js";
 import { registerModelTask } from "@henryqw/pi-task-models";
 const PROMPT_FLAG = "--append-system-prompt";
 const DIRECTORY_MODE = 0o700;
@@ -138,13 +137,14 @@ export class RoleLaunchRuntime {
                 modelClass,
                 model: `${prepared.model.provider}/${prepared.model.id}`,
                 thinkingLevel: prepared.thinkingLevel,
-                args: Object.freeze([...prepared.args]),
-                env: Object.freeze({
-                    ...prepared.env,
-                    ...(executionBudget === undefined ? {} : {
-                        [EXECUTION_BUDGET_ENV]: JSON.stringify({ ...executionBudget, startedAt: this.now() }),
-                    }),
-                }),
+                args: Object.freeze([
+                    ...prepared.args,
+                    ...(executionBudget === undefined ? [] : [
+                        `--${EXECUTION_BUDGET_FLAG}`,
+                        JSON.stringify({ ...executionBudget, startedAt: this.now() }),
+                    ]),
+                ]),
+                env: Object.freeze({ ...prepared.env }),
                 tools: Object.freeze([...prepared.tools]),
             }),
             prompt: prepared.systemPrompt,

package/dist/runner.d.ts

@@ -303,6 +303,13 @@ export declare class IsolatedRunner {
         }>;
         invalidIds: string[];
     }>;
+    /** Classify orphaned work under the same repository lease as productive execution.
+     * Status remains read-only; Main alone chooses any subsequent action. */
+    recoverRepository(root: string): Promise<{
+        requests: RunResponse[];
+        invalidIds: string[];
+        leaseBusy: boolean;
+    }>;
     canFollowup(root: string, requestId: string, taskId: string): boolean;
     drainFollowups(root: string, requestId: string, taskId: string): string[];
     queueFollowup(root: string, requestId: string, taskId: string, instruction: string): string;

package/dist/runner.js

@@ -2,7 +2,7 @@ import { readFileSync, realpathSync } from "node:fs";
 import { createChildWorktree, finalizeChildWorktree } from "./worktree.js";
 import { IntegrationGit } from "./integration-git.js";
 import { checkBatchPasses, CLEANUP_KINDS, isCleanCommitted, MAX_PERSISTED_RUNTIME_TEXT_BYTES, MAX_POSSIBLE_RESOURCES, parseExecuteRequest, parseIntegrationAction, integrationGenerationPasses, parseResumeRequest, parseStageRequest, reviewEvidencePasses, sameIdentity, RUN_STATE_VERSION, } from "./schema.js";
-import { FileRunStore } from "./store.js";
+import { FileRunStore, ProductiveRunLeaseBusyError } from "./store.js";
 const TRUNCATION_MARKER = "\n[truncated]";
 const TEXT_TASK_PROMPT_MAX_BYTES = 64 * 1024;
 const CHANGESET_TASK_PROMPT_MAX_BYTES = 96 * 1024;
@@ -533,6 +533,39 @@ export class IsolatedRunner {
                 })),
             })) };
     }
+    /** Classify orphaned work under the same repository lease as productive execution.
+     * Status remains read-only; Main alone chooses any subsequent action. */
+    async recoverRepository(root) {
+        root = realpathSync.native(root);
+        let leaseBusy = false;
+        let inventory;
+        try {
+            inventory = await this.withProductiveRun(root, async (lifecycle) => await this.store.withLock(root, async () => {
+                const listed = await this.listRequests(root);
+                for (const request of listed.requests) {
+                    if (request.status !== "pending" && request.status !== "running")
+                        continue;
+                    const handle = await this.store.load(root, request.id);
+                    if (this.recoverInterrupted(handle.state))
+                        await handle.save();
+                }
+                return listed;
+            }, { productiveRunLease: lifecycle.lease }));
+        }
+        catch (error) {
+            if (!(error instanceof ProductiveRunLeaseBusyError))
+                throw error;
+            leaseBusy = true;
+            inventory = await this.listRequests(root);
+        }
+        const requests = [];
+        for (const request of inventory.requests) {
+            if (["pending", "running", "needs_attention", "completed · retained"].includes(request.status)) {
+                requests.push(await this.status(request.id, root));
+            }
+        }
+        return { requests, invalidIds: inventory.invalidIds, leaseBusy };
+    }
     canFollowup(root, requestId, taskId) {
         const active = this.activeControl(realpathSync.native(root), requestId, taskId);
         return active !== undefined && active.task.status === "working" && !active.control.isSealed;
@@ -564,12 +597,13 @@ export class IsolatedRunner {
             if (this.productiveLifecycles.has(root)) {
                 throw new Error("Another Pi Subagent productive request is active in this runner.");
             }
-            const lifecycle = { lease, stopped: false };
+            const lifecycle = { lease, stages: new Set(), stopped: false };
             this.productiveLifecycles.set(root, lifecycle);
             try {
                 return await operation(lifecycle);
             }
             finally {
+                await Promise.allSettled(lifecycle.stages);
                 this.productiveLifecycles.delete(root);
             }
         });
@@ -756,10 +790,11 @@ export class IsolatedRunner {
     async stage(value, root, outerSignal) {
         const action = parseStageRequest(value);
         root = realpathSync.native(root);
-        return await this.withProductiveRun(root, async (lifecycle) => {
-            const handle = await this.store.withLock(root, async () => await this.store.load(root, action.id), { productiveRunLease: lifecycle.lease });
+        const stageSelected = async (handle, duringWave) => {
             const state = handle.state;
-            if (terminal(state) || state.status !== "needs_attention" || (state.integration.refresh && state.integration.refresh.status !== "ready")) {
+            if (terminal(state) || (state.status !== "needs_attention"
+                && !(duringWave && state.status === "running" && (action.action === "stage" || action.action === "resolve")))
+                || (state.integration.refresh && state.integration.refresh.status !== "ready")) {
                 throw new Error("Request is not waiting for Main staging or refresh allocation remains uncertain.");
             }
             const candidate = state.integration.candidates.find((item) => item.taskId === action.taskId && item.attempt === action.attempt
@@ -905,6 +940,7 @@ export class IsolatedRunner {
             if (generation && generation.status !== "staging" && generation.status !== "conflict")
                 throw new Error("Stage action has a stale generation.");
             const previousStage = generation?.stages.at(-1);
+            const pendingAllocation = action.action === "resolve" && previousStage?.status === "pending";
             const expected = previousStage?.status === "staged"
                 ? previousStage.tip : previousStage?.onto ?? generation?.integrationBase;
             if (action.action === "stage" && generation?.stages.some((stage) => stage.status !== "staged")) {
@@ -912,7 +948,7 @@ export class IsolatedRunner {
             }
             if (action.action === "resolve") {
                 const pending = generation?.stages.at(-1);
-                if (!pending || !["staging", "conflict"].includes(pending.status)
+                if (!pending || !["pending", "staging", "conflict"].includes(pending.status)
                     || pending.taskId !== action.taskId || pending.attempt !== action.attempt
                     || !sameIdentity(pending.source, action.candidate)
                     || !sameIdentity(pending.onto, action.expectedTip))
@@ -939,6 +975,18 @@ export class IsolatedRunner {
             const actualMain = await scope.call((context) => this.gitRuntime.inspectMain({ root }, context));
             if (!sameIdentity(actualMain, state.main))
                 throw new Error("Main changed or became dirty; staging is blocked.");
+            if (pendingAllocation) {
+                if (!generation?.worktree || generation.status !== "staging" || generation.stages.length !== 1
+                    || !sameIdentity(action.expectedTip, generation.integrationBase)) {
+                    throw new Error("Pending integration allocation is not an exact initial stage.");
+                }
+                const checkout = generation.worktree;
+                const base = await scope.call((context) => this.integrationGit.inspectCombined(root, checkout, state.main, [], context.signal));
+                if (!sameIdentity(base, generation.integrationBase))
+                    throw new Error("Pending integration checkout is not the clean recorded base.");
+                previousStage.status = "staging";
+                await this.saveProductive(handle); // Explicit resolve proves allocation; merge intent precedes the first merge.
+            }
             if (!generation) {
                 if (action.action !== "stage")
                     throw new Error("No integration generation exists to resolve.");
@@ -983,7 +1031,7 @@ export class IsolatedRunner {
                 }
                 await this.saveProductive(handle); // Exact candidate and previous tip before merge.
             }
-            const outcome = await scope.call((context) => action.action === "stage"
+            const outcome = await scope.call((context) => action.action === "stage" || pendingAllocation
                 ? this.integrationGit.stage(root, worktree, state.main, receipts, worker, candidate.tip, context.signal)
                 : this.integrationGit.reconcileStage(root, worktree, state.main, receipts, worker, candidate.tip, context.signal));
             if (outcome.outcome === "ready" && outcome.value !== "not_started") {
@@ -1008,6 +1056,28 @@ export class IsolatedRunner {
             // Unproved outcomes keep the intent; never replay a merge automatically.
             await this.saveProductive(handle);
             return this.response(state);
+        };
+        const active = this.productiveLifecycles.get(root);
+        if (active?.handle?.state.request.id === action.id) {
+            if (active.stopped)
+                throw new DurableRunStopped(active.handle.state);
+            if (action.action !== "stage" && action.action !== "resolve") {
+                throw new Error("Wait for active workers before revising or rejecting a candidate.");
+            }
+            if (active.stages.size)
+                throw new Error("Another stage or resolution is active; retry after it finishes.");
+            const stage = stageSelected(active.handle, true);
+            active.stages.add(stage);
+            try {
+                return await stage;
+            }
+            finally {
+                active.stages.delete(stage);
+            }
+        }
+        return await this.withProductiveRun(root, async (lifecycle) => {
+            const handle = await this.store.withLock(root, async () => await this.store.load(root, action.id), { productiveRunLease: lifecycle.lease });
+            return await stageSelected(handle, false);
         });
     }
     stageReceipts(generation) {
@@ -1581,6 +1651,8 @@ export class IsolatedRunner {
     }
     async run(handle, scope, forceTextTaskId, stagedSnapshot) {
         const state = handle.state;
+        const lifecycle = this.productiveLifecycles.get(state.root);
+        lifecycle.handle = handle;
         let saveOnExit = true;
         state.status = "running";
         state.updatedAt = this.coordinatorRuntime.now();
@@ -1653,6 +1725,10 @@ export class IsolatedRunner {
                 const dispatched = await Promise.allSettled(ready.map(async (task) => {
                     try {
                         await this.dispatchTask(handle, task, scope);
+                        if (task.kind === "changeset" && task.status === "ready_to_integrate") {
+                            this.retainCandidate(state, task);
+                            await this.saveProductive(handle);
+                        }
                     }
                     catch (error) {
                         this.rethrowStopped(error);
@@ -1681,9 +1757,6 @@ export class IsolatedRunner {
                     forceTextTaskId = undefined;
                     continue;
                 }
-                for (const task of ready)
-                    if (task.kind === "changeset")
-                        this.retainCandidate(state, task);
                 wave.status = "needs_attention";
                 state.status = "needs_attention";
                 await this.saveProductive(handle);
@@ -1712,9 +1785,15 @@ export class IsolatedRunner {
         }
         finally {
             this.closeRequestControls(state.root, state.request.id);
-            if (saveOnExit) {
-                state.updatedAt = this.coordinatorRuntime.now();
-                await this.saveProductive(handle);
+            try {
+                if (saveOnExit) {
+                    state.updatedAt = this.coordinatorRuntime.now();
+                    await this.saveProductive(handle);
+                }
+            }
+            finally {
+                if (lifecycle.handle === handle)
+                    delete lifecycle.handle;
             }
         }
     }
@@ -2279,6 +2358,8 @@ export class IsolatedRunner {
             tip: attempt.candidate, checks: attempt.preliminaryChecks,
             ...(request.judgment ? { review: attempt.preliminaryReview } : {}), worker: "retained",
         });
+        state.integration.candidates.sort((a, b) => state.tasks.findIndex((item) => item.taskId === a.taskId)
+            - state.tasks.findIndex((item) => item.taskId === b.taskId));
     }
     async verifyRetainedTask(handle, task, scope) {
         const attempt = latestAttempt(task);

package/dist/store.d.ts

@@ -1,5 +1,8 @@
 import { type RunState } from "./schema.ts";
 declare const productiveRunLeaseBrand: unique symbol;
+export declare class ProductiveRunLeaseBusyError extends Error {
+    constructor();
+}
 export interface ProductiveRunLease {
     readonly [productiveRunLeaseBrand]: true;
 }

package/dist/store.js

@@ -24,6 +24,11 @@ const LIFECYCLE_LOCK_OPTIONS = {
     retries: { forever: true, factor: 1, minTimeout: 25, maxTimeout: 25 },
 };
 const productiveRunLeaseBrand = Symbol("productiveRunLease");
+export class ProductiveRunLeaseBusyError extends Error {
+    constructor() {
+        super("Another Pi Subagent productive request is active in this repository.");
+    }
+}
 function isMissing(error) {
     return Boolean(error && typeof error === "object" && error.code === "ENOENT");
 }
@@ -127,7 +132,7 @@ export class FileRunStore {
         }
         catch (error) {
             if (isLocked(error)) {
-                throw new Error("Another Pi Subagent productive request is active in this repository.");
+                throw new ProductiveRunLeaseBusyError();
             }
             throw error;
         }

package/dist/worktree.d.ts

@@ -46,8 +46,8 @@ export declare function inspectIndexFlags(cwd: string, run?: GitRunner, signal?:
     hidden: boolean;
     failure?: string;
 }>;
-/** Proves a worktree has no tracked, untracked, ignored, index-hidden, or nested submodule work. */
-export declare function inspectWorktreeDirty(cwd: string, run?: GitRunner): Promise<WorktreeDirtyInspection>;
+/** Proves a worktree has no tracked, untracked, index-hidden, or nested submodule work; cleanup also checks ignored files. */
+export declare function inspectWorktreeDirty(cwd: string, run?: GitRunner, includeIgnored?: boolean): Promise<WorktreeDirtyInspection>;
 /**
  * Inspects and possibly prunes a child worktree after it finishes. Commit count
  * reads the dedicated branch and refuses to prune when checkout HEAD no longer

package/dist/worktree.js

@@ -170,12 +170,12 @@ export async function inspectIndexFlags(cwd, run = runGit, signal) {
         return { hidden: false, failure: `ls-files exit ${flags.code}: ${flags.stderr.trim().slice(0, 200)}` };
     return { hidden: flags.stdout.split("\0").some((entry) => /^(?:[a-z]|S) /.test(entry)) };
 }
-async function inspectDirty(run, cwd) {
+async function inspectDirty(run, cwd, includeIgnored = true) {
     const refreshed = await run(["update-index", "--really-refresh"], cwd);
     if (refreshed.code !== 0 && refreshed.code !== 1) {
         return { dirty: false, failure: `update-index exit ${refreshed.code}: ${refreshed.stderr.trim().slice(0, 200)}` };
     }
-    const status = await run(["status", "--porcelain", "--untracked-files=all", "--ignored=matching", "--ignore-submodules=none"], cwd);
+    const status = await run(["status", "--porcelain", "--untracked-files=all", ...(includeIgnored ? ["--ignored=matching"] : []), "--ignore-submodules=none"], cwd);
     if (status.code !== 0)
         return { dirty: false, failure: `status exit ${status.code}: ${status.stderr.trim().slice(0, 200)}` };
     if (refreshed.code === 1 || status.stdout.trim())
@@ -187,9 +187,9 @@ async function inspectDirty(run, cwd) {
         return { dirty: false, failure: "assume-unchanged or skip-worktree index entries remain" };
     return { dirty: false };
 }
-/** Proves a worktree has no tracked, untracked, ignored, index-hidden, or nested submodule work. */
-export async function inspectWorktreeDirty(cwd, run = runGit) {
-    const root = await inspectDirty(run, cwd);
+/** Proves a worktree has no tracked, untracked, index-hidden, or nested submodule work; cleanup also checks ignored files. */
+export async function inspectWorktreeDirty(cwd, run = runGit, includeIgnored = true) {
+    const root = await inspectDirty(run, cwd, includeIgnored);
     if (root.dirty || root.failure)
         return root;
     const modules = await run(["submodule", "status", "--recursive"], cwd);
@@ -204,14 +204,14 @@ export async function inspectWorktreeDirty(cwd, run = runGit) {
         if (!paths.length)
             return { dirty: false, failure: "initialized submodule paths unavailable" };
         for (const path of paths) {
-            const nested = await inspectDirty(run, path);
+            const nested = await inspectDirty(run, path, includeIgnored);
             if (nested.failure)
                 return { dirty: false, failure: `submodule ${path}: ${nested.failure}` };
             if (nested.dirty)
                 return { dirty: true };
         }
     }
-    const rechecked = await inspectDirty(run, cwd);
+    const rechecked = await inspectDirty(run, cwd, includeIgnored);
     return initializedSubmodules ? { ...rechecked, initializedSubmodules } : rechecked;
 }
 /**
@@ -232,7 +232,7 @@ export async function finalizeChildWorktree(info, run = runGit) {
     const countFailure = counted.code !== 0
         ? `rev-list exit ${counted.code}: ${counted.stderr.trim().slice(0, 200)}`
         : Number.isNaN(commits) ? "rev-list produced non-numeric output" : undefined;
-    const inspection = checkoutExists ? await inspectDirty(run, info.path) : undefined;
+    const inspection = checkoutExists ? await inspectDirty(run, info.path, true) : undefined;
     const measurements = {
         ...(countFailure === undefined ? { commits } : {}),
         ...(inspection?.failure === undefined && inspection !== undefined ? { dirty: inspection.dirty } : {}),