@esso0428/pi-subagents 0.15.5 → 0.15.6

package/dist/agent-runner.js

@@ -1,47 +1,30 @@
-"use strict";
 /**
  * agent-runner.ts — Core execution engine: creates sessions, runs agents, collects results.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUBAGENT_TOOL_NAMES = void 0;
-exports.extensionCanonicalName = extensionCanonicalName;
-exports.extensionCanonicalNames = extensionCanonicalNames;
-exports.parseExtensionsSpec = parseExtensionsSpec;
-exports.parseExtSelectors = parseExtSelectors;
-exports.installExtensionToolScope = installExtensionToolScope;
-exports.normalizeMaxTurns = normalizeMaxTurns;
-exports.getDefaultMaxTurns = getDefaultMaxTurns;
-exports.setDefaultMaxTurns = setDefaultMaxTurns;
-exports.getGraceTurns = getGraceTurns;
-exports.setGraceTurns = setGraceTurns;
-exports.runAgent = runAgent;
-exports.resumeAgent = resumeAgent;
-exports.steerAgent = steerAgent;
-exports.getAgentConversation = getAgentConversation;
-const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
-const agent_types_js_1 = require("./agent-types.js");
-const context_js_1 = require("./context.js");
-const default_agents_js_1 = require("./default-agents.js");
-const env_js_1 = require("./env.js");
-const memory_js_1 = require("./memory.js");
-const prompts_js_1 = require("./prompts.js");
-const skill_loader_js_1 = require("./skill-loader.js");
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { BUILTIN_TOOL_NAMES, getAgentConfig, getConfig, getMemoryToolNames, getReadOnlyMemoryToolNames, getToolNamesForType } from "./agent-types.js";
+import { buildParentContext, extractText } from "./context.js";
+import { DEFAULT_AGENTS } from "./default-agents.js";
+import { detectEnv } from "./env.js";
+import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "./memory.js";
+import { buildAgentPrompt } from "./prompts.js";
+import { preloadSkills } from "./skill-loader.js";
 /**
  * Tool names registered by THIS extension. Single source of truth so the
  * registration sites (index.ts) and the subagent exclusion list below can't
  * drift apart. These are our own tools, not pi built-ins, so they can't be
  * derived from pi — but they only need defining once.
  */
-exports.SUBAGENT_TOOL_NAMES = {
+export const SUBAGENT_TOOL_NAMES = {
     AGENT: "Agent",
     GET_RESULT: "get_subagent_result",
     STEER: "steer_subagent",
 };
 /** Names of tools registered by this extension that subagents must NOT inherit. */
-const EXCLUDED_TOOL_NAMES = Object.values(exports.SUBAGENT_TOOL_NAMES);
+const EXCLUDED_TOOL_NAMES = Object.values(SUBAGENT_TOOL_NAMES);
 /**
  * Canonical name of an extension for `extensions: [...]` allowlist matching.
  * Lowercased — extension names match case-insensitively so `extensions: [Mcp]`
@@ -49,10 +32,10 @@ const EXCLUDED_TOOL_NAMES = Object.values(exports.SUBAGENT_TOOL_NAMES);
  * Directory extensions (`foo/index.ts`) resolve to the parent directory name;
  * single-file extensions to the basename minus `.ts`/`.js`.
  */
-function extensionCanonicalName(extPath) {
-    const base = (0, node_path_1.basename)(extPath);
+export function extensionCanonicalName(extPath) {
+    const base = basename(extPath);
     const name = base === "index.ts" || base === "index.js"
-        ? (0, node_path_1.basename)((0, node_path_1.dirname)(extPath))
+        ? basename(dirname(extPath))
         : base.replace(/\.(ts|js)$/, "");
     return name.toLowerCase();
 }
@@ -76,18 +59,18 @@ function extensionCanonicalName(extPath) {
  * co-located file to `pi-subagents`.
  */
 function extensionPackageName(extPath) {
-    const entry = (0, node_path_1.resolve)(extPath);
-    let dir = (0, node_path_1.dirname)(extPath);
+    const entry = resolve(extPath);
+    let dir = dirname(extPath);
     for (;;) {
         // Climbing into node_modules means we've left the owning package's tree.
-        if ((0, node_path_1.basename)(dir) === "node_modules")
+        if (basename(dir) === "node_modules")
             return undefined;
         let pkg;
         try {
-            pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, "package.json"), "utf-8"));
+            pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
         }
         catch {
-            const parent = (0, node_path_1.dirname)(dir);
+            const parent = dirname(dir);
             if (parent === dir)
                 return undefined; // walked to the filesystem root
             dir = parent;
@@ -97,7 +80,7 @@ function extensionPackageName(extPath) {
         const entries = pkg.pi?.extensions;
         if (typeof pkg.name === "string" &&
             Array.isArray(entries) &&
-            entries.some((e) => typeof e === "string" && (0, node_path_1.resolve)(dir, e) === entry)) {
+            entries.some((e) => typeof e === "string" && resolve(dir, e) === entry)) {
             const short = pkg.name.startsWith("@") ? pkg.name.slice(pkg.name.indexOf("/") + 1) : pkg.name;
             return short.toLowerCase();
         }
@@ -112,7 +95,7 @@ function extensionPackageName(extPath) {
  * otherwise only ever match as `src` (the source directory), never by its
  * package name. The path-derived name is preserved, so it keeps matching too.
  */
-function extensionCanonicalNames(extPath) {
+export function extensionCanonicalNames(extPath) {
     const canonical = extensionCanonicalName(extPath);
     const pkg = extensionPackageName(extPath);
     return pkg && pkg !== canonical ? [canonical, pkg] : [canonical];
@@ -128,7 +111,7 @@ function extensionCanonicalNames(extPath) {
  * everything by canonical name, so path-loaded extensions are matched via their name
  * rather than their post-staging `Extension.path`.
  */
-function parseExtensionsSpec(entries, cwd) {
+export function parseExtensionsSpec(entries, cwd) {
     const names = new Set();
     const paths = [];
     let wildcard = false;
@@ -146,9 +129,9 @@ function parseExtensionsSpec(entries, cwd) {
         }
         let p = entry;
         if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-            p = (0, node_os_1.homedir)() + p.slice(1);
+            p = homedir() + p.slice(1);
         }
-        const abs = (0, node_path_1.isAbsolute)(p) ? p : (0, node_path_1.resolve)(cwd, p);
+        const abs = isAbsolute(p) ? p : resolve(cwd, p);
         paths.push(abs);
         names.add(extensionCanonicalName(abs));
     }
@@ -164,7 +147,7 @@ function parseExtensionsSpec(entries, cwd) {
  * `ext:foo` alongside `ext:foo/bar` leaves narrowing in effect (narrowing wins).
  * The split is on the first `/`; extension canonical names never contain `/`.
  */
-function parseExtSelectors(entries) {
+export function parseExtSelectors(entries) {
     const extNames = new Set();
     const narrowing = new Map();
     for (const raw of entries) {
@@ -218,7 +201,7 @@ function parseExtSelectors(entries) {
  * Only meaningful when extensions are loaded — under `noExtensions`/`isolated` the
  * static `allowedToolNames` allowlist already gates the registry itself.
  */
-function installExtensionToolScope(session, ctx) {
+export function installExtensionToolScope(session, ctx) {
     const { loader, toolNames, disallowedSet, extNames, narrowing } = ctx;
     // The names allowed right now. Mirrors the `ext:` opt-in flip: when any `ext:`
     // selector is present, extension tools become an explicit allowlist — a loaded
@@ -277,21 +260,21 @@ function installExtensionToolScope(session, ctx) {
 /** Default max turns. undefined = unlimited (no turn limit). */
 let defaultMaxTurns;
 /** Normalize max turns. undefined or 0 = unlimited, otherwise minimum 1. */
-function normalizeMaxTurns(n) {
+export function normalizeMaxTurns(n) {
     if (n == null || n === 0)
         return undefined;
     return Math.max(1, n);
 }
 /** Get the default max turns value. undefined = unlimited. */
-function getDefaultMaxTurns() { return defaultMaxTurns; }
+export function getDefaultMaxTurns() { return defaultMaxTurns; }
 /** Set the default max turns value. undefined or 0 = unlimited, otherwise minimum 1. */
-function setDefaultMaxTurns(n) { defaultMaxTurns = normalizeMaxTurns(n); }
+export function setDefaultMaxTurns(n) { defaultMaxTurns = normalizeMaxTurns(n); }
 /** Additional turns allowed after the soft limit steer message. */
 let graceTurns = 5;
 /** Get the grace turns value. */
-function getGraceTurns() { return graceTurns; }
+export function getGraceTurns() { return graceTurns; }
 /** Set the grace turns value (minimum 1). */
-function setGraceTurns(n) { graceTurns = Math.max(1, n); }
+export function setGraceTurns(n) { graceTurns = Math.max(1, n); }
 /**
  * Try to find the right model for an agent type.
  * Priority: explicit option > config.model > parent model.
@@ -346,7 +329,7 @@ function getLastAssistantText(session, startIndex = 0) {
         const msg = session.messages[i];
         if (msg.role !== "assistant")
             continue;
-        const text = (0, context_js_1.extractText)(msg.content).trim();
+        const text = extractText(msg.content).trim();
         if (text)
             return text;
     }
@@ -374,7 +357,7 @@ function finalTurnError(session, startIndex = 0) {
         if (msg.stopReason === "error") {
             return msg.errorMessage?.trim() || "provider error with no output";
         }
-        if (msg.stopReason === "length" && !(0, context_js_1.extractText)(msg.content).trim()) {
+        if (msg.stopReason === "length" && !extractText(msg.content).trim()) {
             return "run hit the output token limit before producing any text";
         }
         return undefined;
@@ -396,20 +379,20 @@ function resolveConfiguredSessionDir(sessionDir, cwd) {
     if (!sessionDir)
         return undefined;
     if (sessionDir === "~" || sessionDir.startsWith("~/"))
-        return (0, node_path_1.resolve)((0, node_os_1.homedir)(), sessionDir.slice(2));
-    if ((0, node_path_1.isAbsolute)(sessionDir))
+        return resolve(homedir(), sessionDir.slice(2));
+    if (isAbsolute(sessionDir))
         return sessionDir;
-    return (0, node_path_1.resolve)(cwd, sessionDir);
+    return resolve(cwd, sessionDir);
 }
-async function runAgent(ctx, type, prompt, options) {
-    const config = (0, agent_types_js_1.getConfig)(type);
-    const agentConfig = (0, agent_types_js_1.getAgentConfig)(type);
+export async function runAgent(ctx, type, prompt, options) {
+    const config = getConfig(type);
+    const agentConfig = getAgentConfig(type);
     // Resolve working directory: worktree override > parent cwd
     const effectiveCwd = options.cwd ?? ctx.cwd;
     // Filesystem work happens in effectiveCwd; config discovery in configCwd.
     // They differ only for SpawnOptions.cwd spawns (config stays with the parent).
     const configCwd = options.configCwd ?? effectiveCwd;
-    const env = await (0, env_js_1.detectEnv)(options.pi, effectiveCwd);
+    const env = await detectEnv(options.pi, effectiveCwd);
     // Get parent system prompt for append-mode agents
     const parentSystemPrompt = ctx.getSystemPrompt();
     // Build prompt extras (memory, skill preloading)
@@ -422,12 +405,12 @@ async function runAgent(ctx, type, prompt, options) {
     const skills = options.isolated ? false : config.skills;
     // Skill preloading: when skills is string[], preload their content into prompt
     if (Array.isArray(skills)) {
-        const loaded = (0, skill_loader_js_1.preloadSkills)(skills, configCwd);
+        const loaded = preloadSkills(skills, configCwd);
         if (loaded.length > 0) {
             extras.skillBlocks = loaded;
         }
     }
-    let toolNames = (0, agent_types_js_1.getToolNamesForType)(type);
+    let toolNames = getToolNamesForType(type);
     // Persistent memory: detect write capability and branch accordingly.
     // Account for disallowedTools — a tool in the base set but on the denylist is not truly available.
     if (agentConfig?.memory) {
@@ -437,36 +420,36 @@ async function runAgent(ctx, type, prompt, options) {
         const hasWriteTools = effectivelyHas("write") || effectivelyHas("edit");
         if (hasWriteTools) {
             // Read-write memory: add any missing memory tool names (read/write/edit)
-            const extraNames = (0, agent_types_js_1.getMemoryToolNames)(existingNames);
+            const extraNames = getMemoryToolNames(existingNames);
             if (extraNames.length > 0)
                 toolNames = [...toolNames, ...extraNames];
-            extras.memoryBlock = (0, memory_js_1.buildMemoryBlock)(agentConfig.name, agentConfig.memory, configCwd);
+            extras.memoryBlock = buildMemoryBlock(agentConfig.name, agentConfig.memory, configCwd);
         }
         else {
             // Read-only memory: only add read tool name, use read-only prompt
-            const extraNames = (0, agent_types_js_1.getReadOnlyMemoryToolNames)(existingNames);
+            const extraNames = getReadOnlyMemoryToolNames(existingNames);
             if (extraNames.length > 0)
                 toolNames = [...toolNames, ...extraNames];
-            extras.memoryBlock = (0, memory_js_1.buildReadOnlyMemoryBlock)(agentConfig.name, agentConfig.memory, configCwd);
+            extras.memoryBlock = buildReadOnlyMemoryBlock(agentConfig.name, agentConfig.memory, configCwd);
         }
     }
     // Build system prompt from agent config
     let systemPrompt;
     if (agentConfig) {
-        systemPrompt = (0, prompts_js_1.buildAgentPrompt)(agentConfig, effectiveCwd, env, parentSystemPrompt, extras);
+        systemPrompt = buildAgentPrompt(agentConfig, effectiveCwd, env, parentSystemPrompt, extras);
     }
     else {
         // Unknown type fallback: spread the canonical general-purpose config (defensive —
         // unreachable in practice since index.ts resolves unknown types before calling runAgent).
-        const fallback = default_agents_js_1.DEFAULT_AGENTS.get("general-purpose");
+        const fallback = DEFAULT_AGENTS.get("general-purpose");
         if (!fallback)
             throw new Error(`No fallback config available for unknown type "${type}"`);
-        systemPrompt = (0, prompts_js_1.buildAgentPrompt)({ ...fallback, name: type }, effectiveCwd, env, parentSystemPrompt, extras);
+        systemPrompt = buildAgentPrompt({ ...fallback, name: type }, effectiveCwd, env, parentSystemPrompt, extras);
     }
     // When skills is string[], we've already preloaded them into the prompt.
     // Still pass noSkills: true since we don't need the skill loader to load them again.
     const noSkills = skills === false || Array.isArray(skills);
-    const agentDir = (0, pi_coding_agent_1.getAgentDir)();
+    const agentDir = getAgentDir();
     // Extension loading:
     // - true  → all default-discovered extensions
     // - false → none (noExtensions)
@@ -519,7 +502,7 @@ async function runAgent(ctx, type, prompt, options) {
                 }),
             };
         };
-    const loader = new pi_coding_agent_1.DefaultResourceLoader({
+    const loader = new DefaultResourceLoader({
         cwd: configCwd,
         agentDir,
         noExtensions,
@@ -538,7 +521,7 @@ async function runAgent(ctx, type, prompt, options) {
     // this produced a silently broken agent (#75) — pi-mono accepted the bogus name
     // into the allowlist, then dropped it at registration with no signal back.
     if (agentConfig?.builtinToolNames?.length) {
-        const knownBuiltins = new Set(agent_types_js_1.BUILTIN_TOOL_NAMES);
+        const knownBuiltins = new Set(BUILTIN_TOOL_NAMES);
         for (const name of agentConfig.builtinToolNames) {
             if (!knownBuiltins.has(name)) {
                 options.onToolActivity?.({
@@ -641,7 +624,7 @@ async function runAgent(ctx, type, prompt, options) {
     else {
         const denyTools = new Set(EXCLUDED_TOOL_NAMES);
         // Keep only the built-ins the agent asked for — deny the rest.
-        for (const name of agent_types_js_1.BUILTIN_TOOL_NAMES) {
+        for (const name of BUILTIN_TOOL_NAMES) {
             if (!builtinToolNameSet.has(name))
                 denyTools.add(name);
         }
@@ -651,25 +634,23 @@ async function runAgent(ctx, type, prompt, options) {
         }
         sessionExcludeTools = [...denyTools];
     }
-    const settingsManager = pi_coding_agent_1.SettingsManager.create(configCwd, agentDir);
+    const settingsManager = SettingsManager.create(configCwd, agentDir);
     const configuredSessionDir = resolveConfiguredSessionDir(agentConfig?.sessionDir, effectiveCwd);
     const defaultSessionDir = process.env.PI_CODING_AGENT_SESSION_DIR ?? settingsManager.getSessionDir?.();
     const sessionManager = agentConfig?.persistSession
-        ? pi_coding_agent_1.SessionManager.create(effectiveCwd, configuredSessionDir ?? defaultSessionDir)
-        : pi_coding_agent_1.SessionManager.inMemory(effectiveCwd);
+        ? SessionManager.create(effectiveCwd, configuredSessionDir ?? defaultSessionDir)
+        : SessionManager.inMemory(effectiveCwd);
     // Pi 0.80.8 replaced createAgentSession's modelRegistry option with
     // modelRuntime, but ExtensionContext still exposes only the registry facade.
     // Pass both so the full supported Pi range retains the parent's providers.
-    const parentModelRuntime = ctx.modelRegistry.runtime;
+    const parentModelRuntime = ctx.modelRegistry.runtime ?? undefined;
     const sessionOpts = {
         cwd: effectiveCwd,
         agentDir,
         sessionManager,
         settingsManager,
         modelRegistry: ctx.modelRegistry,
-        ...(parentModelRuntime != null && {
-            modelRuntime: parentModelRuntime,
-        }),
+        ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime }),
         model,
         tools: sessionTools,
         resourceLoader: loader,
@@ -680,7 +661,7 @@ async function runAgent(ctx, type, prompt, options) {
     if (thinkingLevel) {
         sessionOpts.thinkingLevel = thinkingLevel;
     }
-    const { session } = await (0, pi_coding_agent_1.createAgentSession)(sessionOpts);
+    const { session } = await createAgentSession(sessionOpts);
     const baseSessionName = agentConfig?.name ?? type;
     session.setSessionName(options.agentId ? `${baseSessionName}#${options.agentId.slice(0, 8)}` : baseSessionName);
     // Bind extensions so that session_start fires and extensions can initialize
@@ -763,7 +744,7 @@ async function runAgent(ctx, type, prompt, options) {
     // Build the effective prompt: optionally prepend parent context
     let effectivePrompt = prompt;
     if (options.inheritContext) {
-        const parentContext = (0, context_js_1.buildParentContext)(ctx);
+        const parentContext = buildParentContext(ctx);
         if (parentContext) {
             effectivePrompt = parentContext + prompt;
         }
@@ -785,7 +766,7 @@ async function runAgent(ctx, type, prompt, options) {
 /**
  * Send a new prompt to an existing session (resume).
  */
-async function resumeAgent(session, prompt, options = {}) {
+export async function resumeAgent(session, prompt, options = {}) {
     // Boundary for the history fallback: the session already holds prior turns,
     // so only assistant text produced by THIS resume prompt counts as its output
     // — a failed resume must not surface the previous turn's answer (#144).
@@ -829,19 +810,19 @@ async function resumeAgent(session, prompt, options = {}) {
  * Send a steering message to a running subagent.
  * The message will interrupt the agent after its current tool execution.
  */
-async function steerAgent(session, message) {
+export async function steerAgent(session, message) {
     await session.steer(message);
 }
 /**
  * Get the subagent's conversation messages as formatted text.
  */
-function getAgentConversation(session) {
+export function getAgentConversation(session) {
     const parts = [];
     for (const msg of session.messages) {
         if (msg.role === "user") {
             const text = typeof msg.content === "string"
                 ? msg.content
-                : (0, context_js_1.extractText)(msg.content);
+                : extractText(msg.content);
             if (text.trim())
                 parts.push(`[User]: ${text.trim()}`);
         }
@@ -860,7 +841,7 @@ function getAgentConversation(session) {
                 parts.push(`[Tool Calls]:\n${toolCalls.join("\n")}`);
         }
         else if (msg.role === "toolResult") {
-            const text = (0, context_js_1.extractText)(msg.content);
+            const text = extractText(msg.content);
             const truncated = text.length > 200 ? text.slice(0, 200) + "..." : text;
             parts.push(`[Tool Result (${msg.toolName})]: ${truncated}`);
         }

package/dist/agent-types.js

@@ -1,30 +1,12 @@
-"use strict";
 /**
  * agent-types.ts — Unified agent type registry.
  *
  * Merges embedded default agents with user-defined agents from .pi/agents/*.md, .agents/agents/*.md, and global agents.
  * User agents override defaults with the same name. Disabled agents are kept but excluded from spawning.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUILTIN_TOOL_NAMES = void 0;
-exports.isDefaultsDisabled = isDefaultsDisabled;
-exports.setDefaultsDisabled = setDefaultsDisabled;
-exports.registerAgents = registerAgents;
-exports.applyNicoOverrides = applyNicoOverrides;
-exports.resolveType = resolveType;
-exports.getAgentConfig = getAgentConfig;
-exports.getAvailableTypes = getAvailableTypes;
-exports.getAllTypes = getAllTypes;
-exports.getDefaultAgentNames = getDefaultAgentNames;
-exports.getUserAgentNames = getUserAgentNames;
-exports.isValidType = isValidType;
-exports.getMemoryToolNames = getMemoryToolNames;
-exports.getReadOnlyMemoryToolNames = getReadOnlyMemoryToolNames;
-exports.getToolNamesForType = getToolNamesForType;
-exports.getConfig = getConfig;
-const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
-const default_agents_js_1 = require("./default-agents.js");
-const nico_overrides_js_1 = require("./nico-overrides.js");
+import { createCodingTools, createReadOnlyTools } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_AGENTS } from "./default-agents.js";
+import { applyNicoOverridesToMap, readNicoAgentOverrides } from "./nico-overrides.js";
 /**
  * All known built-in tool names, derived from pi's own tool factories rather
  * than hardcoded so the set tracks pi-mono if it adds/renames a built-in.
@@ -33,27 +15,27 @@ const nico_overrides_js_1 = require("./nico-overrides.js");
  * (read, bash, edit, write, grep, find, ls). The `cwd` only binds tool
  * operations we never invoke here — we read each tool's `.name` and discard it.
  */
-exports.BUILTIN_TOOL_NAMES = [
-    ...new Set([...(0, pi_coding_agent_1.createCodingTools)("."), ...(0, pi_coding_agent_1.createReadOnlyTools)(".")].map((t) => t.name)),
+export const BUILTIN_TOOL_NAMES = [
+    ...new Set([...createCodingTools("."), ...createReadOnlyTools(".")].map((t) => t.name)),
 ];
 /** Unified runtime registry of all agents (defaults + user-defined). */
 const agents = new Map();
 /** When true, DEFAULT_AGENTS are skipped during registration. */
 let disableDefaults = false;
 /** Check whether default agents are disabled. */
-function isDefaultsDisabled() { return disableDefaults; }
+export function isDefaultsDisabled() { return disableDefaults; }
 /** Set whether default agents are disabled. */
-function setDefaultsDisabled(b) { disableDefaults = b; }
+export function setDefaultsDisabled(b) { disableDefaults = b; }
 /**
  * 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.
  */
-function registerAgents(userAgents) {
+export function registerAgents(userAgents) {
     agents.clear();
     // Start with defaults (unless disabled via settings)
     if (!disableDefaults) {
-        for (const [name, config] of default_agents_js_1.DEFAULT_AGENTS) {
+        for (const [name, config] of DEFAULT_AGENTS) {
             agents.set(name, config);
         }
     }
@@ -68,9 +50,9 @@ function registerAgents(userAgents) {
  * them as the highest-priority layer. Auto-registers agents that don't
  * exist in the registry yet.
  */
-function applyNicoOverrides() {
-    const { overrides, defaultModel } = (0, nico_overrides_js_1.readNicoAgentOverrides)(process.cwd());
-    (0, nico_overrides_js_1.applyNicoOverridesToMap)(agents, overrides, defaultModel);
+export function applyNicoOverrides() {
+    const { overrides, defaultModel } = readNicoAgentOverrides(process.cwd());
+    applyNicoOverridesToMap(agents, overrides, defaultModel);
 }
 /** Case-insensitive key resolution. */
 function resolveKey(name) {
@@ -84,38 +66,38 @@ function resolveKey(name) {
     return undefined;
 }
 /** Resolve a type name case-insensitively. Returns the canonical key or undefined. */
-function resolveType(name) {
+export function resolveType(name) {
     return resolveKey(name);
 }
 /** Get the agent config for a type (case-insensitive). */
-function getAgentConfig(name) {
+export function getAgentConfig(name) {
     const key = resolveKey(name);
     return key ? agents.get(key) : undefined;
 }
 /** Get all enabled type names (for spawning and tool descriptions). */
-function getAvailableTypes() {
+export function getAvailableTypes() {
     return [...agents.entries()]
         .filter(([_, config]) => config.enabled !== false)
         .map(([name]) => name);
 }
 /** Get all type names including disabled (for UI listing). */
-function getAllTypes() {
+export function getAllTypes() {
     return [...agents.keys()];
 }
 /** Get names of default agents currently in the registry. */
-function getDefaultAgentNames() {
+export function getDefaultAgentNames() {
     return [...agents.entries()]
         .filter(([_, config]) => config.isDefault === true)
         .map(([name]) => name);
 }
 /** Get names of user-defined agents (non-defaults) currently in the registry. */
-function getUserAgentNames() {
+export function getUserAgentNames() {
     return [...agents.entries()]
         .filter(([_, config]) => config.isDefault !== true)
         .map(([name]) => name);
 }
 /** Check if a type is valid and enabled (case-insensitive). */
-function isValidType(type) {
+export function isValidType(type) {
     const key = resolveKey(type);
     if (!key)
         return false;
@@ -126,7 +108,7 @@ const MEMORY_TOOL_NAMES = ["read", "write", "edit"];
 /**
  * Get memory tool names (read/write/edit) not already in the provided set.
  */
-function getMemoryToolNames(existingToolNames) {
+export function getMemoryToolNames(existingToolNames) {
     return MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
 }
 /** Tool names needed for read-only memory access. */
@@ -134,27 +116,27 @@ const READONLY_MEMORY_TOOL_NAMES = ["read"];
 /**
  * Get read-only memory tool names not already in the provided set.
  */
-function getReadOnlyMemoryToolNames(existingToolNames) {
+export function getReadOnlyMemoryToolNames(existingToolNames) {
     return READONLY_MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
 }
 /** Get built-in tool names for a type (case-insensitive). */
-function getToolNamesForType(type) {
+export function getToolNamesForType(type) {
     const key = resolveKey(type);
     const raw = key ? agents.get(key) : undefined;
     const config = raw?.enabled !== false ? raw : undefined;
     // `undefined` (definition omitted the field) → all built-ins; an explicit `[]`
     // (`tools: none` or a `tools:` with only `ext:` entries) → zero built-ins.
-    return config?.builtinToolNames ?? [...exports.BUILTIN_TOOL_NAMES];
+    return config?.builtinToolNames ?? [...BUILTIN_TOOL_NAMES];
 }
 /** Get config for a type (case-insensitive, returns a SubagentTypeConfig-compatible object). Falls back to general-purpose. */
-function getConfig(type) {
+export function getConfig(type) {
     const key = resolveKey(type);
     const config = key ? agents.get(key) : undefined;
     if (config && config.enabled !== false) {
         return {
             displayName: config.displayName ?? config.name,
             description: config.description,
-            builtinToolNames: config.builtinToolNames ?? exports.BUILTIN_TOOL_NAMES,
+            builtinToolNames: config.builtinToolNames ?? BUILTIN_TOOL_NAMES,
             extensions: config.extensions,
             excludeExtensions: config.excludeExtensions,
             skills: config.skills,
@@ -167,7 +149,7 @@ function getConfig(type) {
         return {
             displayName: gp.displayName ?? gp.name,
             description: gp.description,
-            builtinToolNames: gp.builtinToolNames ?? exports.BUILTIN_TOOL_NAMES,
+            builtinToolNames: gp.builtinToolNames ?? BUILTIN_TOOL_NAMES,
             extensions: gp.extensions,
             excludeExtensions: gp.excludeExtensions,
             skills: gp.skills,
@@ -178,7 +160,7 @@ function getConfig(type) {
     return {
         displayName: "Agent",
         description: "General-purpose agent for complex, multi-step tasks",
-        builtinToolNames: exports.BUILTIN_TOOL_NAMES,
+        builtinToolNames: BUILTIN_TOOL_NAMES,
         extensions: true,
         skills: true,
         promptMode: "append",

package/dist/context.js

@@ -1,12 +1,8 @@
-"use strict";
 /**
  * context.ts — Extract parent conversation context for subagent inheritance.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractText = extractText;
-exports.buildParentContext = buildParentContext;
 /** Extract text from a message content block array. */
-function extractText(content) {
+export function extractText(content) {
     return content
         .filter((c) => c.type === "text")
         .map((c) => c.text ?? "")
@@ -17,7 +13,7 @@ function extractText(content) {
  * Used when inherit_context is true to give the subagent visibility
  * into what has been discussed/done so far.
  */
-function buildParentContext(ctx) {
+export function buildParentContext(ctx) {
     const entries = ctx.sessionManager.getBranch();
     if (!entries || entries.length === 0)
         return "";

package/dist/cross-extension-rpc.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Cross-extension RPC handlers for the subagents extension.
  *
@@ -9,12 +8,9 @@
  *   success → { success: true, data?: T }
  *   error   → { success: false, error: string }
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROTOCOL_VERSION = void 0;
-exports.registerRpcHandlers = registerRpcHandlers;
-const model_resolver_js_1 = require("./model-resolver.js");
+import { resolveModel } from "./model-resolver.js";
 /** RPC protocol version — bumped when the envelope or method contracts change. */
-exports.PROTOCOL_VERSION = 2;
+export const PROTOCOL_VERSION = 2;
 /**
  * Wire a single RPC handler: listen on `channel`, run `fn(params)`,
  * emit the reply envelope on `channel:reply:${requestId}`.
@@ -40,10 +36,10 @@ function handleRpc(events, channel, fn) {
  * Register ping, spawn, and stop RPC handlers on the event bus.
  * Returns unsub functions for cleanup.
  */
-function registerRpcHandlers(deps) {
+export function registerRpcHandlers(deps) {
     const { events, pi, getCtx, manager } = deps;
     const unsubPing = handleRpc(events, "subagents:rpc:ping", () => {
-        return { version: exports.PROTOCOL_VERSION };
+        return { version: PROTOCOL_VERSION };
     });
     const unsubSpawn = handleRpc(events, "subagents:rpc:spawn", ({ type, prompt, options }) => {
         const ctx = getCtx();
@@ -61,7 +57,7 @@ function registerRpcHandlers(deps) {
             if (!registry) {
                 throw new Error(`Model override "${normalizedOptions.model}" provided but ctx.modelRegistry is unavailable`);
             }
-            const resolved = (0, model_resolver_js_1.resolveModel)(normalizedOptions.model, registry);
+            const resolved = resolveModel(normalizedOptions.model, registry);
             if (typeof resolved === "string") {
                 // resolveModel returns a human-readable error string when the
                 // input doesn't match any available model. Surface it instead of