@ryan_nookpi/pi-extension-subagent 0.5.6 → 0.5.8

package/index.ts

@@ -28,6 +28,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SubagentAsyncTasks } from "./async-task-lifecycle.js";
 import { HANG_CHECK_INTERVAL_MS } from "./constants.js";
 import { SUBAGENT_COMMANDS, SUBAGENT_SHORTCUTS, type SubagentCommandName } from "./registration-manifest.js";
 
@@ -40,6 +41,7 @@ interface SubagentCore {
 }
 
 export default function (pi: ExtensionAPI) {
+	const asyncTasks = new SubagentAsyncTasks(pi);
 	let core: SubagentCore | null = null;
 	let corePromise: Promise<SubagentCore> | null = null;
 	/** Serializes session lifecycle work so events apply in dispatch order. */
@@ -54,6 +56,7 @@ export default function (pi: ExtensionAPI) {
 				import("./store.js"),
 			]);
 			const store = storeMod.createStore();
+			store.asyncTasks = asyncTasks;
 			const registrations = commands.registerAll(pi, store);
 			core = { store, commands, registrations, escalation, lifecycle };
 			return core;
@@ -116,11 +119,24 @@ export default function (pi: ExtensionAPI) {
 	}, 0);
 
 	let hangCheckTimer: ReturnType<typeof setInterval> | undefined;
+	let sessionGeneration = 0;
 
 	pi.on("session_start", (_event, ctx) => {
-		enqueue((c) => {
+		const generation = ++sessionGeneration;
+		const sessionId = ctx.sessionManager.getSessionId();
+		// Fence tool admission synchronously, before lazy lifecycle work can yield.
+		try {
+			if (pi.events) asyncTasks.bind(sessionId);
+		} catch (error) {
+			process.stderr.write(`[subagent] session binding failed: ${error instanceof Error ? error.message : error}\n`);
+			return;
+		}
+		enqueue(async (c) => {
+			if (generation !== sessionGeneration) return;
+			if (pi.events) await asyncTasks.provider.whenDiscovered();
+			if (generation !== sessionGeneration || ctx.sessionManager.getSessionId() !== sessionId) return;
 			c.store.disposed = false;
-			c.commands.handleSessionStart(pi, c.store, ctx as unknown as ExtensionContext);
+			c.commands.handleSessionStart(asyncTasks.wrap(pi), c.store, ctx as unknown as ExtensionContext);
 			c.escalation.maybeRegisterAskMaster(pi, ctx);
 		});
 		if (!hangCheckTimer) {
@@ -131,6 +147,8 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async (event) => {
+		++sessionGeneration;
+		asyncTasks.shutdown();
 		if (hangCheckTimer) {
 			clearInterval(hangCheckTimer);
 			hangCheckTimer = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryan_nookpi/pi-extension-subagent",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Asynchronous subagent delegation for pi with run, batch, chain, and continuation workflows.",
   "license": "MIT",
   "repository": {
@@ -39,6 +39,8 @@
     "format.ts",
     "group-pending.ts",
     "index.ts",
+    "async-task-provider.ts",
+    "async-task-lifecycle.ts",
     "lifecycle.ts",
     "invocation-queue.ts",
     "live-preview.ts",

package/run-utils.ts

@@ -242,18 +242,18 @@ export function snapshotBatchGroup(
 	let failed = 0;
 	let aborted = 0;
 	const members: FinishedGroupMember[] = batch.runIds.map((runId) => {
-		const run = store.commandRuns.get(runId);
+		const run = batch.completedRuns.get(runId) ?? store.commandRuns.get(runId);
 		if (!run) {
 			if (batch.abortedRunIds.has(runId)) aborted++;
 			else if (batch.failedRunIds.has(runId)) failed++;
 			return {
 				summaryLine: `#${runId} [gone] (run no longer available)`,
-				output: batch.pendingResults.get(runId)?.trim() || "(no output)",
+				output: "(no output)",
 			};
 		}
 		if (run.errorClass === "aborted" || batch.abortedRunIds.has(runId)) aborted++;
 		else if (run.status === "error" || batch.failedRunIds.has(runId)) failed++;
-		return { summaryLine: formatCommandRunSummary(run), output: memberOutput(run, batch.pendingResults.get(runId)) };
+		return { summaryLine: formatCommandRunSummary(run), output: memberOutput(run) };
 	});
 	return {
 		groupId: batch.batchId,

package/runner.ts

@@ -7,6 +7,7 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import type { Message } from "@earendil-works/pi-ai";
 import type { AgentConfig } from "./agents.js";
+import { currentResourceObserver, trackSubagentRunner } from "./async-task-lifecycle.js";
 import { buildClaudeArgs } from "./claude-args.js";
 import { createSidecarWriter } from "./claude-sidecar-writer.js";
 import {
@@ -43,6 +44,7 @@ import {
 } from "./utils/agent-utils.js";
 
 export interface RunSingleAgentSessionConfig {
+	asyncRunId?: number;
 	sessionFile?: string;
 	resumeSessionId?: string;
 	sidecarSessionFile?: string;
@@ -198,7 +200,21 @@ export function computeAgentAliasHints(agents: AgentConfig[]): string {
 
 // ─── Single Agent Execution ──────────────────────────────────────────────────
 
-export async function runSingleAgent(
+export async function runSingleAgent(...args: Parameters<typeof runSingleAgentUntracked>): Promise<SingleResult> {
+	const config = typeof args[8] === "object" ? args[8] : undefined;
+	return trackSubagentRunner(
+		args[2],
+		args[5],
+		(signal) => {
+			const invocation: Parameters<typeof runSingleAgentUntracked> = [...args];
+			invocation[5] = signal;
+			return runSingleAgentUntracked(...invocation);
+		},
+		config?.asyncRunId,
+	);
+}
+
+async function runSingleAgentUntracked(
 	defaultCwd: string,
 	agents: AgentConfig[],
 	agentName: string,
@@ -209,6 +225,7 @@ export async function runSingleAgent(
 	makeDetails: (results: SingleResult[]) => SubagentDetails,
 	sessionConfig?: string | RunSingleAgentSessionConfig,
 ): Promise<SingleResult> {
+	currentResourceObserver()("settled");
 	const normalizedSessionConfig = normalizeRunSessionConfig(sessionConfig);
 	const sessionFile = normalizedSessionConfig.sessionFile;
 	const resumeSessionId = normalizedSessionConfig.resumeSessionId;
@@ -246,7 +263,10 @@ export async function runSingleAgent(
 
 	if (agent.runtime === "claude") {
 		if (resolveClaudeRuntimeMode(defaultCwd) === "sdk") {
+			// SDK query.close() has no process-exit acknowledgement.
+			currentResourceObserver()("unknown");
 			const { runClaudeAgentViaSdk } = await import("./claude-sdk-runner.js");
+			if (signal?.aborted) throw new Error("Subagent was aborted");
 			return runClaudeAgentViaSdk(
 				defaultCwd,
 				agent,
@@ -300,6 +320,7 @@ async function runClaudeAgent(
 	sidecarSessionFile?: string,
 	onDiagnostic?: RunnerDiagnosticSink,
 ): Promise<SingleResult> {
+	const observeResource = currentResourceObserver();
 	try {
 		validateClaudeRuntimeModel(agent.model);
 	} catch (err: any) {
@@ -392,7 +413,9 @@ async function runClaudeAgent(
 		});
 
 		const exitCode = await new Promise<number>((resolve) => {
+			if (signal?.aborted) throw new Error("Subagent was aborted");
 			const proc = spawn("claude", args, { cwd: defaultCwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+			observeResource("active");
 			let buffer = "";
 			let procExited = false;
 			let settled = false;
@@ -564,6 +587,7 @@ async function runClaudeAgent(
 			});
 
 			proc.on("exit", (code, terminationSignal) => {
+				observeResource("settled");
 				procExited = true;
 				lastExitCode = normalizeChildExitCode(code, terminationSignal, lastExitCode);
 				lastProcessSignal = terminationSignal;
@@ -583,6 +607,7 @@ async function runClaudeAgent(
 			});
 
 			proc.on("close", (code, terminationSignal) => {
+				observeResource("settled");
 				procExited = true;
 				lastProcessSignal = terminationSignal ?? lastProcessSignal;
 				diagnose({ event: "close", childPid: proc.pid, code, signal: terminationSignal });
@@ -593,6 +618,7 @@ async function runClaudeAgent(
 			});
 
 			proc.on("error", (error) => {
+				observeResource(proc.pid ? "unknown" : "settled");
 				procExited = true;
 				stderrBuf += `[runner] process error: ${error?.message || String(error)}\n`;
 				diagnose({
@@ -658,6 +684,7 @@ async function runPiAgent(
 	persistedSessionBaseOffset = 0,
 	onDiagnostic?: RunnerDiagnosticSink,
 ): Promise<SingleResult> {
+	const observeResource = currentResourceObserver();
 	const args: string[] = ["--mode", "json", "-p"];
 	if (sessionFile) args.push("--session", sessionFile);
 	else args.push("--no-session");
@@ -721,7 +748,9 @@ async function runPiAgent(
 		args.push(normalizeTaskForSubagentPrompt(task));
 
 		const exitCode = await new Promise<number>((resolve) => {
+			if (signal?.aborted) throw new Error("Subagent was aborted");
 			const proc = spawn("pi", args, { cwd: defaultCwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+			observeResource("active");
 			let buffer = "";
 			let procExited = false;
 			let settled = false;
@@ -1089,6 +1118,7 @@ async function runPiAgent(
 			});
 
 			proc.on("exit", (code, terminationSignal) => {
+				observeResource("settled");
 				procExited = true;
 				lastExitCode = normalizeChildExitCode(code, terminationSignal, lastExitCode);
 				lastProcessSignal = terminationSignal;
@@ -1105,6 +1135,7 @@ async function runPiAgent(
 			});
 
 			proc.on("close", (code, terminationSignal) => {
+				observeResource("settled");
 				procExited = true;
 				lastProcessSignal = terminationSignal ?? lastProcessSignal;
 				diagnose({ event: "close", childPid: proc.pid, code, signal: terminationSignal });
@@ -1113,6 +1144,7 @@ async function runPiAgent(
 			});
 
 			proc.on("error", (error) => {
+				observeResource(proc.pid ? "unknown" : "settled");
 				procExited = true;
 				appendStderrDiagnostic(currentResult, `process error: ${error?.message || String(error)}`);
 				diagnose({

package/store.ts

@@ -18,6 +18,7 @@ import type { WidgetRenderCtx } from "./widget.js";
 export const COLLAPSED_ITEM_COUNT = 10;
 
 export interface SubagentStore {
+	asyncTasks?: import("./async-task-lifecycle.js").SubagentAsyncTasks;
 	/** True after session_shutdown; async callbacks must not use captured runtime APIs. */
 	disposed: boolean;
 	commandRuns: Map<number, CommandRunState>;