@nklisch/pi-enhanced 0.2.2 → 0.2.4

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/lifecycle/subagent-manager.ts

@@ -8,7 +8,7 @@
 
 import { randomUUID } from "node:crypto";
 import type { Model } from "@earendil-works/pi-ai";
-import { debugLog, runSafely } from "#src/debug";
+import { debugLog, runDetached, runSafely } from "#src/debug";
 import type { ConcurrencyLimiter } from "#src/lifecycle/concurrency-limiter";
 import type { CreateSubagentSessionParams } from "#src/lifecycle/create-subagent-session";
 import {
@@ -89,6 +89,7 @@ export class SubagentManager {
   private getRunConfig?: () => RunConfig;
   private _workspaceProvider?: WorkspaceProvider;
   private readonly lifecycleInterceptors = new LifecycleInterceptorRegistry();
+  private disposalPromise?: Promise<void>;
 
   /** The registered workspace provider, or undefined when none is registered. */
   get workspaceProvider(): WorkspaceProvider | undefined {
@@ -105,11 +106,7 @@ export class SubagentManager {
     // Timer callbacks sit outside Pi's extension runner, so a malformed setting
     // or disposal failure must remain diagnostic rather than escape into Node.
     this.cleanupInterval = setInterval(() => {
-      try {
-        this.cleanup();
-      } catch (error) {
-        debugLog("retention cleanup", error);
-      }
+      runDetached("retention cleanup", () => this.cleanup());
     }, 60_000);
     this.cleanupInterval.unref();
   }
@@ -293,17 +290,20 @@ export class SubagentManager {
   }
 
   /** Dispose a record's session and remove it from the map. */
-  private removeRecord(id: string, record: Subagent): void {
-    record.disposeSession();
+  private async removeRecord(id: string, record: Subagent): Promise<void> {
+    // Remove first so no caller can acquire a record while its extensions are
+    // shutting down asynchronously.
     this.agents.delete(id);
+    await record.disposeSession();
   }
 
-  private cleanup() {
+  private async cleanup(): Promise<void> {
     const now = Date.now();
     const config = this.getRunConfig?.();
     const consumedMinutes = config?.consumedSessionRetentionMinutes ?? 10;
     const unconsumedMinutes = config?.unconsumedSessionRetentionMinutes ?? 720;
 
+    const releases: Promise<void>[] = [];
     for (const record of this.agents.values()) {
       if (record.isActive() || !record.isSessionReady()) continue;
       const anchor = record.consumed
@@ -314,33 +314,33 @@ export class SubagentManager {
       if (anchor + retentionMinutes * 60_000 > now) continue;
       // Keep the lightweight terminal record and result for the whole parent
       // session; only release the heavy in-memory child session.
-      record.releaseSession();
+      releases.push(record.releaseSession());
     }
+    await Promise.all(releases);
   }
 
   /**
    * Remove all completed/stopped/errored records immediately.
    * Called on session start/switch so tasks from a prior session don't persist.
    */
-  clearCompleted(): void {
+  async clearCompleted(): Promise<void> {
+    const disposals: Promise<void>[] = [];
     for (const [id, record] of this.agents) {
-      if (record.status === "running" || record.status === "queued") continue;
+      if (record.isActive()) continue;
       try {
         this.observer?.onSubagentCleared?.(record);
       } catch (err) {
         debugLog("onSubagentCleared observer", err);
       }
-      this.removeRecord(id, record);
+      disposals.push(this.removeRecord(id, record));
     }
-
+    await Promise.all(disposals);
   }
 
   /** Whether any agents are still running or queued. */
   // fallow-ignore-next-line unused-class-member
   hasRunning(): boolean {
-    return [...this.agents.values()].some(
-      r => r.status === "running" || r.status === "queued",
-    );
+    return [...this.agents.values()].some((record) => record.isActive());
   }
 
   /** Abort all running and queued agents immediately. */
@@ -376,22 +376,31 @@ export class SubagentManager {
   /** Promises of all running/queued agents that have one. */
   private pendingPromises(): Promise<void>[] {
     return [...this.agents.values()]
-      .filter(r => r.status === "running" || r.status === "queued")
+      .filter((record) => record.isActive())
       .map(r => r.promise)
       .filter((p): p is Promise<void> => p != null);
   }
 
-  dispose() {
+  dispose(): Promise<void> {
+    this.disposalPromise ??= this.disposeOnce();
+    return this.disposalPromise;
+  }
+
+  private async disposeOnce(): Promise<void> {
     clearInterval(this.cleanupInterval);
     // Lifecycle callbacks observe the shutdown signal before their registration
-    // disposer runs. Existing no-provider teardown stays synchronous. Consume
-    // async disposer failures because manager disposal is intentionally sync.
-    void this.lifecycleInterceptors.dispose().catch((error) => debugLog("lifecycle interceptor shutdown", error));
-    // Drop pending thunks
-    this.limiter.clear();
-    for (const record of this.agents.values()) {
-      record.disposeSession();
+    // disposer runs. Await their finalizers before child extension teardown.
+    try {
+      await this.lifecycleInterceptors.dispose();
+    } catch (error) {
+      debugLog("lifecycle interceptor shutdown", error);
     }
+
+    // Drop pending thunks and make every record unreachable before awaiting
+    // extension shutdown. No new resume can race teardown from this point.
+    this.limiter.clear();
+    const records = [...this.agents.values()];
     this.agents.clear();
+    await Promise.all(records.map((record) => record.disposeSession()));
   }
 }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/lifecycle/subagent-session.ts

@@ -74,7 +74,7 @@ export interface SubagentSessionMeta {
  * One child AgentSession plus its turn-driving and teardown — born complete.
  */
 export class SubagentSession {
-  private disposed = false;
+  private disposalPromise?: Promise<void>;
 
   constructor(
     private readonly _session: AgentSession,
@@ -309,6 +309,52 @@ export class SubagentSession {
     });
   }
 
+  /** Whether Pi has fully settled the child, including post-run continuation. */
+  get isIdle(): boolean {
+    return this._session.isIdle;
+  }
+
+  /**
+   * Wait for Pi's authoritative idle boundary before starting another prompt.
+   * A record can already look terminal while AgentSession is still finishing an
+   * extension-driven continuation, so domain status alone is insufficient.
+   */
+  async waitUntilIdle(signal?: AbortSignal): Promise<void> {
+    if (this._session.isIdle) return;
+    signal?.throwIfAborted();
+
+    await new Promise<void>((resolve, reject) => {
+      let settled = false;
+      let unsubscribe: () => void = () => {};
+      const cleanup = (): void => {
+        signal?.removeEventListener("abort", onAbort);
+        unsubscribe();
+      };
+      const finish = (): void => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve();
+      };
+      const onAbort = (): void => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(signal?.reason ?? new Error("Resume wait aborted"));
+      };
+
+      unsubscribe = this._session.subscribe((event: AgentSessionEvent) => {
+        if (event.type === "agent_settled" || this._session.isIdle) finish();
+      });
+      signal?.addEventListener("abort", onAbort, { once: true });
+
+      // Close the check/subscribe race: Pi may have settled between the first
+      // isIdle read and listener registration.
+      if (this._session.isIdle) finish();
+      else if (signal?.aborted) onAbort();
+    });
+  }
+
   /** Deliver a steer to the live session. */
   async steer(message: string): Promise<void> {
     await this._session.steer(message);
@@ -349,14 +395,32 @@ export class SubagentSession {
     return this._session.getToolDefinition(name);
   }
 
-  /** Tear down: session.dispose() + emit `disposed` (registry unregister). */
-  dispose(): void {
-    if (this.disposed) return;
-    this.disposed = true;
+  /**
+   * Tear down the child session exactly once.
+   *
+   * AgentSession.dispose() revokes extension contexts immediately but does not
+   * emit the extension lifecycle event. Child-owned extensions need the same
+   * awaited shutdown boundary as root-session replacement so they can cancel
+   * detached work before their Pi API is invalidated.
+   */
+  dispose(): Promise<void> {
+    this.disposalPromise ??= this.disposeOnce();
+    return this.disposalPromise;
+  }
+
+  private async disposeOnce(): Promise<void> {
+    try {
+      await this._session.extensionRunner.emit({
+        type: "session_shutdown",
+        reason: "quit",
+      });
+    } catch (error) {
+      // A faulty extension must not prevent the SDK session from being revoked.
+      debugLog("child extension session_shutdown", error);
+    }
 
     try {
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- dispose may not exist on all session implementations
-      this._session.dispose?.();
+      this._session.dispose();
     } catch (error) {
       debugLog("child session dispose", error);
     }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/lifecycle/subagent.ts

@@ -55,6 +55,14 @@ export type SteerOutcome =
 	| { kind: "buffered" }
 	| { kind: "rejected"; status: SubagentStatus };
 
+/** A second prompt was requested while this record already owned an execution. */
+export class SubagentBusyError extends Error {
+	constructor(agentId: string) {
+		super(`Subagent "${agentId}" is still processing a turn. Wait for it to settle before resuming.`);
+		this.name = "SubagentBusyError";
+	}
+}
+
 /**
  * The execution machinery a Subagent needs to run. A single mandatory
  * collaborator: production (SubagentManager.spawn) always supplies it, so run()
@@ -140,6 +148,11 @@ export class Subagent {
 	private _effectiveThinkingLevel: ThinkingLevel;
 	private readonly listeners = new RunListeners();
 	private readonly workspaceBracket: WorkspaceBracket;
+	/** True while run()/runResume() owns the child prompt boundary. */
+	private executionInFlight = false;
+	/** Synchronous admission lease spanning wind-down, Pi idle, and resume. */
+	private resumeReserved = false;
+	private pendingResumeAbort?: AbortController;
 
 	subagentSession?: SubagentSession;
 	private releasedOutputFile?: string;
@@ -167,7 +180,7 @@ export class Subagent {
 	}
 
 	isActive(): boolean {
-		return this.status === "queued" || this.status === "running";
+		return this.status === "queued" || this.status === "running" || this.resumeReserved;
 	}
 
 	isRunning(): boolean {
@@ -263,6 +276,7 @@ export class Subagent {
 	 * captured internally).
 	 */
 	async run(): Promise<void> {
+		this.executionInFlight = true;
 		this.markRunning(Date.now());
 		try {
 			// Observer callbacks are extension-owned sinks, not part of the agent's
@@ -322,6 +336,8 @@ export class Subagent {
 			// One outer failure path guarantees terminal state, listener release,
 			// workspace cleanup, and the manager's completion funnel.
 			this.failRun(err);
+		} finally {
+			this.executionInFlight = false;
 		}
 	}
 
@@ -371,8 +387,65 @@ export class Subagent {
 					: "Subagent not configured for resume — missing session",
 			));
 		}
-		this._promise = this.runResume(subagentSession, prompt, signal);
-		return this._promise;
+		if (this.status === "queued" || this.status === "running" || this.resumeReserved) {
+			return Promise.reject(new SubagentBusyError(this.id));
+		}
+
+		// Reserve synchronously before the first await. This closes both the
+		// concurrent-resume race and retention's release-while-waiting race.
+		this.resumeReserved = true;
+		const previousExecution = this.executionInFlight ? this._promise : undefined;
+		const resumeAbort = new AbortController();
+		this.pendingResumeAbort = resumeAbort;
+		const resumed = this.resumeWhenReady(
+			subagentSession,
+			previousExecution,
+			prompt,
+			resumeAbort,
+			signal,
+		);
+		this._promise = resumed;
+		return resumed;
+	}
+
+	private async resumeWhenReady(
+		subagentSession: SubagentSession,
+		previousExecution: Promise<void> | undefined,
+		prompt: string,
+		resumeAbort: AbortController,
+		signal?: AbortSignal,
+	): Promise<void> {
+		const waitSignal = signal
+			? AbortSignal.any([resumeAbort.signal, signal])
+			: resumeAbort.signal;
+		let started = false;
+		try {
+			// abort() marks a record stopped before AgentSession.prompt() necessarily
+			// settles. Wait for both the record-owned invocation and Pi's stronger
+			// idle boundary instead of racing a new prompt into the old one.
+			if (previousExecution) await previousExecution;
+			waitSignal.throwIfAborted();
+			await subagentSession.waitUntilIdle(waitSignal);
+			waitSignal.throwIfAborted();
+			if (this.subagentSession !== subagentSession) {
+				throw new Error("Subagent session was released while waiting to resume");
+			}
+
+			started = true;
+			this.executionInFlight = true;
+			this.resetForResume(Date.now(), resumeAbort);
+			await this.runResume(subagentSession, prompt, signal);
+		} catch (error) {
+			if (waitSignal.aborted) this.markStopped();
+			else this.markError(error);
+			if (!started) {
+				runSafely("subagent onResumedFinished observer", () => this.execution.observer?.onResumedFinished?.(this));
+			}
+		} finally {
+			if (started) this.executionInFlight = false;
+			if (this.pendingResumeAbort === resumeAbort) this.pendingResumeAbort = undefined;
+			this.resumeReserved = false;
+		}
 	}
 
 	private async runResume(
@@ -380,7 +453,6 @@ export class Subagent {
 		prompt: string,
 		signal?: AbortSignal,
 	): Promise<void> {
-		this.resetForResume(Date.now());
 		const executionSignal = signal
 			? AbortSignal.any([this.abortController.signal, signal])
 			: this.abortController.signal;
@@ -420,7 +492,7 @@ export class Subagent {
 	/** Wait for the current queued, running, or resumed execution without cancelling it. */
 	async waitUntilSettled(signal: AbortSignal): Promise<void> {
 		const run = this._promise;
-		if (!run || !this.isActive() || signal.aborted) return;
+		if (!run || (!this.executionInFlight && !this.resumeReserved) || signal.aborted) return;
 		await settleOrAbort(run, signal);
 	}
 
@@ -535,8 +607,9 @@ export class Subagent {
 	 * then no-ops on the queued-status guard.
 	 */
 	abort(): boolean {
-		if (this.status !== "running") return false;
+		if (this.status !== "running" && !this.resumeReserved) return false;
 		this.abortController.abort();
+		this.pendingResumeAbort?.abort();
 		this.markStopped();
 		return true;
 	}
@@ -561,8 +634,8 @@ export class Subagent {
 	}
 
 	/** Reset for resume: running status, new startedAt, clear completedAt/result/error/listeners. */
-	resetForResume(startedAt: number): void {
-		this.abortController = new AbortController();
+	resetForResume(startedAt: number, controller = new AbortController()): void {
+		this.abortController = controller;
 		this.state.resetForResume(startedAt);
 		this.listeners.release();
 	}
@@ -598,18 +671,25 @@ export class Subagent {
 	}
 
 	/** Dispose the wrapped session, firing the `disposed` lifecycle event. */
-	disposeSession(): void {
-		this.subagentSession?.dispose();
+	async disposeSession(): Promise<void> {
+		const session = this.subagentSession;
+		if (!session) return;
+		// Detach first: callers must not admit a resume while asynchronous
+		// extension shutdown is in progress.
+		this.subagentSession = undefined;
+		await session.dispose();
 	}
 
 	/** Release heavy session state while preserving the transcript pointer and record. */
-	releaseSession(): void {
+	async releaseSession(): Promise<void> {
 		const session = this.subagentSession;
 		if (!session) return;
 		this.releasedOutputFile = session.outputFile;
-		session.dispose();
+		// The record becomes non-resumable atomically at release admission, not
+		// after extension shutdown finishes.
 		this.subagentSession = undefined;
 		this._sessionReleased = true;
+		await session.dispose();
 	}
 
 	/** Fail a run: mark error, release listeners, best-effort workspace dispose, notify observer. */

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/tools/agent-tool.ts

@@ -7,6 +7,7 @@ import { AgentTypeRegistry } from "#src/config/agent-types";
 import { THINKING_LEVELS_DESCRIPTION } from "#src/config/thinking-levels";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { AgentSpawnConfig } from "#src/lifecycle/subagent-manager";
+import { SubagentBusyError } from "#src/lifecycle/subagent";
 import { spawnBackground } from "#src/tools/background-spawner";
 import { runForeground } from "#src/tools/foreground-runner";
 import { buildAgentGuidelines, buildDetails, buildTypeListText, textResult } from "#src/tools/helpers";
@@ -97,11 +98,17 @@ export class AgentTool {
 						: `Agent "${params.resume}" has no active session to resume.`,
 				);
 			}
-			const record = await this.manager.resume(
-				params.resume as string,
-				params.prompt as string,
-				signal ?? new AbortController().signal,
-			);
+			let record: Subagent | undefined;
+			try {
+				record = await this.manager.resume(
+					params.resume as string,
+					params.prompt as string,
+					signal ?? new AbortController().signal,
+				);
+			} catch (error) {
+				if (error instanceof SubagentBusyError) return textResult(error.message);
+				throw error;
+			}
 			if (!record) {
 				return textResult(`Failed to resume agent "${params.resume}".`);
 			}

package/node_modules/@nklisch/pi-plugins/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@nklisch/pi-plugins",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "private": false,
-  "description": "Native marketplace and plugin lifecycle management for Pi, with Claude Code and Codex compatibility.",
+  "description": "A small filesystem-first marketplace and plugin host for Pi.",
   "license": "MIT",
   "author": "Nathan Klisch",
   "repository": {
@@ -54,34 +54,22 @@
     "clean:dist": "node -e \"import('node:fs/promises').then(fs => fs.rm('dist', { recursive: true, force: true }))\"",
     "build": "npm run clean && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "boundaries": "depcruise src --config .dependency-cruiser.cjs",
     "test:unit": "vitest run",
-    "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "test:e2e:production": "vitest run --config vitest.e2e.config.ts test/e2e/production",
-    "test:e2e:production:final": "vitest run --config vitest.e2e.config.ts test/e2e/production/final-packed-registry.e2e.test.ts",
-    "test:e2e:infrastructure": "vitest run --config vitest.e2e.config.ts test/e2e/infrastructure/packed-pi-smoke.e2e.test.ts",
-    "test:package": "npm run build && node test/compiled-package-import.mjs && node test/compiled-pi-package-import.mjs && node test/packed-pi-consumer.mjs",
-    "test": "npm run typecheck && npm run boundaries && npm run test:unit && npm run test:package"
+    "test:package": "npm run build && node test/compiled-package-import.mjs && node test/compiled-pi-package-import.mjs",
+    "test": "npm run typecheck && npm run test:unit && npm run test:package"
   },
   "bundledDependencies": [
     "@nklisch/pi-subagents"
   ],
   "dependencies": {
-    "@nklisch/pi-mcp-adapter": "2.21.0-nklisch.1",
-    "@nklisch/pi-subagents": "18.1.0-nklisch.2",
-    "jiti": "2.7.0",
-    "semver": "7.8.1",
-    "smol-toml": "^1.7.0",
-    "yaml": "2.9.0",
-    "zod": "^4.0.0"
+    "@nklisch/pi-mcp-adapter": "2.21.0-nklisch.2",
+    "@nklisch/pi-subagents": "18.1.0-nklisch.3",
+    "jiti": "2.7.0"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.82.0",
     "@earendil-works/pi-tui": "0.82.0",
-    "@swc/core": "^1.15.43",
     "@types/node": "^24.0.0",
-    "@types/semver": "^7.7.1",
-    "dependency-cruiser": "^17.0.0",
     "typescript": ">=7.0.0 <8",
     "vitest": "^4.0.0"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-enhanced",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Pi, enhanced — one install for nklisch's full harness: policy-gated command review, plugin marketplace, subagents, background tasks, research tools, search, model modes, and a curated UX set.",
   "author": {
     "name": "nklisch"
@@ -70,7 +70,7 @@
     "@nklisch/pi-clearance": "^0",
     "@nklisch/pi-conveniences": "^0",
     "@nklisch/pi-fff-compat": "^0",
-    "@nklisch/pi-mcp-adapter": "2.21.0-nklisch.1",
+    "@nklisch/pi-mcp-adapter": "2.21.0-nklisch.2",
     "@nklisch/pi-model-modes": "^0",
     "@nklisch/pi-plugins": "^0",
     "@sinclair/typebox": "^0.34.49",

package/node_modules/@nklisch/pi-plugins/dist/application/abort-rejection.d.ts

@@ -1 +0,0 @@
-export declare function isAbortRejection(error: unknown): boolean;

package/node_modules/@nklisch/pi-plugins/dist/application/abort-rejection.js

@@ -1,7 +0,0 @@
-export function isAbortRejection(error) {
-    if (error === null || typeof error !== "object")
-        return false;
-    const candidate = error;
-    return candidate.name === "AbortError" || candidate.code === "ABORT_ERR";
-}
-//# sourceMappingURL=abort-rejection.js.map

package/node_modules/@nklisch/pi-plugins/dist/application/abort-rejection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abort-rejection.js","sourceRoot":"","sources":["../../src/application/abort-rejection.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,SAAS,GAAG,KAA6D,CAAC;IAChF,OAAO,SAAS,CAAC,IAAI,KAAK,YAAY,IAAI,SAAS,CAAC,IAAI,KAAK,WAAW,CAAC;AAC3E,CAAC"}