@gotgenes/pi-subagents 6.3.1 → 6.5.0

package/src/agent-manager.ts

@@ -11,6 +11,7 @@ import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSession, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { AgentRecord } from "./agent-record.js";
 import type { AgentRunner } from "./agent-runner.js";
+import { AgentTypeRegistry } from "./agent-types.js";
 import { debugLog } from "./debug.js";
 import { buildParentSnapshot } from "./parent-snapshot.js";
 import { subscribeRecordObserver } from "./record-observer.js";
@@ -30,7 +31,9 @@ export interface AgentManagerOptions {
   runner: AgentRunner;
   worktrees: WorktreeManager;
   exec: ShellExec;
-  maxConcurrent?: number;
+  registry: AgentTypeRegistry;
+  /** Injected getter for the concurrency limit — owned by SettingsManager. */
+  getMaxConcurrent?: () => number;
   getRunConfig?: () => RunConfig;
   onStart?: OnAgentStart;
   onComplete?: OnAgentComplete;
@@ -81,7 +84,8 @@ export class AgentManager {
   private readonly runner: AgentRunner;
   private readonly worktrees: WorktreeManager;
   private readonly exec: ShellExec;
-  private maxConcurrent: number;
+  private readonly registry: AgentTypeRegistry;
+  private readonly _getMaxConcurrent: () => number;
   private getRunConfig?: () => RunConfig;
 
   /** Queue of background agents waiting to start. */
@@ -93,27 +97,25 @@ export class AgentManager {
     this.runner = options.runner;
     this.worktrees = options.worktrees;
     this.exec = options.exec;
+    this.registry = options.registry;
     this.onComplete = options.onComplete;
     this.onStart = options.onStart;
     this.onCompact = options.onCompact;
     this.getRunConfig = options.getRunConfig;
-    this.maxConcurrent = options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+    this._getMaxConcurrent = options.getMaxConcurrent ?? (() => DEFAULT_MAX_CONCURRENT);
     // Cleanup completed agents after 10 minutes (but keep sessions for resume)
     this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
     this.cleanupInterval.unref();
   }
 
-  /** Update the max concurrent background agents limit. */
-  setMaxConcurrent(n: number) {
-    this.maxConcurrent = Math.max(1, n);
-    // Start queued agents if the new limit allows
+  /**
+   * Drain the concurrency queue after SettingsManager has updated maxConcurrent.
+   * Call this whenever the concurrency limit increases so queued agents can start.
+   */
+  notifyConcurrencyChanged(): void {
     this.drainQueue();
   }
 
-  getMaxConcurrent(): number {
-    return this.maxConcurrent;
-  }
-
   /**
    * Spawn an agent and return its ID immediately (for background use).
    * If the concurrency limit is reached, the agent is queued.
@@ -140,7 +142,7 @@ export class AgentManager {
     const snapshot = buildParentSnapshot(ctx, options.inheritContext);
     const args: SpawnArgs = { snapshot, type, prompt, options };
 
-    if (options.isBackground && !options.bypassQueue && this.runningBackground >= this.maxConcurrent) {
+    if (options.isBackground && !options.bypassQueue && this.runningBackground >= this._getMaxConcurrent()) {
       // Queue it — will be started when a running agent completes
       this.queue.push({ id, args });
       return id;
@@ -203,6 +205,7 @@ export class AgentManager {
       parentSessionFile: options.parentSessionFile,
       parentSessionId: options.parentSessionId,
       signal: record.abortController!.signal,
+      registry: this.registry,
       onSessionCreated: (session) => {
         record.session = session;
         // Capture the session file path early so it's available for display
@@ -279,7 +282,7 @@ export class AgentManager {
 
   /** Start queued agents up to the concurrency limit. */
   private drainQueue() {
-    while (this.queue.length > 0 && this.runningBackground < this.maxConcurrent) {
+    while (this.queue.length > 0 && this.runningBackground < this._getMaxConcurrent()) {
       const next = this.queue.shift()!;
       const record = this.agents.get(next.id);
       if (!record || record.status !== "queued") continue;

package/src/agent-runner.ts

@@ -12,6 +12,7 @@ import {
   SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
+import type { AgentConfigLookup } from "./agent-types.js";
 import { extractText } from "./context.js";
 import { detectEnv } from "./env.js";
 import { assembleSessionConfig } from "./session-config.js";
@@ -91,6 +92,8 @@ export interface RunOptions {
    * module-scope `graceTurns` during migration.
    */
   graceTurns?: number;
+  /** Agent config lookup — provides resolveAgentConfig and getToolNamesForType. */
+  registry: AgentConfigLookup;
 }
 
 export interface RunResult {
@@ -189,6 +192,7 @@ export async function runAgent(
       thinkingLevel: options.thinkingLevel,
     },
     env,
+    options.registry,
   );
 
   const agentDir = getAgentDir();

package/src/agent-types.ts

@@ -8,79 +8,132 @@
 import { DEFAULT_AGENTS } from "./default-agents.js";
 import type { AgentConfig } from "./types.js";
 
-/** All known built-in tool names. */
-export const BUILTIN_TOOL_NAMES: string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+// ── AgentConfigLookup interface ──────────────────────────────────────────────
 
-/** Unified runtime registry of all agents (defaults + user-defined). */
-const agents = new Map<string, AgentConfig>();
+/**
+ * Narrow registry interface for consumers that only need config resolution.
+ * Prefer this over the full `AgentTypeRegistry` in function signatures (ISP).
+ */
+export interface AgentConfigLookup {
+  resolveAgentConfig(type: string): AgentConfig;
+  getToolNamesForType(type: string): string[];
+}
+
+// ── AgentTypeRegistry class ──────────────────────────────────────────────────
 
 /**
- * Register agents into the unified registry.
- * Starts with DEFAULT_AGENTS, then overlays user agents (overrides defaults with same name).
- * Disabled agents (enabled === false) are kept in the registry but excluded from spawning.
+ * Injectable registry of all agent configurations (defaults + user-defined).
+ *
+ * Replaces the module-scoped `agents` Map and its companion free functions.
+ * The constructor accepts a `loadUserAgents` callback to defer disk I/O to the
+ * call site, keeping this class side-effect-free and easy to test.
  */
-export function registerAgents(userAgents: Map<string, AgentConfig>): void {
-  agents.clear();
+export class AgentTypeRegistry implements AgentConfigLookup {
+  private agents = new Map<string, AgentConfig>();
 
-  // Start with defaults
-  for (const [name, config] of DEFAULT_AGENTS) {
-    agents.set(name, config);
+  /** The three embedded default agent names. */
+  static readonly DEFAULT_AGENT_NAMES = ["general-purpose", "Explore", "Plan"] as const;
+
+  constructor(private loadUserAgents: () => Map<string, AgentConfig>) {
+    this.reload();
   }
 
-  // Overlay user agents (overrides defaults with same name)
-  for (const [name, config] of userAgents) {
-    agents.set(name, config);
+  /**
+   * Re-scan user agents and rebuild the registry.
+   * Starts with DEFAULT_AGENTS, then overlays whatever `loadUserAgents()` returns.
+   */
+  reload(): void {
+    this.agents.clear();
+    for (const [name, config] of DEFAULT_AGENTS) {
+      this.agents.set(name, config);
+    }
+    for (const [name, config] of this.loadUserAgents()) {
+      this.agents.set(name, config);
+    }
   }
-}
 
-/** Case-insensitive key resolution. */
-function resolveKey(name: string): string | undefined {
-  if (agents.has(name)) return name;
-  const lower = name.toLowerCase();
-  for (const key of agents.keys()) {
-    if (key.toLowerCase() === lower) return key;
+  /** Resolve a type name case-insensitively. Returns the canonical key or undefined. */
+  resolveType(name: string): string | undefined {
+    return this.resolveKey(name);
   }
-  return undefined;
-}
 
-/** Resolve a type name case-insensitively. Returns the canonical key or undefined. */
-export function resolveType(name: string): string | undefined {
-  return resolveKey(name);
-}
+  /** Get all enabled type names (for spawning and tool descriptions). */
+  getAvailableTypes(): string[] {
+    return [...this.agents.entries()]
+      .filter(([_, config]) => config.enabled !== false)
+      .map(([name]) => name);
+  }
 
-/** Get all enabled type names (for spawning and tool descriptions). */
-export function getAvailableTypes(): string[] {
-  return [...agents.entries()]
-    .filter(([_, config]) => config.enabled !== false)
-    .map(([name]) => name);
-}
+  /** Get all type names including disabled (for UI listing). */
+  getAllTypes(): string[] {
+    return [...this.agents.keys()];
+  }
 
-/** Get all type names including disabled (for UI listing). */
-export function getAllTypes(): string[] {
-  return [...agents.keys()];
-}
+  /** Get names of default agents currently in the registry. */
+  getDefaultAgentNames(): string[] {
+    return [...this.agents.entries()]
+      .filter(([_, config]) => config.isDefault === true)
+      .map(([name]) => name);
+  }
 
-/** Get names of default agents currently in the registry. */
-export function getDefaultAgentNames(): string[] {
-  return [...agents.entries()]
-    .filter(([_, config]) => config.isDefault === true)
-    .map(([name]) => name);
-}
+  /** Get names of user-defined agents (non-defaults) currently in the registry. */
+  getUserAgentNames(): string[] {
+    return [...this.agents.entries()]
+      .filter(([_, config]) => config.isDefault !== true)
+      .map(([name]) => name);
+  }
 
-/** Get names of user-defined agents (non-defaults) currently in the registry. */
-export function getUserAgentNames(): string[] {
-  return [...agents.entries()]
-    .filter(([_, config]) => config.isDefault !== true)
-    .map(([name]) => name);
-}
+  /** Check if a type is valid and enabled (case-insensitive). */
+  isValidType(type: string): boolean {
+    const key = this.resolveKey(type);
+    if (!key) return false;
+    return this.agents.get(key)?.enabled !== false;
+  }
 
-/** Check if a type is valid and enabled (case-insensitive). */
-export function isValidType(type: string): boolean {
-  const key = resolveKey(type);
-  if (!key) return false;
-  return agents.get(key)?.enabled !== false;
+  /** Get built-in tool names for a type (case-insensitive). */
+  getToolNamesForType(type: string): string[] {
+    const key = this.resolveKey(type);
+    const raw = key ? this.agents.get(key) : undefined;
+    const config = raw?.enabled !== false ? raw : undefined;
+    const names = config?.builtinToolNames?.length ? config.builtinToolNames : [...BUILTIN_TOOL_NAMES];
+    return names;
+  }
+
+  /** Resolve agent config with guaranteed non-null return. Falls back: unknown → general-purpose → absolute fallback. */
+  resolveAgentConfig(type: string): AgentConfig {
+    const key = this.resolveKey(type);
+    const config = key ? this.agents.get(key) : undefined;
+    if (config) return config;
+
+    const gp = this.agents.get("general-purpose");
+    if (gp) return gp;
+
+    // Absolute fallback (should never happen in practice)
+    return {
+      name: type,
+      displayName: "Agent",
+      description: "General-purpose agent for complex, multi-step tasks",
+      builtinToolNames: BUILTIN_TOOL_NAMES,
+      extensions: true,
+      skills: true,
+      systemPrompt: "",
+      promptMode: "append",
+    };
+  }
+
+  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;
+  }
 }
 
+/** All known built-in tool names. */
+export const BUILTIN_TOOL_NAMES: string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+
 /** Tool names required for memory management. */
 const MEMORY_TOOL_NAMES = ["read", "write", "edit"];
 
@@ -100,39 +153,3 @@ const READONLY_MEMORY_TOOL_NAMES = ["read"];
 export function getReadOnlyMemoryToolNames(existingToolNames: Set<string>): string[] {
   return READONLY_MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
 }
-
-/** Get built-in tool names for a type (case-insensitive). */
-export function getToolNamesForType(type: string): string[] {
-  const key = resolveKey(type);
-  const raw = key ? agents.get(key) : undefined;
-  const config = raw?.enabled !== false ? raw : undefined;
-  const names = config?.builtinToolNames?.length ? config.builtinToolNames : [...BUILTIN_TOOL_NAMES];
-  return names;
-}
-
-/** Resolve agent config with guaranteed non-null return. Falls back: unknown → general-purpose → absolute fallback. */
-export function resolveAgentConfig(type: string): AgentConfig {
-  const key = resolveKey(type);
-  const config = key ? agents.get(key) : undefined;
-  if (config) {
-    return config;
-  }
-
-  // Fallback to general-purpose for unknown types
-  const gp = agents.get("general-purpose");
-  if (gp) {
-    return gp;
-  }
-
-  // Absolute fallback (should never happen in practice)
-  return {
-    name: type,
-    displayName: "Agent",
-    description: "General-purpose agent for complex, multi-step tasks",
-    builtinToolNames: BUILTIN_TOOL_NAMES,
-    extensions: true,
-    skills: true,
-    systemPrompt: "",
-    promptMode: "append",
-  };
-}

package/src/index.ts

@@ -13,8 +13,8 @@
 import { join } from "node:path";
 import { defineTool, type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { AgentManager } from "./agent-manager.js";
-import { getAgentConversation, normalizeMaxTurns, resumeAgent, runAgent, steerAgent } from "./agent-runner.js";
-import { getAvailableTypes, getDefaultAgentNames, getUserAgentNames, registerAgents, resolveAgentConfig, } from "./agent-types.js";
+import { getAgentConversation, resumeAgent, runAgent, steerAgent } from "./agent-runner.js";
+import { AgentTypeRegistry } from "./agent-types.js";
 import { loadCustomAgents } from "./custom-agents.js";
 import { SessionLifecycleHandler, ToolStartHandler } from "./handlers/index.js";
 import { type ModelRegistry, resolveModel } from "./model-resolver.js";
@@ -23,7 +23,7 @@ import { createNotificationRenderer } from "./renderer.js";
 import { createSubagentRuntime } from "./runtime.js";
 import { publishSubagentsService, unpublishSubagentsService } from "./service.js";
 import { createSubagentsService } from "./service-adapter.js";
-import { applyAndEmitLoaded, saveAndEmitChanged } from "./settings.js";
+import { SettingsManager } from "./settings.js";
 import { createAgentTool } from "./tools/agent-tool.js";
 import { createGetResultTool } from "./tools/get-result-tool.js";
 import { getModelLabelFromConfig } from "./tools/helpers.js";
@@ -40,14 +40,7 @@ export default function (pi: ExtensionAPI) {
   // ---- Register custom notification renderer ----
   pi.registerMessageRenderer<NotificationDetails>("subagent-notification", createNotificationRenderer());
 
-  /** Reload agents from .pi/agents/*.md and merge with defaults (called on init and each Agent invocation). */
-  const reloadCustomAgents = () => {
-    const userAgents = loadCustomAgents(process.cwd());
-    registerAgents(userAgents);
-  };
-
-  // Initial load
-  reloadCustomAgents();
+  const registry = new AgentTypeRegistry(() => loadCustomAgents(process.cwd()));
 
   // ---- Runtime: all mutable extension state in one place ----
   const runtime = createSubagentRuntime();
@@ -62,11 +55,19 @@ export default function (pi: ExtensionAPI) {
     updateWidget: () => runtime.updateWidget(),
   });
 
+  // Settings: owns all three in-memory values and handles load/save/emit.
+  const settings = new SettingsManager({
+    emit: (event, payload) => pi.events.emit(event, payload),
+    cwd: process.cwd(),
+  });
+  settings.load();
+
   // Background completion: emit lifecycle event and delegate to notification system
   const manager = new AgentManager({
     runner: { run: runAgent, resume: resumeAgent },
     worktrees: new GitWorktreeManager(process.cwd()),
     exec: (cmd, args, opts) => pi.exec(cmd, args, opts),
+    registry,
     onComplete: (record) => {
       // Emit lifecycle event based on terminal status
       const isError = record.status === "error" || record.status === "stopped" || record.status === "aborted";
@@ -111,7 +112,8 @@ export default function (pi: ExtensionAPI) {
         compactionCount: record.compactionCount,
       });
     },
-    getRunConfig: () => ({ defaultMaxTurns: runtime.defaultMaxTurns, graceTurns: runtime.graceTurns }),
+    getMaxConcurrent: () => settings.maxConcurrent,
+    getRunConfig: () => settings,
   });
 
   // Typed service published via Symbol.for() for cross-extension access.
@@ -137,7 +139,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_shutdown", () => lifecycle.handleSessionShutdown());
 
   // Live widget: show running agents above editor
-  runtime.widget = new AgentWidget(manager, runtime.agentActivity);
+  runtime.widget = new AgentWidget(manager, runtime.agentActivity, registry);
 
   // Grab UI context from first tool execution + clear lingering widget on new turn
   const toolStart = new ToolStartHandler(runtime);
@@ -145,17 +147,17 @@ export default function (pi: ExtensionAPI) {
 
   /** Build the full type list text dynamically from the unified registry. */
   const buildTypeListText = () => {
-    const defaultNames = getDefaultAgentNames();
-    const userNames = getUserAgentNames();
+    const defaultNames = registry.getDefaultAgentNames();
+    const userNames = registry.getUserAgentNames();
 
     const defaultDescs = defaultNames.map((name) => {
-      const cfg = resolveAgentConfig(name);
+      const cfg = registry.resolveAgentConfig(name);
       const modelSuffix = cfg.model ? ` (${getModelLabelFromConfig(cfg.model)})` : "";
       return `- ${name}: ${cfg.description}${modelSuffix}`;
     });
 
     const customDescs = userNames.map((name) => {
-      const cfg = resolveAgentConfig(name);
+      const cfg = registry.resolveAgentConfig(name);
       return `- ${name}: ${cfg.description}`;
     });
 
@@ -170,18 +172,6 @@ export default function (pi: ExtensionAPI) {
 
   const typeListText = buildTypeListText();
 
-  // Apply persisted settings on startup and emit `subagents:settings_loaded`.
-  // Global + project merged; missing → defaults; corrupt file emits a warning
-  // to stderr and falls back to defaults.
-  applyAndEmitLoaded(
-    {
-      setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
-      setDefaultMaxTurns: (n) => { runtime.defaultMaxTurns = normalizeMaxTurns(n); },
-      setGraceTurns: (n) => { runtime.graceTurns = Math.max(1, n); },
-    },
-    (event, payload) => pi.events.emit(event, payload),
-  );
-
   // ---- Agent tool ----
 
   pi.registerTool(defineTool(createAgentTool({
@@ -190,7 +180,7 @@ export default function (pi: ExtensionAPI) {
       spawnAndWait: (ctx, type, prompt, opts) => manager.spawnAndWait(ctx, type, prompt, opts),
       resume: (id, prompt, signal) => manager.resume(id, prompt, signal),
       getRecord: (id) => manager.getRecord(id),
-      getMaxConcurrent: () => manager.getMaxConcurrent(),
+      getMaxConcurrent: () => settings.maxConcurrent,
       listAgents: () => manager.listAgents(),
     },
     widget: {
@@ -201,11 +191,11 @@ export default function (pi: ExtensionAPI) {
     },
     agentActivity: runtime.agentActivity,
     emitEvent: (name, data) => pi.events.emit(name, data),
-    reloadCustomAgents,
+    registry,
     typeListText,
-    availableTypesText: getAvailableTypes().join(", "),
+    availableTypesText: registry.getAvailableTypes().join(", "),
     agentDir: getAgentDir(),
-    getDefaultMaxTurns: () => runtime.defaultMaxTurns,
+    settings,
   })));
 
   // ---- get_subagent_result tool ----
@@ -214,6 +204,7 @@ export default function (pi: ExtensionAPI) {
     getRecord: (id) => manager.getRecord(id),
     cancelNudge: (key) => notifications.cancelNudge(key),
     getConversation: (session) => getAgentConversation(session),
+    registry,
   })));
 
   // ---- steer_subagent tool ----
@@ -231,38 +222,20 @@ export default function (pi: ExtensionAPI) {
       listAgents: () => manager.listAgents(),
       getRecord: (id) => manager.getRecord(id),
       spawnAndWait: (ctx, type, prompt, opts) => manager.spawnAndWait(ctx, type, prompt, opts),
-      getMaxConcurrent: () => manager.getMaxConcurrent(),
-      setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
+      notifyConcurrencyChanged: () => manager.notifyConcurrencyChanged(),
     },
-    reloadCustomAgents,
+    registry,
     agentActivity: runtime.agentActivity,
-    getModelLabel: (type, registry) => {
-      const cfg = resolveAgentConfig(type);
+    getModelLabel: (type, modelRegistry) => {
+      const cfg = registry.resolveAgentConfig(type);
       if (!cfg.model) return 'inherit';
-      if (registry) {
-        const resolved = resolveModel(cfg.model, registry);
+      if (modelRegistry) {
+        const resolved = resolveModel(cfg.model, modelRegistry);
         if (typeof resolved === 'string') return 'inherit';
       }
       return getModelLabelFromConfig(cfg.model);
     },
-    snapshotSettings: () => ({
-      maxConcurrent: manager.getMaxConcurrent(),
-      defaultMaxTurns: runtime.defaultMaxTurns ?? 0,
-      graceTurns: runtime.graceTurns,
-    }),
-    getDefaultMaxTurns: () => runtime.defaultMaxTurns,
-    getGraceTurns: () => runtime.graceTurns,
-    setDefaultMaxTurns: (n) => {
-      runtime.defaultMaxTurns = normalizeMaxTurns(n);
-    },
-    setGraceTurns: (n) => {
-      runtime.graceTurns = Math.max(1, n);
-    },
-    saveSettings: (settings, successMsg) => saveAndEmitChanged(
-      settings,
-      successMsg,
-      (event, payload) => pi.events.emit(event, payload),
-    ),
+    settings,
     emitEvent: (name, data) => pi.events.emit(name, data),
     personalAgentsDir: join(getAgentDir(), 'agents'),
     projectAgentsDir: join(process.cwd(), '.pi', 'agents'),

package/src/runtime.ts

@@ -24,12 +24,6 @@ export interface RunConfig {
  * Tests construct a fresh runtime per test for full isolation.
  */
 export class SubagentRuntime {
-  // ── Execution config (was module-scope in agent-runner.ts) ──────────────
-  /** Default max turns for all agents. undefined = unlimited. */
-  defaultMaxTurns: number | undefined = undefined;
-  /** Additional turns allowed after the soft-limit steer message. */
-  graceTurns: number = 5;
-
   // ── Session state (was closure-scoped in index.ts) ───────────────────────
   /** Active Pi session context — set on session_start, cleared on session_shutdown. */
   currentCtx: { pi: unknown; ctx: unknown } | undefined = undefined;

package/src/session-config.ts

@@ -11,10 +11,9 @@
  */
 
 import {
+  type AgentConfigLookup,
   getMemoryToolNames,
   getReadOnlyMemoryToolNames,
-  getToolNamesForType,
-  resolveAgentConfig,
 } from "./agent-types.js";
 import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "./memory.js";
 import { buildAgentPrompt, type PromptExtras } from "./prompts.js";
@@ -140,14 +139,16 @@ function resolveDefaultModel(
  * @param ctx        Narrow context from the parent session.
  * @param options    Per-call overrides (cwd, isolated, model, thinkingLevel).
  * @param env        Pre-resolved environment info from `detectEnv()`.
+ * @param registry   Agent config lookup — provides resolveAgentConfig and getToolNamesForType.
  */
 export function assembleSessionConfig(
   type: SubagentType,
   ctx: AssemblerContext,
   options: AssemblerOptions,
   env: EnvInfo,
+  registry: AgentConfigLookup,
 ): SessionConfig {
-  const agentConfig = resolveAgentConfig(type);
+  const agentConfig = registry.resolveAgentConfig(type);
 
   const effectiveCwd = options.cwd ?? ctx.cwd;
 
@@ -166,7 +167,7 @@ export function assembleSessionConfig(
     }
   }
 
-  let toolNames = getToolNamesForType(type);
+  let toolNames = registry.getToolNamesForType(type);
 
   // Persistent memory: detect write capability and branch accordingly.
   // Account for disallowedTools — a tool in the base set but on the denylist