@esso0428/pi-subagents 0.15.0 → 0.15.2

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.15.2] - 2026-09-10
+
+### Added
+- **Completed subagent records survive session reloads.** On `session_start`, the extension now reconstructs validated terminal records persisted as `subagents:record` entries. Restored records retain their result and status for `get_subagent_result`, but never pretend to have a live child session; running and queued records are ignored, and duplicate IDs use the newest branch entry.
+
+## [0.15.1] - 2026-09-10
+
+### Added
+- **Markdown-rendered subagent results.** Expanded foreground results and background completion notifications now render headings, lists, inline code, and fenced code through pi's Markdown renderer. Display output is capped to keep terminal notifications bounded; use `get_subagent_result` for the complete result.
+
 ## [0.14.3] - 2026-07-23
 
 ### Fixed

package/README.md

@@ -28,7 +28,7 @@ https://github.com/user-attachments/assets/8685261b-9338-4fea-8dfe-1c590d5df543
 - **Git worktree isolation** — run agents in isolated repo copies; changes auto-committed to branches on completion
 - **Skill preloading** — inject named skills into agent system prompts, discovered from `.pi/skills/`, `.agents/skills/`, and global locations (Pi-standard `<name>/SKILL.md` directory layout supported)
 - **Tool denylist** — block specific tools via `disallowed_tools` frontmatter
-- **Styled completion notifications** — background agent results render as themed, compact notification boxes (icon, stats, result preview) instead of raw XML. Expandable to show full output. Group completions render each agent individually
+- **Styled completion notifications** — background agent results render as themed, compact notification boxes (icon, stats, result preview) instead of raw XML. Expanded results render headings, lists, inline code, and fenced code as Markdown, with a bounded display to keep the TUI responsive. Group completions render each agent individually
 - **Event bus** — lifecycle events (`subagents:created`, `started`, `completed`, `failed`, `steered`, `compacted`) emitted via `pi.events`, enabling other extensions to react to sub-agent activity
 - **Cross-extension RPC** — other pi extensions can spawn and stop subagents via the `pi.events` event bus (`subagents:rpc:ping`, `subagents:rpc:spawn`, `subagents:rpc:stop`). Standardized reply envelopes with protocol versioning. Emits `subagents:ready` on session start
 - **Schedule subagents** — pass `schedule` to the `Agent` tool to fire on cron / interval / one-shot. Session-scoped jobs with PID-locked persistence; results land via the same `subagent-notification` followUp path as manual background completions; manage via `/agents → Scheduled jobs`
@@ -138,7 +138,7 @@ Individual agent results render Claude Code-style in the conversation:
 | **Error** | `✗ ↻3 · 3 tool uses · 12.4k token (8%)` / `⎿ Error: timeout` |
 | **Aborted** | `✗ ↻55≤50 · 55 tool uses · 102.3k token (95% · ⇊3)` / `⎿ Aborted (max turns exceeded)` |
 
-Completed results can be expanded (ctrl+o in pi) to show the full agent output inline.
+Completed results can be expanded (ctrl+o in pi) to show the agent output inline with Markdown formatting. Expanded output is capped at 50 rendered lines (background notification results at 30 lines) and ends with a marker when more output is available; use `get_subagent_result` for the complete result.
 
 By default, foreground and background agents each stream their full conversation to a per-subagent transcript — a JSON-lines file at `<os-tmpdir>/pi-subagents-<uid>/<cwd>/<session>/tasks/<agent-id>.output` (owner-only `0700`, cleared on reboot). Set `output_transcript: false` on a custom agent to write no transcript path or file for it, or set `outputTranscript: false` in `subagents.json` to make transcripts opt-in for the whole project (frontmatter overrides the project default). This governs **only** the transcript: it is independent of `persist_session` (the pi session on disk), and it does not affect `isolation: worktree` (which commits the agent's work to a git branch) or `memory:` (durable files) — set those accordingly if the goal is to keep a run off disk entirely. Background agent completion notifications render as styled boxes:
 

package/dist/agent-manager.d.ts

@@ -121,6 +121,14 @@ export declare class AgentManager {
      */
     steer(id: string, message: string): boolean;
     getRecord(id: string): AgentRecord | undefined;
+    /**
+     * Restore terminal records persisted in a parent session.
+     *
+     * Restored records deliberately have no live session, promise, or abort
+     * controller. Invalid data is ignored because session entries are persisted
+     * extension data and may have been written by an older version.
+     */
+    restoreCompleted(records: readonly unknown[]): void;
     listAgents(): AgentRecord[];
     abort(id: string): boolean;
     /** Dispose a record's session and remove it from the map. */

package/dist/agent-manager.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * agent-manager.ts — Tracks agents, background execution, resume support.
  *
@@ -5,14 +6,23 @@
  * Excess agents are queued and auto-started as running agents complete.
  * Foreground agents bypass the queue (they block the parent anyway).
  */
-import { randomUUID } from "node:crypto";
-import { statSync } from "node:fs";
-import { isAbsolute } from "node:path";
-import { resumeAgent, runAgent } from "./agent-runner.js";
-import { addUsage } from "./usage.js";
-import { cleanupWorktree, createWorktree, pruneWorktrees, } from "./worktree.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentManager = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const agent_runner_js_1 = require("./agent-runner.js");
+const usage_js_1 = require("./usage.js");
+const worktree_js_1 = require("./worktree.js");
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
+const TERMINAL_STATUSES = new Set([
+    "completed",
+    "steered",
+    "aborted",
+    "stopped",
+    "error",
+]);
 /**
  * Validate a caller-supplied SpawnOptions.cwd. `undefined`/`null` mean "unset"
  * (parent cwd). Anything else must be an absolute path to an existing
@@ -22,12 +32,12 @@ const DEFAULT_MAX_CONCURRENT = 4;
 function assertValidSpawnCwd(cwd) {
     if (cwd == null)
         return;
-    if (typeof cwd !== "string" || !isAbsolute(cwd)) {
+    if (typeof cwd !== "string" || !(0, node_path_1.isAbsolute)(cwd)) {
         throw new Error(`SpawnOptions.cwd must be an absolute path: "${String(cwd)}"`);
     }
     let isDirectory = false;
     try {
-        isDirectory = statSync(cwd).isDirectory();
+        isDirectory = (0, node_fs_1.statSync)(cwd).isDirectory();
     }
     catch {
         throw new Error(`SpawnOptions.cwd does not exist: "${cwd}"`);
@@ -36,7 +46,30 @@ function assertValidSpawnCwd(cwd) {
         throw new Error(`SpawnOptions.cwd is not a directory: "${cwd}"`);
     }
 }
-export class AgentManager {
+const RESTORABLE_STATUSES = new Set([
+    "completed",
+    "steered",
+    "aborted",
+    "stopped",
+    "error",
+]);
+function isRestorableRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return (typeof record.id === "string" &&
+        record.id.length > 0 &&
+        typeof record.type === "string" &&
+        typeof record.description === "string" &&
+        RESTORABLE_STATUSES.has(record.status) &&
+        typeof record.startedAt === "number" &&
+        Number.isFinite(record.startedAt) &&
+        typeof record.completedAt === "number" &&
+        Number.isFinite(record.completedAt) &&
+        (record.result === undefined || typeof record.result === "string") &&
+        (record.error === undefined || typeof record.error === "string"));
+}
+class AgentManager {
     agents = new Map();
     cleanupInterval;
     onComplete;
@@ -77,7 +110,7 @@ export class AgentManager {
         // call, not minutes later at drain. Throw (not warn): programmatic callers
         // can fix and retry; the RPC layer converts throws into error envelopes.
         assertValidSpawnCwd(options.cwd);
-        const id = randomUUID().slice(0, 17);
+        const id = (0, node_crypto_1.randomUUID)().slice(0, 17);
         const abortController = new AbortController();
         const record = {
             id,
@@ -130,7 +163,7 @@ export class AgentManager {
         // BEFORE state mutation so a throw doesn't leave the record half-running.
         let worktreeCwd;
         if (options.isolation === "worktree") {
-            const wt = createWorktree(baseCwd, id);
+            const wt = (0, worktree_js_1.createWorktree)(baseCwd, id);
             if (!wt) {
                 throw new Error('Cannot run with isolation: "worktree" — not a git repo, no commits yet, or `git worktree add` failed. ' +
                     'Initialize git and commit at least once, or omit `isolation`.');
@@ -158,7 +191,7 @@ export class AgentManager {
             detachParentSignal = () => options.signal.removeEventListener("abort", onParentAbort);
         }
         const detach = () => { detachParentSignal?.(); detachParentSignal = undefined; };
-        const promise = runAgent(ctx, type, prompt, {
+        const promise = (0, agent_runner_js_1.runAgent)(ctx, type, prompt, {
             pi,
             agentId: id,
             model: options.model,
@@ -182,7 +215,7 @@ export class AgentManager {
             onTurnEnd: options.onTurnEnd,
             onTextDelta: options.onTextDelta,
             onAssistantUsage: (usage) => {
-                addUsage(record.lifetimeUsage, usage);
+                (0, usage_js_1.addUsage)(record.lifetimeUsage, usage);
                 options.onAssistantUsage?.(usage);
             },
             onCompaction: (info) => {
@@ -233,7 +266,7 @@ export class AgentManager {
             }
             // Clean up worktree if used
             if (record.worktree) {
-                const wtResult = cleanupWorktree(baseCwd, record.worktree, options.description);
+                const wtResult = (0, worktree_js_1.cleanupWorktree)(baseCwd, record.worktree, options.description);
                 record.worktreeResult = wtResult;
                 if (wtResult.hasChanges && wtResult.branch) {
                     // With a caller-supplied cwd the branch lives in THAT repo, not the
@@ -281,7 +314,7 @@ export class AgentManager {
             // Best-effort worktree cleanup on error
             if (record.worktree) {
                 try {
-                    const wtResult = cleanupWorktree(baseCwd, record.worktree, options.description);
+                    const wtResult = (0, worktree_js_1.cleanupWorktree)(baseCwd, record.worktree, options.description);
                     record.worktreeResult = wtResult;
                 }
                 catch { /* ignore cleanup errors */ }
@@ -366,13 +399,13 @@ export class AgentManager {
         record.result = undefined;
         record.error = undefined;
         try {
-            const { text, failure } = await resumeAgent(record.session, prompt, {
+            const { text, failure } = await (0, agent_runner_js_1.resumeAgent)(record.session, prompt, {
                 onToolActivity: (activity) => {
                     if (activity.type === "end")
                         record.toolUses++;
                 },
                 onAssistantUsage: (usage) => {
-                    addUsage(record.lifetimeUsage, usage);
+                    (0, usage_js_1.addUsage)(record.lifetimeUsage, usage);
                 },
                 onCompaction: (info) => {
                     record.compactionCount++;
@@ -422,6 +455,40 @@ export class AgentManager {
     getRecord(id) {
         return this.agents.get(id);
     }
+    /**
+     * Restore terminal records persisted in a parent session.
+     *
+     * Restored records deliberately have no live session, promise, or abort
+     * controller. Invalid data is ignored because session entries are persisted
+     * extension data and may have been written by an older version.
+     */
+    restoreCompleted(records) {
+        const restoredIds = new Set();
+        // getBranch() is chronological; newest persisted state wins on duplicate IDs.
+        for (const value of [...records].reverse()) {
+            if (!isRestorableRecord(value))
+                continue;
+            if (restoredIds.has(value.id) || this.agents.has(value.id))
+                continue;
+            restoredIds.add(value.id);
+            this.agents.set(value.id, {
+                id: value.id,
+                type: value.type,
+                description: value.description,
+                status: value.status,
+                result: value.result,
+                error: value.error,
+                toolUses: 0,
+                startedAt: value.startedAt,
+                completedAt: value.completedAt,
+                lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
+                compactionCount: 0,
+                // Historical records have no inline tool surface and should remain
+                // visible in the background widget.
+                isBackground: true,
+            });
+        }
+    }
     listAgents() {
         return [...this.agents.values()].sort((a, b) => b.startedAt - a.startedAt);
     }
@@ -527,16 +594,17 @@ export class AgentManager {
         this.agents.clear();
         // Prune any orphaned git worktrees (crash recovery)
         try {
-            pruneWorktrees(process.cwd());
+            (0, worktree_js_1.pruneWorktrees)(process.cwd());
         }
         catch { /* ignore */ }
         // Also prune repos that caller-supplied cwds created worktrees in — a clean
         // exit with in-flight agents would otherwise leave stale registrations there.
         for (const repo of this.worktreeRepos) {
             try {
-                pruneWorktrees(repo);
+                (0, worktree_js_1.pruneWorktrees)(repo);
             }
             catch { /* ignore */ }
         }
     }
 }
+exports.AgentManager = AgentManager;

package/dist/agent-runner.js

@@ -1,30 +1,47 @@
+"use strict";
 /**
  * agent-runner.ts — Core execution engine: creates sessions, runs agents, collects results.
  */
-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";
+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");
 /**
  * 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.
  */
-export const SUBAGENT_TOOL_NAMES = {
+exports.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(SUBAGENT_TOOL_NAMES);
+const EXCLUDED_TOOL_NAMES = Object.values(exports.SUBAGENT_TOOL_NAMES);
 /**
  * Canonical name of an extension for `extensions: [...]` allowlist matching.
  * Lowercased — extension names match case-insensitively so `extensions: [Mcp]`
@@ -32,10 +49,10 @@ const EXCLUDED_TOOL_NAMES = Object.values(SUBAGENT_TOOL_NAMES);
  * Directory extensions (`foo/index.ts`) resolve to the parent directory name;
  * single-file extensions to the basename minus `.ts`/`.js`.
  */
-export function extensionCanonicalName(extPath) {
-    const base = basename(extPath);
+function extensionCanonicalName(extPath) {
+    const base = (0, node_path_1.basename)(extPath);
     const name = base === "index.ts" || base === "index.js"
-        ? basename(dirname(extPath))
+        ? (0, node_path_1.basename)((0, node_path_1.dirname)(extPath))
         : base.replace(/\.(ts|js)$/, "");
     return name.toLowerCase();
 }
@@ -59,18 +76,18 @@ export function extensionCanonicalName(extPath) {
  * co-located file to `pi-subagents`.
  */
 function extensionPackageName(extPath) {
-    const entry = resolve(extPath);
-    let dir = dirname(extPath);
+    const entry = (0, node_path_1.resolve)(extPath);
+    let dir = (0, node_path_1.dirname)(extPath);
     for (;;) {
         // Climbing into node_modules means we've left the owning package's tree.
-        if (basename(dir) === "node_modules")
+        if ((0, node_path_1.basename)(dir) === "node_modules")
             return undefined;
         let pkg;
         try {
-            pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+            pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, "package.json"), "utf-8"));
         }
         catch {
-            const parent = dirname(dir);
+            const parent = (0, node_path_1.dirname)(dir);
             if (parent === dir)
                 return undefined; // walked to the filesystem root
             dir = parent;
@@ -80,7 +97,7 @@ function extensionPackageName(extPath) {
         const entries = pkg.pi?.extensions;
         if (typeof pkg.name === "string" &&
             Array.isArray(entries) &&
-            entries.some((e) => typeof e === "string" && resolve(dir, e) === entry)) {
+            entries.some((e) => typeof e === "string" && (0, node_path_1.resolve)(dir, e) === entry)) {
             const short = pkg.name.startsWith("@") ? pkg.name.slice(pkg.name.indexOf("/") + 1) : pkg.name;
             return short.toLowerCase();
         }
@@ -95,7 +112,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.
  */
-export function extensionCanonicalNames(extPath) {
+function extensionCanonicalNames(extPath) {
     const canonical = extensionCanonicalName(extPath);
     const pkg = extensionPackageName(extPath);
     return pkg && pkg !== canonical ? [canonical, pkg] : [canonical];
@@ -111,7 +128,7 @@ export function extensionCanonicalNames(extPath) {
  * everything by canonical name, so path-loaded extensions are matched via their name
  * rather than their post-staging `Extension.path`.
  */
-export function parseExtensionsSpec(entries, cwd) {
+function parseExtensionsSpec(entries, cwd) {
     const names = new Set();
     const paths = [];
     let wildcard = false;
@@ -129,9 +146,9 @@ export function parseExtensionsSpec(entries, cwd) {
         }
         let p = entry;
         if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-            p = homedir() + p.slice(1);
+            p = (0, node_os_1.homedir)() + p.slice(1);
         }
-        const abs = isAbsolute(p) ? p : resolve(cwd, p);
+        const abs = (0, node_path_1.isAbsolute)(p) ? p : (0, node_path_1.resolve)(cwd, p);
         paths.push(abs);
         names.add(extensionCanonicalName(abs));
     }
@@ -147,7 +164,7 @@ export 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 `/`.
  */
-export function parseExtSelectors(entries) {
+function parseExtSelectors(entries) {
     const extNames = new Set();
     const narrowing = new Map();
     for (const raw of entries) {
@@ -201,7 +218,7 @@ export function parseExtSelectors(entries) {
  * Only meaningful when extensions are loaded — under `noExtensions`/`isolated` the
  * static `allowedToolNames` allowlist already gates the registry itself.
  */
-export function installExtensionToolScope(session, ctx) {
+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
@@ -260,21 +277,21 @@ export function installExtensionToolScope(session, ctx) {
 /** Default max turns. undefined = unlimited (no turn limit). */
 let defaultMaxTurns;
 /** Normalize max turns. undefined or 0 = unlimited, otherwise minimum 1. */
-export function normalizeMaxTurns(n) {
+function normalizeMaxTurns(n) {
     if (n == null || n === 0)
         return undefined;
     return Math.max(1, n);
 }
 /** Get the default max turns value. undefined = unlimited. */
-export function getDefaultMaxTurns() { return defaultMaxTurns; }
+function getDefaultMaxTurns() { return defaultMaxTurns; }
 /** Set the default max turns value. undefined or 0 = unlimited, otherwise minimum 1. */
-export function setDefaultMaxTurns(n) { defaultMaxTurns = normalizeMaxTurns(n); }
+function setDefaultMaxTurns(n) { defaultMaxTurns = normalizeMaxTurns(n); }
 /** Additional turns allowed after the soft limit steer message. */
 let graceTurns = 5;
 /** Get the grace turns value. */
-export function getGraceTurns() { return graceTurns; }
+function getGraceTurns() { return graceTurns; }
 /** Set the grace turns value (minimum 1). */
-export function setGraceTurns(n) { graceTurns = Math.max(1, n); }
+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.
@@ -329,7 +346,7 @@ function getLastAssistantText(session, startIndex = 0) {
         const msg = session.messages[i];
         if (msg.role !== "assistant")
             continue;
-        const text = extractText(msg.content).trim();
+        const text = (0, context_js_1.extractText)(msg.content).trim();
         if (text)
             return text;
     }
@@ -357,7 +374,7 @@ function finalTurnError(session, startIndex = 0) {
         if (msg.stopReason === "error") {
             return msg.errorMessage?.trim() || "provider error with no output";
         }
-        if (msg.stopReason === "length" && !extractText(msg.content).trim()) {
+        if (msg.stopReason === "length" && !(0, context_js_1.extractText)(msg.content).trim()) {
             return "run hit the output token limit before producing any text";
         }
         return undefined;
@@ -379,20 +396,20 @@ function resolveConfiguredSessionDir(sessionDir, cwd) {
     if (!sessionDir)
         return undefined;
     if (sessionDir === "~" || sessionDir.startsWith("~/"))
-        return resolve(homedir(), sessionDir.slice(2));
-    if (isAbsolute(sessionDir))
+        return (0, node_path_1.resolve)((0, node_os_1.homedir)(), sessionDir.slice(2));
+    if ((0, node_path_1.isAbsolute)(sessionDir))
         return sessionDir;
-    return resolve(cwd, sessionDir);
+    return (0, node_path_1.resolve)(cwd, sessionDir);
 }
-export async function runAgent(ctx, type, prompt, options) {
-    const config = getConfig(type);
-    const agentConfig = getAgentConfig(type);
+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);
     // 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 detectEnv(options.pi, effectiveCwd);
+    const env = await (0, env_js_1.detectEnv)(options.pi, effectiveCwd);
     // Get parent system prompt for append-mode agents
     const parentSystemPrompt = ctx.getSystemPrompt();
     // Build prompt extras (memory, skill preloading)
@@ -405,12 +422,12 @@ export 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 = preloadSkills(skills, configCwd);
+        const loaded = (0, skill_loader_js_1.preloadSkills)(skills, configCwd);
         if (loaded.length > 0) {
             extras.skillBlocks = loaded;
         }
     }
-    let toolNames = getToolNamesForType(type);
+    let toolNames = (0, agent_types_js_1.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) {
@@ -420,36 +437,36 @@ export 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 = getMemoryToolNames(existingNames);
+            const extraNames = (0, agent_types_js_1.getMemoryToolNames)(existingNames);
             if (extraNames.length > 0)
                 toolNames = [...toolNames, ...extraNames];
-            extras.memoryBlock = buildMemoryBlock(agentConfig.name, agentConfig.memory, configCwd);
+            extras.memoryBlock = (0, memory_js_1.buildMemoryBlock)(agentConfig.name, agentConfig.memory, configCwd);
         }
         else {
             // Read-only memory: only add read tool name, use read-only prompt
-            const extraNames = getReadOnlyMemoryToolNames(existingNames);
+            const extraNames = (0, agent_types_js_1.getReadOnlyMemoryToolNames)(existingNames);
             if (extraNames.length > 0)
                 toolNames = [...toolNames, ...extraNames];
-            extras.memoryBlock = buildReadOnlyMemoryBlock(agentConfig.name, agentConfig.memory, configCwd);
+            extras.memoryBlock = (0, memory_js_1.buildReadOnlyMemoryBlock)(agentConfig.name, agentConfig.memory, configCwd);
         }
     }
     // Build system prompt from agent config
     let systemPrompt;
     if (agentConfig) {
-        systemPrompt = buildAgentPrompt(agentConfig, effectiveCwd, env, parentSystemPrompt, extras);
+        systemPrompt = (0, prompts_js_1.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.get("general-purpose");
+        const fallback = default_agents_js_1.DEFAULT_AGENTS.get("general-purpose");
         if (!fallback)
             throw new Error(`No fallback config available for unknown type "${type}"`);
-        systemPrompt = buildAgentPrompt({ ...fallback, name: type }, effectiveCwd, env, parentSystemPrompt, extras);
+        systemPrompt = (0, prompts_js_1.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 = getAgentDir();
+    const agentDir = (0, pi_coding_agent_1.getAgentDir)();
     // Extension loading:
     // - true  → all default-discovered extensions
     // - false → none (noExtensions)
@@ -502,7 +519,7 @@ export async function runAgent(ctx, type, prompt, options) {
                 }),
             };
         };
-    const loader = new DefaultResourceLoader({
+    const loader = new pi_coding_agent_1.DefaultResourceLoader({
         cwd: configCwd,
         agentDir,
         noExtensions,
@@ -521,7 +538,7 @@ export 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(BUILTIN_TOOL_NAMES);
+        const knownBuiltins = new Set(agent_types_js_1.BUILTIN_TOOL_NAMES);
         for (const name of agentConfig.builtinToolNames) {
             if (!knownBuiltins.has(name)) {
                 options.onToolActivity?.({
@@ -624,7 +641,7 @@ export 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 BUILTIN_TOOL_NAMES) {
+        for (const name of agent_types_js_1.BUILTIN_TOOL_NAMES) {
             if (!builtinToolNameSet.has(name))
                 denyTools.add(name);
         }
@@ -634,12 +651,12 @@ export async function runAgent(ctx, type, prompt, options) {
         }
         sessionExcludeTools = [...denyTools];
     }
-    const settingsManager = SettingsManager.create(configCwd, agentDir);
+    const settingsManager = pi_coding_agent_1.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
-        ? SessionManager.create(effectiveCwd, configuredSessionDir ?? defaultSessionDir)
-        : SessionManager.inMemory(effectiveCwd);
+        ? pi_coding_agent_1.SessionManager.create(effectiveCwd, configuredSessionDir ?? defaultSessionDir)
+        : pi_coding_agent_1.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.
@@ -650,7 +667,9 @@ export async function runAgent(ctx, type, prompt, options) {
         sessionManager,
         settingsManager,
         modelRegistry: ctx.modelRegistry,
-        ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime }),
+        ...(parentModelRuntime != null && {
+            modelRuntime: parentModelRuntime,
+        }),
         model,
         tools: sessionTools,
         resourceLoader: loader,
@@ -661,7 +680,7 @@ export async function runAgent(ctx, type, prompt, options) {
     if (thinkingLevel) {
         sessionOpts.thinkingLevel = thinkingLevel;
     }
-    const { session } = await createAgentSession(sessionOpts);
+    const { session } = await (0, pi_coding_agent_1.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
@@ -744,7 +763,7 @@ export async function runAgent(ctx, type, prompt, options) {
     // Build the effective prompt: optionally prepend parent context
     let effectivePrompt = prompt;
     if (options.inheritContext) {
-        const parentContext = buildParentContext(ctx);
+        const parentContext = (0, context_js_1.buildParentContext)(ctx);
         if (parentContext) {
             effectivePrompt = parentContext + prompt;
         }
@@ -766,7 +785,7 @@ export async function runAgent(ctx, type, prompt, options) {
 /**
  * Send a new prompt to an existing session (resume).
  */
-export async function resumeAgent(session, prompt, options = {}) {
+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).
@@ -810,19 +829,19 @@ export 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.
  */
-export async function steerAgent(session, message) {
+async function steerAgent(session, message) {
     await session.steer(message);
 }
 /**
  * Get the subagent's conversation messages as formatted text.
  */
-export function getAgentConversation(session) {
+function getAgentConversation(session) {
     const parts = [];
     for (const msg of session.messages) {
         if (msg.role === "user") {
             const text = typeof msg.content === "string"
                 ? msg.content
-                : extractText(msg.content);
+                : (0, context_js_1.extractText)(msg.content);
             if (text.trim())
                 parts.push(`[User]: ${text.trim()}`);
         }
@@ -841,7 +860,7 @@ export function getAgentConversation(session) {
                 parts.push(`[Tool Calls]:\n${toolCalls.join("\n")}`);
         }
         else if (msg.role === "toolResult") {
-            const text = extractText(msg.content);
+            const text = (0, context_js_1.extractText)(msg.content);
             const truncated = text.length > 200 ? text.slice(0, 200) + "..." : text;
             parts.push(`[Tool Result (${msg.toolName})]: ${truncated}`);
         }