@nklisch/pi-enhanced 0.2.7 → 0.3.1

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/docs/decisions/0004-reconsider-ui-direction.md

@@ -5,6 +5,11 @@ date: 2026-06-18
 
 # 0004 — Reconsider the UI direction from first principles
 
+> Historical vocabulary note: this decision predates the joined/detached clean
+> break. In current code, its "background-only widget" means detached-only;
+> joined runs use their inline result surface. Historical delivery labels below
+> are retained as decision history, not as current API contracts.
+
 ## Status
 
 Accepted.

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

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-subagents",
-  "version": "18.1.0-nklisch.4",
+  "version": "18.2.0-nklisch.1",
   "type": "module",
   "exports": {
     ".": {

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/config/custom-agents.ts

@@ -7,7 +7,7 @@ import { basename, join } from "node:path";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { BUILTIN_TOOL_NAMES } from "#src/config/agent-types";
 import { debugLog } from "#src/debug";
-import type { AgentConfig, ThinkingLevel } from "#src/types";
+import type { AgentConfig, ThinkingLevel, SubagentMode } from "#src/types";
 
 /**
  * Scan for custom agent .md files from multiple locations.
@@ -60,6 +60,27 @@ function loadFromDir(
 
     try {
       const { frontmatter: fm, body } = parseFrontmatter(content);
+      if (fm.run_in_background !== undefined || fm.foreground !== undefined) {
+        const path = join(dir, file);
+        const removedFields = [
+          fm.run_in_background !== undefined ? "run_in_background" : undefined,
+          fm.foreground !== undefined ? "foreground" : undefined,
+        ].filter((field): field is string => field !== undefined).join(", ");
+        // Reserve the name as disabled so a removed field cannot silently fall
+        // through to a lower-priority file or an embedded default with a
+        // different delivery mode. The warning gives the owner an actionable
+        // migration path instead of making the refusal look like a missing file.
+        console.warn(`[pi-subagents] Ignoring ${path}: removed delivery field(s) ${removedFields}; use mode: joined|detached.`);
+        agents.set(name, {
+          name,
+          description: `Invalid agent definition: ${removedFields}`,
+          systemPrompt: "",
+          promptMode: "append",
+          enabled: false,
+          source,
+        });
+        continue;
+      }
       agents.set(name, {
         name,
         displayName: str(fm.display_name),
@@ -68,10 +89,11 @@ function loadFromDir(
         model: str(fm.model),
         thinking: str(fm.thinking) as ThinkingLevel | undefined,
         maxTurns: nonNegativeInt(fm.max_turns),
+        timeoutSeconds: positiveInt(fm.timeout_seconds),
         systemPrompt: body.trim(),
         promptMode: fm.prompt_mode === "replace" ? "replace" : "append",
         inheritContext: fm.inherit_context != null ? fm.inherit_context === true : undefined,
-        runInBackground: fm.run_in_background != null ? fm.run_in_background === true : undefined,
+        mode: fm.mode === "joined" || fm.mode === "detached" ? fm.mode as SubagentMode : undefined,
         enabled: fm.enabled !== false,  // default true; explicitly false disables
         source,
       });
@@ -91,9 +113,14 @@ function str(val: unknown): string | undefined {
   return typeof val === "string" ? val : undefined;
 }
 
-/** Extract a non-negative integer or undefined. 0 means unlimited for max_turns. */
+/** Extract a non-negative integer; 0 means unlimited for max_turns. */
 function nonNegativeInt(val: unknown): number | undefined {
-  return typeof val === "number" && val >= 0 ? val : undefined;
+  return typeof val === "number" && Number.isInteger(val) && val >= 0 ? val : undefined;
+}
+
+/** Extract a positive integer for an active runtime deadline. */
+function positiveInt(val: unknown): number | undefined {
+  return typeof val === "number" && Number.isInteger(val) && val > 0 ? val : undefined;
 }
 
 /**

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/config/default-agents.ts

@@ -17,7 +17,7 @@ export const DEFAULT_AGENTS: Map<string, AgentConfig> = new Map([
       description: "General-purpose agent for complex, multi-step tasks",
       toolGuideline: "- Use general-purpose for complex tasks that need file editing.",
       // builtinToolNames omitted — means "all available tools" (resolved at lookup time)
-      // inheritContext / runInBackground omitted — strategy fields, callers decide per-call.
+      // inheritContext / mode omitted — delivery strategy is selected by the caller.
       // Setting them to false would lock callsite intent (see resolveAgentInvocationConfig in invocation-config.ts).
       systemPrompt: "",
       promptMode: "append",

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/config/invocation-config.ts

@@ -1,10 +1,11 @@
-import type { AgentConfig, ThinkingLevel } from "#src/types";
+import type { AgentConfig, SubagentMode, ThinkingLevel } from "#src/types";
 
 interface AgentInvocationParams {
   model?: string;
   thinking?: string;
   max_turns?: number;
-  run_in_background?: boolean;
+  mode?: SubagentMode;
+  timeout_seconds?: number;
   inherit_context?: boolean;
 }
 
@@ -16,15 +17,17 @@ export function resolveAgentInvocationConfig(
   modelFromParams: boolean;
   thinking?: ThinkingLevel;
   maxTurns?: number;
+  mode: SubagentMode;
+  timeoutSeconds?: number;
   inheritContext: boolean;
-  runInBackground: boolean;
 } {
   return {
     modelInput: agentConfig?.model ?? params.model,
     modelFromParams: agentConfig?.model == null && params.model != null,
     thinking: (agentConfig?.thinking ?? params.thinking) as ThinkingLevel | undefined,
     maxTurns: agentConfig?.maxTurns ?? params.max_turns,
+    mode: agentConfig?.mode ?? params.mode ?? "detached",
+    timeoutSeconds: agentConfig?.timeoutSeconds ?? params.timeout_seconds,
     inheritContext: agentConfig?.inheritContext ?? params.inherit_context ?? false,
-    runInBackground: agentConfig?.runInBackground ?? params.run_in_background ?? false,
   };
 }

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

@@ -4,8 +4,12 @@
  *
  * Tools:
  *   Agent             — LLM-callable: spawn a sub-agent
- *   get_subagent_result  — LLM-callable: check background agent status/result
- *   steer_subagent       — LLM-callable: send a steering message to a running agent
+ *   get_subagent_result  — LLM-callable: inspect bounded subagent status/result
+ *   resume_subagent      — LLM-callable: resume a retained settled session
+ *   stop_subagent         — LLM-callable: request cooperative cancellation
+ *   list_subagents        — LLM-callable: inspect fleet state
+ *   steer_subagent        — LLM-callable: send a steering message to a running agent
+ *   query_subagent_session — LLM-callable: search a bounded child transcript
  *
  * Commands:
  */
@@ -41,7 +45,11 @@ import { deriveSubagentSessionDir } from "#src/session/session-dir";
 import { SettingsManager } from "#src/settings";
 import { AgentTool } from "#src/tools/agent-tool";
 import { GetResultTool } from "#src/tools/get-result-tool";
+import { ListTool } from "#src/tools/list-tool";
+import { QuerySessionTool } from "#src/tools/query-session-tool";
+import { ResumeTool } from "#src/tools/resume-tool";
 import { SteerTool } from "#src/tools/steer-tool";
+import { StopTool } from "#src/tools/stop-tool";
 import { AgentWidget } from "#src/ui/agent-widget";
 import { SessionNavigatorHandler } from "#src/ui/session-navigator";
 import { SubagentsSettingsHandler } from "#src/ui/subagents-settings";
@@ -105,7 +113,7 @@ export default function (pi: ExtensionAPI) {
     lifecycle: createChildLifecyclePublisher((channel, data) => pi.events.emit(channel, data)),
   };
 
-  // ConcurrencyLimiter: schedules background run thunks FIFO against the limit.
+  // ConcurrencyLimiter: schedules run thunks FIFO against the limit.
   // It knows nothing about agents or the manager — dependency direction is strictly manager → limiter.
   const limiter = new ConcurrencyLimiter(() => settings.maxConcurrent);
 
@@ -118,7 +126,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   // Typed service published via Symbol.for() for cross-extension access.
-  // Consumers: const { getSubagentsService } = await import("@gotgenes/pi-subagents");
+  // Consumers: const { getSubagentsService } = await import("@nklisch/pi-subagents");
   const service = new SubagentsServiceAdapter(manager, resolveModel, runtime, registry, settings);
   publishSubagentsService(service);
 
@@ -151,13 +159,14 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerTool(new AgentTool(manager, runtime, settings, registry, getAgentDir()).toToolDefinition());
 
-  // ---- get_subagent_result tool ----
+  // ---- parent-only lifecycle control tools ----
 
+  pi.registerTool(new ResumeTool(manager).toToolDefinition());
+  pi.registerTool(new StopTool(manager).toToolDefinition());
+  pi.registerTool(new ListTool(manager).toToolDefinition());
   pi.registerTool(new GetResultTool(manager, registry).toToolDefinition());
-
-  // ---- steer_subagent tool ----
-
-  pi.registerTool(new SteerTool(manager, pi.events).toToolDefinition());
+  pi.registerTool(new SteerTool({ steer: (id, message) => manager.steer(id, message) }, pi.events).toToolDefinition());
+  pi.registerTool(new QuerySessionTool(manager, (path) => readFileSync(path, "utf8")).toToolDefinition());
 
   // ---- /subagents:settings command ----
 

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/layered-settings.ts

@@ -1,5 +1,5 @@
 /**
- * Generic layered settings loader for `@gotgenes/pi-*` extensions.
+ * Generic layered settings loader for `@nklisch/pi-*` extensions.
  *
  * Extensions that store configuration in JSON files under a global agent
  * directory and a per-project `.pi/` folder share the same three-step idiom:
@@ -15,7 +15,7 @@
  * ## Usage
  *
  * ```typescript
- * import { loadLayeredSettings, type LayeredSettingsSource } from "@gotgenes/pi-subagents/settings";
+ * import { loadLayeredSettings, type LayeredSettingsSource } from "@nklisch/pi-subagents/settings";
  *
  * interface MyConfig { enabled?: boolean; limit?: number }
  *

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

@@ -1,69 +1,35 @@
-/**
- * child-lifecycle.ts — Child-execution lifecycle event contract and publisher.
- *
- * The core publishes its child-execution lifecycle as ordered events on the Pi
- * event bus; reactive consumers (permissions, telemetry, UI) subscribe rather
- * than the core reaching out to them (ADR 0002). This module owns the channel
- * names, payload shapes, and the publisher that emits them.
- *
- * The publisher takes an injected `emit` callback so this module stays free of
- * Pi SDK imports — `index.ts` wires it to `pi.events.emit`.
- */
+/** Ordered child-session lifecycle hooks used by cooperating extensions. */
 
 import { debugLog } from "#src/debug";
+import type { SubagentLifecycleOutcome } from "#src/lifecycle/lifecycle-interceptor";
 
-/** Emitted at the start of a child run, before the session is created. */
 export const SUBAGENT_CHILD_SPAWNING = "subagents:child:spawning";
-
-/**
- * Emitted after the child session is created, immediately before
- * `bindExtensions()`. Carries the child session id consumers need to register
- * the session in `SubagentSessionRegistry`. Subscribers must register
- * synchronously so the entry lands before binding proceeds (see ADR 0002 /
- * the event-bus synchronous-dispatch guarantee).
- */
 export const SUBAGENT_CHILD_SESSION_CREATED = "subagents:child:session-created";
-
-/** Emitted after the child's prompt resolves (normal, steered, or aborted). */
 export const SUBAGENT_CHILD_COMPLETED = "subagents:child:completed";
-
-/** Emitted in the run's `finally` — always fires, on success and error. */
 export const SUBAGENT_CHILD_DISPOSED = "subagents:child:disposed";
 
-/** Payload for `subagents:child:spawning`. */
 export interface ChildSpawningEvent {
   agentName: string;
   parentSessionId?: string;
 }
 
-/** Payload for `subagents:child:session-created`. */
 export interface ChildSessionCreatedEvent {
-  /** Child session id — the registry key. Unique per child; concurrent
-   * siblings of the same parent occupy distinct keys. */
   sessionId: string;
   parentSessionId?: string;
 }
 
-/** Payload for `subagents:child:completed`. */
 export interface ChildCompletedEvent {
   sessionDir: string;
   agentName: string;
-  /** True if the run was hard-aborted (max turns + grace exceeded). */
-  aborted: boolean;
-  /** True if the run was steered to wrap up (soft turn limit) but finished. */
-  steered: boolean;
+  terminalReason: SubagentLifecycleOutcome | "lifecycle_abort";
 }
 
-/** Payload for `subagents:child:disposed`. */
 export interface ChildDisposedEvent {
-  /** Child session id — the registry key. Must match `session-created`. */
   sessionId: string;
 }
 
-/** Narrow emit seam — injected, never imports the Pi SDK. */
 export type LifecycleEmit = (channel: string, data: unknown) => void;
 
-/** Publishes the child-execution lifecycle on the event bus. */
 export interface ChildLifecyclePublisher {
   spawning(event: ChildSpawningEvent): void;
   sessionCreated(event: ChildSessionCreatedEvent): void;
@@ -71,38 +37,19 @@ export interface ChildLifecyclePublisher {
   disposed(event: ChildDisposedEvent): void;
 }
 
-/** Build a publisher backed by an injected `emit` callback. */
-export function createChildLifecyclePublisher(
-  emit: LifecycleEmit,
-): ChildLifecyclePublisher {
+export function createChildLifecyclePublisher(emit: LifecycleEmit): ChildLifecyclePublisher {
   return {
-    spawning(event) {
-      publish(emit, "child lifecycle spawning", SUBAGENT_CHILD_SPAWNING, event);
-    },
-    sessionCreated(event) {
-      publish(emit, "child lifecycle session-created", SUBAGENT_CHILD_SESSION_CREATED, event);
-    },
-    completed(event) {
-      publish(emit, "child lifecycle completed", SUBAGENT_CHILD_COMPLETED, event);
-    },
-    disposed(event) {
-      publish(emit, "child lifecycle disposed", SUBAGENT_CHILD_DISPOSED, event);
-    },
+    spawning: (event) => publish(emit, "child lifecycle spawning", SUBAGENT_CHILD_SPAWNING, event),
+    sessionCreated: (event) => publish(emit, "child lifecycle session-created", SUBAGENT_CHILD_SESSION_CREATED, event),
+    completed: (event) => publish(emit, "child lifecycle completed", SUBAGENT_CHILD_COMPLETED, event),
+    disposed: (event) => publish(emit, "child lifecycle disposed", SUBAGENT_CHILD_DISPOSED, event),
   };
 }
 
-/** EventEmitter listeners are outside the extension runner; isolate their throws. */
-function publish(
-  emit: LifecycleEmit,
-  channelContext: string,
-  channel: string,
-  data: unknown,
-): void {
+function publish(emit: LifecycleEmit, context: string, channel: string, data: unknown): void {
   try {
-    // Pi's event bus is synchronous for child lifecycle hooks by design.
-    // Keep that ordering while preventing a subscriber from escaping into Pi.
     emit(channel, data);
   } catch (error) {
-    debugLog(channelContext, error);
+    debugLog(context, error);
   }
 }

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

@@ -1,84 +1,130 @@
 /**
- * concurrency-limiter.ts — FIFO admission gate for background work.
+ * FIFO admission for every child run.
  *
- * Schedules run closures (thunks) against a dynamic limit, running them in
- * scheduling order as slots free. The limiter knows nothing about agents, IDs,
- * or the manager — it owns only the active count and the pending queue.
- *
- * Every scheduled promise settles: it follows the task's settlement when the
- * task runs, or resolves early if clear() drops it before it starts.
+ * The limiter deliberately knows nothing about subagents. A queued handle can
+ * be cancelled by its owner, which removes that exact entry rather than
+ * leaving a tombstone for a later capacity change.
  */
 
 import { debugLog } from "#src/debug";
 
+export interface AdmissionHandle {
+  readonly promise: Promise<void>;
+  readonly admitted: boolean;
+  cancel(): void;
+}
+
+interface PendingEntry {
+  readonly task: () => Promise<void>;
+  readonly resolve: () => void;
+  readonly reject: (error: unknown) => void;
+  handle: AdmissionHandleImpl;
+}
+
+class AdmissionHandleImpl implements AdmissionHandle {
+  admitted = false;
+  settled = false;
+  private cancelled = false;
+
+  constructor(
+    readonly promise: Promise<void>,
+    private readonly cancelPending: () => void,
+  ) {}
+
+  cancel(): void {
+    if (this.cancelled || this.admitted || this.settled) return;
+    this.cancelled = true;
+    this.cancelPending();
+  }
+
+  markAdmitted(): void {
+    this.admitted = true;
+  }
+
+  markSettled(): void {
+    this.settled = true;
+  }
+
+  get isCancelled(): boolean {
+    return this.cancelled;
+  }
+}
+
 export class ConcurrencyLimiter {
-	private active = 0;
-	private readonly pending: Array<{ start: () => void; settle: () => void }> = [];
-
-	constructor(private readonly getLimit: () => number) {}
-
-	/** Whether a newly scheduled task will wait behind work already admitted. */
-	isSaturated(): boolean {
-		try {
-			return this.active >= this.getLimit();
-		} catch (error) {
-			debugLog("concurrency limiter limit", error);
-			return false;
-		}
-	}
-
-	/**
-	 * Schedule a task to run FIFO once a slot is free.
-	 * Returns a promise that settles with the task, or resolves early if the
-	 * task is dropped by clear() before it starts.
-	 */
-	schedule(task: () => Promise<void>): Promise<void> {
-		const { promise, resolve, reject } = Promise.withResolvers<void>(); // eslint-disable-line @typescript-eslint/no-invalid-void-type -- Promise.withResolvers<void> is valid; rule does not allow void in generic fn call type args
-		this.pending.push({
-			start: () => {
-				this.active++;
-				let taskPromise: Promise<void>;
-				try {
-					taskPromise = Promise.resolve(task());
-				} catch (error) {
-					taskPromise = Promise.reject(error);
-				}
-				taskPromise
-					.then(resolve, reject)
-					.finally(() => {
-						this.active--;
-						try {
-							this.recheck();
-						} catch (error) {
-							// A failing dynamic limit must not strand the slot or
-							// reject the detached cleanup promise.
-							debugLog("concurrency limiter recheck", error);
-						}
-					})
-					.catch((error: unknown) => debugLog("concurrency limiter cleanup", error));
-			},
-			settle: resolve,
-		});
-		this.recheck();
-		return promise;
-	}
-
-	/** Start pending tasks until the limit is reached. Call when the limit may have grown. */
-	recheck(): void {
-		try {
-			while (this.active < this.getLimit()) {
-				const next = this.pending.shift();
-				if (!next) break;
-				next.start();
-			}
-		} catch (error) {
-			debugLog("concurrency limiter recheck", error);
-		}
-	}
-
-	/** Drop all pending tasks, resolving their promises without running them. */
-	clear(): void {
-		const dropped = this.pending.splice(0);
-		for (const task of dropped) task.settle();
-	}
+  private active = 0;
+  private readonly pending: PendingEntry[] = [];
+
+  constructor(private readonly getLimit: () => number) {}
+
+  isSaturated(): boolean {
+    try {
+      return this.active >= this.getLimit();
+    } catch (error) {
+      debugLog("concurrency limiter limit", error);
+      return false;
+    }
+  }
+
+  get activeCount(): number {
+    return this.active;
+  }
+
+  get queuedCount(): number {
+    return this.pending.length;
+  }
+
+  schedule(task: () => Promise<void>): AdmissionHandle {
+    let entry!: PendingEntry;
+    let resolve!: () => void;
+    let reject!: (error: unknown) => void;
+    const promise = new Promise<void>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const handle = new AdmissionHandleImpl(promise, () => {
+      const index = this.pending.indexOf(entry);
+      if (index === -1) return;
+      this.pending.splice(index, 1);
+      handle.markSettled();
+      resolve();
+    });
+    entry = { task, resolve, reject, handle };
+    this.pending.push(entry);
+    this.recheck();
+    return handle;
+  }
+
+  recheck(): void {
+    try {
+      while (this.active < this.getLimit()) {
+        const next = this.pending.shift();
+        if (!next) return;
+        if (next.handle.isCancelled) continue;
+        next.handle.markAdmitted();
+        this.active++;
+        let taskPromise: Promise<void>;
+        try {
+          taskPromise = Promise.resolve(next.task());
+        } catch (error) {
+          taskPromise = Promise.reject(error);
+        }
+        taskPromise.then(next.resolve, next.reject).finally(() => {
+          next.handle.markSettled();
+          this.active--;
+          try {
+            this.recheck();
+          } catch (error) {
+            debugLog("concurrency limiter recheck", error);
+          }
+        }).catch((error: unknown) => {
+          // The task promise was already forwarded to the caller. This catch
+          // only contains a rejected `finally` continuation.
+          debugLog("concurrency limiter cleanup", error);
+        });
+      }
+    } catch (error) {
+      debugLog("concurrency limiter recheck", error);
+    }
+  }
+
 }

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

@@ -24,9 +24,7 @@ import { SubagentSession } from "#src/lifecycle/subagent-session";
 import type { EnvInfo } from "#src/session/env";
 import { type AssemblerIO, assembleSessionConfig } from "#src/session/session-config";
 import type { ParentSessionInfo, ShellExec, SubagentType, ThinkingLevel } from "#src/types";
-
-/** Names of tools registered by this extension that subagents must NOT inherit. */
-const EXCLUDED_TOOL_NAMES = ["subagent", "get_subagent_result", "steer_subagent"];
+import { PARENT_ONLY_TOOL_NAMES, PARENT_ONLY_TOOL_SET } from "#src/tools/parent-tool-registry";
 
 /**
  * Apply the recursion guard: remove this extension's dispatch tools from the
@@ -36,7 +34,7 @@ const EXCLUDED_TOOL_NAMES = ["subagent", "get_subagent_result", "steer_subagent"
 function applyRecursionGuard(session: AgentSession): void {
   const filtered = session
     .getActiveToolNames()
-    .filter((t) => !EXCLUDED_TOOL_NAMES.includes(t));
+    .filter((t) => !PARENT_ONLY_TOOL_SET.has(t));
   session.setActiveToolsByName(filtered);
 }
 
@@ -212,7 +210,7 @@ export async function createSubagentSession(
     modelRegistry: snapshot.modelRegistry,
     modelRuntime: snapshot.modelRuntime,
     model: cfg.model,
-    excludeTools: [...new Set([...cfg.excludedBuiltinToolNames, ...EXCLUDED_TOOL_NAMES])],
+    excludeTools: [...new Set([...cfg.excludedBuiltinToolNames, ...PARENT_ONLY_TOOL_NAMES])],
     resourceLoader: loader,
     thinkingLevel: cfg.thinkingLevel,
   });

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

@@ -8,21 +8,22 @@
  */
 
 import { debugLog } from "#src/debug";
+import type { SubagentMode } from "#src/types";
 
 /** The fixed bound prevents a provider from turning completion into an unbounded loop. */
 export const MAX_LIFECYCLE_CONTINUATION_ROUNDS = 3;
 
 export type SubagentExecutionPhase = "initial" | "resume";
 export type SubagentExecutionOrigin = "tool" | "service";
-export type SubagentExecutionMode = "foreground" | "background";
+export type SubagentExecutionMode = SubagentMode;
 export type SubagentExecutionAdmission = "immediate" | "queued";
-export type SubagentLifecycleOutcome = "completed" | "steered" | "aborted";
+export type SubagentLifecycleOutcome = "completed" | "turn_limit_graceful" | "turn_limit_hard";
 
 /** Immutable identifiers for one initial or resumed execution attempt. */
 export interface SubagentLifecycleIdentity {
   readonly agentId: string;
   readonly sessionId: string;
-  readonly runId: string;
+  readonly runId: number;
   readonly agentType: string;
   readonly parentSessionId?: string;
 }

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

@@ -1,28 +1,10 @@
-/**
- * run-listeners.ts — Per-run observer-unsubscribe and signal-detach handles.
- *
- * Owns the two teardown handles that a Subagent wires at run start (signal
- * listener) and after session creation (record-observer unsub), releasing
- * both atomically when the run ends or the agent is resumed.
- */
+/** Per-run observer-unsubscribe handle. */
 
 import { runSafely } from "#src/debug";
 
-/** Owns the per-run observer-unsubscribe and signal-detach handles. */
+/** Owns the per-run observer-unsubscribe handle. */
 export class RunListeners {
 	private unsub?: () => void;
-	private detach?: () => void;
-
-	/**
-	 * Wire a parent AbortSignal so it triggers onAbort when fired.
-	 * No-op when signal is undefined.
-	 */
-	wireSignal(signal: AbortSignal | undefined, onAbort: () => void): void {
-		if (!signal) return;
-		const listener = () => onAbort();
-		signal.addEventListener("abort", listener, { once: true });
-		this.detach = () => signal.removeEventListener("abort", listener);
-	}
 
 	/** Store the record-observer unsubscribe handle. */
 	attachObserver(unsub: () => void): void {
@@ -33,9 +15,6 @@ export class RunListeners {
 	release(): void {
 		const unsub = this.unsub;
 		this.unsub = undefined;
-		const detach = this.detach;
-		this.detach = undefined;
 		runSafely("subagent observer unsubscribe", () => unsub?.());
-		runSafely("subagent abort listener detach", () => detach?.());
 	}
 }