@henryqw/pi-subagent 22.2.0 → 22.2.1

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/integration-git.js

@@ -45,12 +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 first = (await requireGit(["worktree", "list", "--porcelain", "-z"], root, signal)).split("\0")[0];
-    const primary = first.startsWith("worktree ") ? await realpath(first.slice("worktree ".length)) : "";
+    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 !== primary || info.cwd !== info.path
+        || info.repoRoot !== repoRoot || info.cwd !== info.path
         || !/^pi-subagent\/subagent-[0-9a-f]{24}$/.test(info.branch)
-        || info.path !== join(primary, ".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/runner.js

@@ -940,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")) {
@@ -974,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.");
@@ -1018,15 +1031,9 @@ export class IsolatedRunner {
                 }
                 await this.saveProductive(handle); // Exact candidate and previous tip before merge.
             }
-            let 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 (action.action === "resolve" && stage.status === "pending"
-                && outcome.outcome === "ready" && outcome.value === "not_started") {
-                stage.status = "staging";
-                await this.saveProductive(handle); // Read-only proof before Main's explicit merge request.
-                outcome = await scope.call((context) => this.integrationGit.stage(root, worktree, state.main, receipts, worker, candidate.tip, context.signal));
-            }
             if (outcome.outcome === "ready" && outcome.value !== "not_started") {
                 stage.status = "staged";
                 stage.tip = outcome.value.tip;

package/dist/worktree.d.ts

@@ -46,7 +46,7 @@ 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. */
+/** 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

package/dist/worktree.js

@@ -187,7 +187,7 @@ async function inspectDirty(run, cwd, includeIgnored = true) {
         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. */
+/** 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)
@@ -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 } : {}),

package/extensions/isolated.ts

@@ -65,18 +65,19 @@ export const createIsolatedComponents: CreateIsolatedComponents = ({
 		: await directRunProcess(command, args, options);
 	const resolveRoot = createCanonicalGitRootResolver({ runProcess });
 	const git = new CheckedGitRuntime({ runProcess, executeReview: createExactJudgmentExecutor(executor) });
-	const host = new HerdrHostRuntime({ inspectInFlightTaskCandidate: git.inspectInFlightTaskCandidate.bind(git), runProcess });
+	const executionBudget = () => ({
+		maxTurns: policy.maxTurns,
+		maxMs: null,
+		...(policy.maxTokens === undefined ? {} : { maxTokens: policy.maxTokens }),
+	});
+	const host = new HerdrHostRuntime({ inspectInFlightTaskCandidate: git.inspectInFlightTaskCandidate.bind(git), runProcess, executionBudget });
 	const coordinator = new RoleLaunchRuntime({
 		pi,
 		context,
 		resolveRoot,
 		preflightHost: async ({ root }, operation) => await host.preflightHost({ root }, operation),
 		inspectMain: async (input, operation) => await git.inspectMain(input, operation),
-		executionBudget: () => ({
-			maxTurns: policy.maxTurns,
-			maxMs: null,
-			...(policy.maxTokens === undefined ? {} : { maxTokens: policy.maxTokens }),
-		}),
+		executionBudget,
 	});
 	return {
 		resolveRoot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "22.2.0",
+  "version": "22.2.1",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",