@nklisch/pi-enhanced 0.1.2 → 0.1.4

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/docs/comparison-with-upstream.md

@@ -1,77 +1,82 @@
 # Comparison with upstream
 
-`@gotgenes/pi-subagents` began as a fork of [`tintinweb/pi-subagents`](https://github.com/tintinweb/pi-subagents) by [@tintinweb](https://github.com/tintinweb).
-The original design — autonomous subagent dispatch, the live widget, the conversation viewer, custom agent types — is the foundation everything here builds on.
+`@nklisch/pi-subagents` is a maintained fork of `@gotgenes/pi-subagents`, which began as a hard fork of [`@tintinweb/pi-subagents`](https://github.com/tintinweb/pi-subagents). This page explains which ideas this fork preserves, adapts, or leaves upstream.
 
-It has since become an independently maintained hard fork.
-It follows its own architecture, does not track upstream as a merge target, and cherry-picks upstream fixes only when they fit its scope.
-This document compares the fork against the current upstream release so you can choose between them.
+The source tree was reviewed against `@gotgenes/pi-subagents` 19.2.1 and `@tintinweb/pi-subagents` 0.14.3 plus its unreleased changelog. The local package version remains independently managed; see [Fork maintenance](./FORK-MAINTENANCE.md) for provenance and release rules.
 
-Versions compared: `@gotgenes/pi-subagents` 16.2.1 and `@tintinweb/pi-subagents` 0.10.3 (current at the time of writing).
+## Shared core
 
-## At a glance
+All three implementations provide in-process foreground and background agents, custom agent definitions, concurrency control, steering, result retrieval, session resume, model selection, thinking control, and completion notifications.
 
-| Aspect          | @gotgenes/pi-subagents          | @tintinweb/pi-subagents                 |
-| --------------- | ------------------------------- | --------------------------------------- |
-| Philosophy      | Minimal, composable core        | Batteries-included, all-in-one          |
-| Pi peer scope   | `@earendil-works/pi-*` (>=0.75) | `@earendil-works/pi-*` (>=0.74)         |
-| Spawn tool name | `subagent`                      | `Agent`                                 |
-| Runtime deps    | `@sinclair/typebox`             | `@sinclair/typebox`, `croner`, `nanoid` |
-| License         | MIT                             | MIT                                     |
+The direct `gotgenes` lineage and this fork also share a focused-core architecture:
 
-Both ship TypeScript source directly (Pi runs `./src/index.ts`) and target the same `@earendil-works/pi-*` Pi.
-The peer-dep migration that prompted the original fork has since landed upstream, so the Pi scope is no longer a differentiator.
+- typed cross-extension service access;
+- child-session lifecycle events;
+- workspace and permission integration through companion packages;
+- native read-only session transcripts;
+- no built-in scheduling, memory, worktrees, or event RPC.
 
-## Common ground
+## What this fork preserves beyond direct upstream
 
-Both extensions provide the same core experience:
+This fork retains several contracts that must survive selective upstream ports:
 
-- Foreground/background subagents with a live above-editor widget and a conversation viewer.
-- Custom agent types defined in `.pi/agents/<name>.md` with YAML frontmatter (system prompt, model, thinking, tools).
-- Fuzzy model selection, context inheritance, mid-run steering, session resume, and graceful turn limits.
-- A `pi.events` lifecycle bus (`subagents:created`, `started`, `completed`, `failed`, `steered`, `compacted`).
+- ordered lifecycle interception for prompt, result, and continuation decisions;
+- exact `provider/id` and elapsed or final runtime on every operator status surface;
+- a typed service and deterministic child-session lifecycle;
+- only `general-purpose` and `Explore` as built-in agents;
+- model runtime inheritance for runtime-registered providers and authentication;
+- inherited extension tools through a registration-open denylist, with recursive orchestration tools excluded;
+- provider terminal failures reported as failures instead of successful empty or stale results.
 
-## What upstream has that this fork does not
+A mechanical rebase is unsafe because direct upstream may change or remove these surfaces.
 
-Upstream is the batteries-included option.
-It keeps several subsystems built in that this fork deliberately removed or delegated:
+## Reliability changes adapted from direct upstream
 
-| Capability              | @tintinweb/pi-subagents                           | @gotgenes/pi-subagents                                                                                                                            |
-| ----------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Tool restrictions       | `disallowed_tools` frontmatter (denylist)         | Delegated — `permission:` via [`@gotgenes/pi-permission-system`](https://github.com/gotgenes/pi-packages/tree/main/packages/pi-permission-system) |
-| Worktree isolation      | Built-in                                          | Delegated — [`@gotgenes/pi-subagents-worktrees`](https://github.com/gotgenes/pi-packages/tree/main/packages/pi-subagents-worktrees)               |
-| Persistent agent memory | `memory:` frontmatter (project / local / user)    | Removed                                                                                                                                           |
-| Skill preloading        | `skills:` frontmatter (preload named skills)      | Removed — children always inherit the parent's skills                                                                                             |
-| Scheduling              | Cron / interval / one-shot subagents (`schedule`) | Removed                                                                                                                                           |
-| Cross-extension control | `subagents:rpc:*` event RPC                       | Replaced by a typed service (below)                                                                                                               |
-| Model-scope enforcement | `enabledModels` allowlist validation              | Not included                                                                                                                                      |
-| Notifications           | Smart group-join consolidation                    | Individual per-agent notifications                                                                                                                |
+This fork selectively carries the useful 18.1–19.2 reliability work:
 
-## What this fork adds
+- queued and resumed runs are awaitable through the current record promise;
+- interrupting `get_subagent_result(wait: true)` ends only the wait;
+- queued stops follow the terminal lifecycle and state that no work started;
+- consumption-aware retention keeps terminal records for the parent session while releasing heavy live sessions on separate consumed and unconsumed windows;
+- completion notifications wait for the parent `agent_settled` boundary and recheck consumption;
+- parent ESC abort-all behavior is configurable;
+- resumed turns emit `subagents:resumed`;
+- contradictory inherited cwd footer text is removed for workspace-backed children;
+- terminal glyphs and XML escaping are safe across common terminal and structured-message contexts.
 
-This fork is a minimal core that other extensions build on, plus a small companion ecosystem:
+These changes require `@earendil-works/pi-coding-agent >=0.80.5`.
 
-- **Typed service API** — `SubagentsService` exposed via `Symbol.for()` accessors, so another extension can spawn and manage subagents without importing this package or relying on ad-hoc event RPC.
-- **Child-session lifecycle events** — `subagents:child:spawning` / `session-created` / `completed` / `disposed`, with `session-created` firing synchronously before `bindExtensions()` so consumers can register the child session deterministically.
-- **`<active_agent>` system-prompt tag** — lets [`@gotgenes/pi-permission-system`](https://github.com/gotgenes/pi-packages/tree/main/packages/pi-permission-system) resolve per-agent `permission:` frontmatter (allow / ask / deny — richer than a binary denylist) inside the child session.
-- **Companion packages** — permission policy and worktree isolation live in dedicated packages rather than the core.
-- **Re-architected codebase** — decomposed into seven domains behind a typed public API boundary, backed by ~994 tests.
+## Ideas adapted from the original upstream
 
-## Which should I use?
+The original `tintinweb` project remains the broader product laboratory. This fork adapted a narrow subset that fits its focused-core direction:
 
-**Use `@tintinweb/pi-subagents`** if you want a single, batteries-included extension with nothing else to install: built-in tool denylist, scheduled / cron subagents, cross-extension RPC, and model-scope enforcement in one package.
-It is the canonical upstream and the original.
+- final assistant `stopReason` classification for provider errors and empty output-limit failures;
+- modern parent `ModelRuntime` forwarding;
+- the `max` thinking level in model-facing and human-facing descriptions;
+- optional fail-closed unknown-agent resolution;
+- `.agents/agents` as a read-only shared project discovery tier.
 
-**Use `@gotgenes/pi-subagents`** if you want a minimal, composable core: richer allow / ask / deny permissions and worktree isolation through companion packages, a typed service plus lifecycle events to build your own extensions on, and an actively refactored codebase — and you do not need built-in scheduling, RPC, or model-scope enforcement.
+## Capabilities intentionally left upstream
 
-The spawn tool is named `subagent` here versus `Agent` upstream, so prompts and docs that hard-code the tool name are not drop-in portable between the two.
+| Capability | `@tintinweb/pi-subagents` | This fork |
+| --- | --- | --- |
+| Nested subagent delegation | Available or under active development | Excluded; recursion remains disabled |
+| Scheduling | Cron, interval, and one-shot jobs | Separate extension concern |
+| Persistent agent memory | Built in | Excluded |
+| Worktree isolation | Built in | Companion workspace provider |
+| Tool permission policy | Built-in selectors and denylist | Companion permission layer plus built-in denylist |
+| Fleet/editor UI | Broad agent management UI | Narrow widget, settings, and native transcript viewer |
+| Cross-extension RPC | Event RPC | Typed service contract |
+| Transcript opt-out | Sidecar output control | Not adopted; this fork uses official persisted Pi sessions |
 
-## Patches contributed upstream
+These are product choices, not missing parity work. Adopting one requires a new architectural decision and a concrete consumer need.
 
-Three of the fork's early changes were opened as PRs against upstream and remain a record of the shared lineage:
+## Choosing an implementation
 
-1. Peer-dep migration to `@earendil-works/pi-*` — [tintinweb/pi-subagents#71](https://github.com/tintinweb/pi-subagents/pull/71) (upstream has since migrated).
-2. Post-`bindExtensions` active-tool re-filter — [tintinweb/pi-subagents#72](https://github.com/tintinweb/pi-subagents/pull/72).
-3. `<active_agent>` system-prompt tag — [tintinweb/pi-subagents#73](https://github.com/tintinweb/pi-subagents/pull/73).
+Use `@tintinweb/pi-subagents` when you want a batteries-included extension with scheduling, memory, nested delegation, worktrees, and its full management UI.
 
-The fork has since diverged well beyond these.
+Use `@gotgenes/pi-subagents` when you want the direct focused-core lineage without this fork's lifecycle interception and status-display guarantees.
+
+Use `@nklisch/pi-subagents` when companion extensions need deterministic lifecycle decisions, inherited runtime and extension tooling, exact model/runtime visibility, and the selective reliability contracts described above.
+
+Tool names and configuration are not drop-in portable across all three projects. Review agent definitions and orchestration prompts before switching packages.

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

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-subagents",
-  "version": "18.0.4-nklisch.1",
+  "version": "18.1.0-nklisch.0",
   "type": "module",
   "exports": {
     ".": {
@@ -52,7 +52,7 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.75.0",
-    "@earendil-works/pi-coding-agent": ">=0.75.0",
+    "@earendil-works/pi-coding-agent": ">=0.80.5",
     "@earendil-works/pi-tui": ">=0.75.0"
   },
   "dependencies": {

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/config/agent-type-resolution.ts

@@ -0,0 +1,43 @@
+import type { AgentTypeRegistry } from "#src/config/agent-types";
+
+export interface AgentTypeResolution {
+  type: string;
+  requestedType: string;
+  fellBack: boolean;
+}
+
+export type AgentTypeResolutionResult = AgentTypeResolution | { error: string };
+
+/**
+ * Resolve caller-supplied agent identity once, before prompt/model/tool policy.
+ * Unknown names follow the configured fallback; disabled or ambiguous names do
+ * not silently acquire another agent's identity.
+ */
+export function resolveDispatchAgentType(
+  requestedType: string,
+  registry: AgentTypeRegistry,
+  fallback: string | false | undefined,
+): AgentTypeResolutionResult {
+  const resolved = registry.resolveType(requestedType);
+  if (resolved) {
+    if (!registry.isValidType(resolved)) return { error: `Agent type "${resolved}" is disabled` };
+    return { type: resolved, requestedType, fellBack: false };
+  }
+
+  if (registry.isCaseAmbiguous(requestedType)) {
+    return { error: `Agent type "${requestedType}" is ambiguous. Use exact casing.` };
+  }
+
+  if (fallback === false) {
+    return {
+      error: `Unknown agent type "${requestedType}". Available types: ${registry.getAvailableTypes().join(", ")}`,
+    };
+  }
+
+  const fallbackName = fallback ?? "general-purpose";
+  const resolvedFallback = registry.resolveType(fallbackName);
+  if (!resolvedFallback || !registry.isValidType(resolvedFallback)) {
+    return { error: `Configured fallback agent "${fallbackName}" is unknown or disabled` };
+  }
+  return { type: resolvedFallback, requestedType, fellBack: true };
+}

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

@@ -31,8 +31,8 @@ export interface AgentConfigLookup {
 export class AgentTypeRegistry implements AgentConfigLookup {
   private agents = new Map<string, AgentConfig>();
 
-  /** The three embedded default agent names. */
-  static readonly DEFAULT_AGENT_NAMES = ["general-purpose", "Explore", "Plan"] as const;
+  /** The two embedded default agent names. */
+  static readonly DEFAULT_AGENT_NAMES = ["general-purpose", "Explore"] as const;
 
   constructor(private loadUserAgents: () => Map<string, AgentConfig>) {
     this.reload();
@@ -83,6 +83,13 @@ export class AgentTypeRegistry implements AgentConfigLookup {
       .map(([name]) => name);
   }
 
+  /** Whether a non-exact case-insensitive lookup has more than one candidate. */
+  isCaseAmbiguous(type: string): boolean {
+    if (this.agents.has(type)) return false;
+    const lower = type.toLowerCase();
+    return [...this.agents.keys()].filter((key) => key.toLowerCase() === lower).length > 1;
+  }
+
   /** Check if a type is valid and enabled (case-insensitive). */
   isValidType(type: string): boolean {
     const key = this.resolveKey(type);
@@ -122,10 +129,8 @@ export class AgentTypeRegistry implements AgentConfigLookup {
   private resolveKey(name: string): string | undefined {
     if (this.agents.has(name)) return name;
     const lower = name.toLowerCase();
-    for (const key of this.agents.keys()) {
-      if (key.toLowerCase() === lower) return key;
-    }
-    return undefined;
+    const matches = [...this.agents.keys()].filter((key) => key.toLowerCase() === lower);
+    return matches.length === 1 ? matches[0] : undefined;
   }
 }
 

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

@@ -1,5 +1,5 @@
 /**
- * custom-agents.ts — Load user-defined agents from project (.pi/agents/) and global ($PI_CODING_AGENT_DIR/agents/, default ~/.pi/agent/agents/) locations.
+ * custom-agents.ts — Load user-defined agents from global, shared project, and Pi project locations.
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
@@ -12,24 +12,31 @@ import type { AgentConfig, ThinkingLevel } from "#src/types";
 /**
  * Scan for custom agent .md files from multiple locations.
  * Discovery hierarchy (higher priority wins):
- *   1. Project: <cwd>/.pi/agents/*.md
- *   2. Global:  $PI_CODING_AGENT_DIR/agents/*.md (default: ~/.pi/agent/agents/*.md)
+ *   1. Pi project:     <cwd>/.pi/agents/*.md
+ *   2. Shared project: <cwd>/.agents/agents/*.md
+ *   3. Global:         $PI_CODING_AGENT_DIR/agents/*.md
  *
  * Project-level agents override global ones with the same name.
  * Any name is allowed — names matching defaults (e.g. "Explore") override them.
  */
 export function loadCustomAgents(cwd: string): Map<string, AgentConfig> {
   const globalDir = join(getAgentDir(), "agents");
+  const sharedProjectDir = join(cwd, ".agents", "agents");
   const projectDir = join(cwd, ".pi", "agents");
 
   const agents = new Map<string, AgentConfig>();
-  loadFromDir(globalDir, agents, "global");   // lower priority
-  loadFromDir(projectDir, agents, "project");  // higher priority (overwrites)
+  loadFromDir(globalDir, agents, "global");
+  loadFromDir(sharedProjectDir, agents, "shared-project");
+  loadFromDir(projectDir, agents, "project");
   return agents;
 }
 
 /** Load agent configs from a directory into the map. */
-function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "project" | "global"): void {
+function loadFromDir(
+  dir: string,
+  agents: Map<string, AgentConfig>,
+  source: "project" | "shared-project" | "global",
+): void {
   if (!existsSync(dir)) return;
 
   let files: string[];

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

@@ -65,56 +65,4 @@ Use Bash ONLY for read-only operations: ls, git status, git log, git diff, find,
       isDefault: true,
     },
   ],
-  [
-    "Plan",
-    {
-      name: "Plan",
-      displayName: "Plan",
-      description: "Software architect for implementation planning (read-only)",
-      toolGuideline: "- Use Plan for architecture and implementation planning.",
-      builtinToolNames: READ_ONLY_TOOLS,
-      systemPrompt: `# CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS
-You are a software architect and planning specialist.
-Your role is EXCLUSIVELY to explore the codebase and design implementation plans.
-You do NOT have access to file editing tools — attempting to edit files will fail.
-
-You are STRICTLY PROHIBITED from:
-- Creating new files
-- Modifying existing files
-- Deleting files
-- Moving or copying files
-- Creating temporary files anywhere, including /tmp
-- Using redirect operators (>, >>, |) or heredocs to write to files
-- Running ANY commands that change system state
-
-# Planning Process
-1. Understand requirements
-2. Explore thoroughly (read files, find patterns, understand architecture)
-3. Design solution based on your assigned perspective
-4. Detail the plan with step-by-step implementation strategy
-
-# Requirements
-- Consider trade-offs and architectural decisions
-- Identify dependencies and sequencing
-- Anticipate potential challenges
-- Follow existing patterns where appropriate
-
-# Tool Usage
-- Use the find tool for file pattern matching (NOT the bash find command)
-- Use the grep tool for content search (NOT bash grep/rg command)
-- Use the read tool for reading files (NOT bash cat/head/tail)
-- Use Bash ONLY for read-only operations
-
-# Output Format
-- Use absolute file paths
-- Do not use emojis
-- End your response with:
-
-### Critical Files for Implementation
-List 3-5 files most critical for implementing this plan:
-- /absolute/path/to/file.ts - [Brief reason]`,
-      promptMode: "replace",
-      isDefault: true,
-    },
-  ],
 ]);

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

@@ -0,0 +1,12 @@
+/** Host-supported thinking levels advertised by every pi-subagents surface. */
+export const THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+] as const;
+
+export const THINKING_LEVELS_DESCRIPTION = THINKING_LEVELS.join(", ");

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

@@ -29,7 +29,10 @@ export class InterruptHandler {
   private latched?: AbortSignal;
   private detach?: () => void;
 
-  constructor(private readonly manager: InterruptManager) {}
+  constructor(
+    private readonly manager: InterruptManager,
+    private readonly shouldAbortAll: () => boolean = () => true,
+  ) {}
 
   handleTurnStart(ctx: InterruptCtx): void {
     const signal = ctx.signal;
@@ -41,7 +44,7 @@ export class InterruptHandler {
     if (!signal) return;
 
     const onAbort = (): void => {
-      this.manager.abortAll();
+      if (this.shouldAbortAll()) this.manager.abortAll();
     };
     signal.addEventListener("abort", onAbort, { once: true });
     this.detach = () => signal.removeEventListener("abort", onAbort);

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

@@ -49,14 +49,14 @@ export class SessionLifecycleHandler {
   // Cleanup order matters:
   // 1. Unpublish service — prevent new cross-extension calls
   // 2. Clear session context — no more session state
-  // 3. Abort all agents — stop running work
-  // 4. Dispose notifications — cancel pending nudges/timers
+  // 3. Dispose notifications — prevent terminal transitions from enqueueing follow-ups
+  // 4. Abort all agents — stop running and queued work
   // 5. Dispose manager — final cleanup
   handleSessionShutdown(): Promise<void> {
     this.unpublishService();
     this.runtime.clearSessionContext();
-    this.manager.abortAll();
     this.disposeNotifications();
+    this.manager.abortAll();
     this.manager.dispose();
     return Promise.resolve();
   }

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

@@ -62,6 +62,8 @@ export default function (pi: ExtensionAPI) {
   const notifications = new NotificationManager(
     (msg, opts) => pi.sendMessage(msg, opts),
   );
+  pi.on("agent_start", () => notifications.onParentAgentStart());
+  pi.on("agent_settled", () => notifications.onParentAgentSettled());
 
   // Settings: owns all three in-memory values and handles load/save/emit.
   // onMaxConcurrentChanged is wired to the limiter directly (closure captures by reference).
@@ -118,7 +120,7 @@ export default function (pi: ExtensionAPI) {
 
   // Typed service published via Symbol.for() for cross-extension access.
   // Consumers: const { getSubagentsService } = await import("@gotgenes/pi-subagents");
-  const service = new SubagentsServiceAdapter(manager, resolveModel, runtime);
+  const service = new SubagentsServiceAdapter(manager, resolveModel, runtime, registry, settings);
   publishSubagentsService(service);
 
   const lifecycle = new SessionLifecycleHandler(
@@ -142,7 +144,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("tool_execution_start", (event, ctx) => toolStart.handleToolExecutionStart(event, ctx));
 
   // Abort all subagents when the parent agent loop is interrupted (ESC).
-  const interrupt = new InterruptHandler(manager);
+  const interrupt = new InterruptHandler(manager, () => settings.abortAllOnInterrupt);
   pi.on("turn_start", (_event, ctx) => interrupt.handleTurnStart(ctx));
 
   // ---- Agent tool ----
@@ -151,7 +153,7 @@ export default function (pi: ExtensionAPI) {
 
   // ---- get_subagent_result tool ----
 
-  pi.registerTool(new GetResultTool(manager, notifications, registry).toToolDefinition());
+  pi.registerTool(new GetResultTool(manager, registry).toToolDefinition());
 
   // ---- steer_subagent tool ----
 
@@ -159,10 +161,10 @@ export default function (pi: ExtensionAPI) {
 
   // ---- /subagents:settings command ----
 
-  const subagentsSettings = new SubagentsSettingsHandler(settings);
+  const subagentsSettings = new SubagentsSettingsHandler(settings, registry);
 
   pi.registerCommand("subagents:settings", {
-    description: "Configure subagent settings (concurrency, turn limits)",
+    description: "Configure subagent concurrency, retention, interrupts, and fallback policy",
     handler: async (_args, ctx) => {
       await subagentsSettings.handle({ ui: ctx.ui });
     },
@@ -178,7 +180,6 @@ export default function (pi: ExtensionAPI) {
       await sessionNavigator.handle({
         ui: ctx.ui,
         agents: manager.listAgents(),
-        evicted: manager.listEvicted(),
         registry,
         cwd: ctx.cwd,
         readFile: (path) => readFileSync(path, "utf8"),

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

@@ -72,9 +72,13 @@ export interface CreateSessionOptions {
   agentDir: string;
   sessionManager: SessionManagerLike;
   settingsManager: SettingsManager;
+  /** Legacy Pi compatibility input; modern Pi consumes modelRuntime. */
   modelRegistry: unknown;
+  /** Parent model/auth runtime so child sessions preserve runtime registrations. */
+  modelRuntime?: unknown;
   model?: unknown;
-  tools: string[];
+  /** Denylist keeps extension-tool registration open, including late registration. */
+  excludeTools: string[];
   resourceLoader: ResourceLoaderLike;
   thinkingLevel?: ThinkingLevel;
 }
@@ -205,8 +209,9 @@ export async function createSubagentSession(
     sessionManager,
     settingsManager: deps.io.createSettingsManager(cfg.effectiveCwd, agentDir),
     modelRegistry: snapshot.modelRegistry,
+    modelRuntime: snapshot.modelRuntime,
     model: cfg.model,
-    tools: cfg.toolNames,
+    excludeTools: [...new Set([...cfg.excludedBuiltinToolNames, ...EXCLUDED_TOOL_NAMES])],
     resourceLoader: loader,
     thinkingLevel: cfg.thinkingLevel,
   });

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

@@ -16,11 +16,13 @@ export interface ParentSnapshot {
   systemPrompt: string;
   /** Parent's current model instance (fallback when agent config has no model). */
   model: unknown;
-  /** Model registry for resolving config.model strings and creating sessions. */
+  /** Model registry compatibility facade used for synchronous model lookup. */
   modelRegistry: {
     find(provider: string, modelId: string): unknown;
     getAvailable?(): Array<{ provider: string; id: string }>;
   };
+  /** Canonical parent model/auth runtime, when exposed by the host Pi version. */
+  modelRuntime?: unknown;
   /** Pre-built parent conversation text (when inheritContext was requested). */
   parentContext?: string;
 }
@@ -36,12 +38,18 @@ export function buildParentSnapshot(
   inheritContext?: boolean,
 ): ParentSnapshot {
   const parentContext = inheritContext ? buildParentContext(ctx) : undefined;
+  const modelRegistry = ctx.modelRegistry!;
+  // Pi exposes ModelRegistry as a compatibility facade. Modern createAgentSession
+  // consumes its underlying ModelRuntime; carrying that same runtime preserves
+  // extension-registered providers and in-memory auth state in child sessions.
+  const modelRuntime = (modelRegistry as unknown as { runtime?: unknown }).runtime;
+
   return {
     cwd: ctx.cwd,
     systemPrompt: ctx.getSystemPrompt(),
     model: ctx.model,
-
-    modelRegistry: ctx.modelRegistry!,
+    modelRegistry,
+    modelRuntime,
     // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- || intentional: converts empty string to undefined as well as null/undefined
     parentContext: parentContext || undefined,
   };