agent-sh 0.12.27 → 0.13.1

package/dist/{index.js → cli/index.js}

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import * as path from "node:path";
-import { activateShell, registerShellHandlers } from "./shell/index.js";
-import { createCore } from "./core.js";
-import { palette as p } from "./utils/palette.js";
-import { loadBuiltinExtensions } from "./extensions/index.js";
-import { loadExtensions } from "./extension-loader.js";
-import { getSettings } from "./settings.js";
-import { runInit } from "./init.js";
-import { runInstall, runUninstall, runList, suggestBridgeFor } from "./install.js";
-import { PACKAGE_VERSION } from "./utils/package-version.js";
+import { activateShell, registerShellHandlers } from "../shell/index.js";
+import { pickStrategy, FALLBACK_STRATEGY } from "../shell/strategies/index.js";
+import { activateAgent } from "../agent/index.js";
+import { createCore } from "../core/index.js";
+import { palette as p } from "../utils/palette.js";
+import { loadBuiltinExtensions } from "../extensions/index.js";
+import { loadExtensions } from "../core/extension-loader.js";
+import { getSettings } from "../core/settings.js";
+import { dispatchSubcommand } from "./subcommands.js";
+import { suggestBridgeFor } from "./install.js";
+import { anyProviderConfigured } from "./auth/keys.js";
+import { PACKAGE_VERSION } from "../utils/package-version.js";
+import { clearOpost } from "../utils/tty.js";
 /**
  * Capture the user's full shell environment.
  * This picks up env vars exported in .zshrc/.bashrc that the
@@ -25,12 +28,9 @@ async function captureShellEnvAsync(shell) {
             resolve(result);
         };
         try {
-            const shellName = path.basename(shell);
-            const isZsh = shellName.includes("zsh");
-            const sourceRc = isZsh
-                ? 'source ~/.zshrc 2>/dev/null;'
-                : '[ -f ~/.bashrc ] && source ~/.bashrc 2>/dev/null;';
-            const child = spawn(shell, ["-l", "-c", `${sourceRc} env -0`], {
+            const strategy = pickStrategy(shell) ?? FALLBACK_STRATEGY;
+            const captureCmd = strategy.envCaptureCommand();
+            const child = spawn(shell, ["-l", "-c", captureCmd], {
                 stdio: ["ignore", "pipe", "ignore"],
                 timeout: 5000,
             });
@@ -119,6 +119,9 @@ Usage: agent-sh [options]
        agent-sh install <spec> [--force]  Install an extension (bundled name, file:, npm:, github:)
        agent-sh uninstall <name>          Remove an installed extension
        agent-sh list                      List installed extensions
+       agent-sh auth login [provider]     Store an API key for a built-in provider
+       agent-sh auth logout <provider>    Remove a stored key
+       agent-sh auth list                 Show configured providers
 
 Provider Profiles:
   --provider <name>   Use a provider from ~/.agent-sh/settings.json
@@ -161,24 +164,9 @@ Inside the shell:
     return { shell, model, extensions, apiKey, baseURL, provider, backend };
 }
 async function main() {
-    // Subcommands — handled before the shell-launch path.
     const rawArgs = process.argv.slice(2);
-    if (rawArgs[0] === "init") {
-        runInit({ force: rawArgs.includes("--force") });
+    if (await dispatchSubcommand(rawArgs))
         return;
-    }
-    if (rawArgs[0] === "install") {
-        await runInstall(rawArgs[1] ?? "", { force: rawArgs.includes("--force") });
-        return;
-    }
-    if (rawArgs[0] === "uninstall") {
-        await runUninstall(rawArgs[1] ?? "");
-        return;
-    }
-    if (rawArgs[0] === "list") {
-        runList();
-        return;
-    }
     if (process.env.AGENT_SH) {
         console.error("agent-sh: already running inside an agent-sh session (nested sessions are not supported).");
         process.exit(1);
@@ -212,6 +200,13 @@ async function main() {
     catch {
         // Ignore errors, we already have process.env as fallback
     }
+    if (!config.apiKey && !config.provider && !anyProviderConfigured()) {
+        console.error("\nagent-sh: no LLM provider configured.\n\n" +
+            "  Run `agent-sh auth login` to store an API key, or\n" +
+            "  export OPENAI_API_KEY / OPENROUTER_API_KEY / DEEPSEEK_API_KEY, or\n" +
+            "  run `agent-sh init` for a settings.json template.\n");
+        process.exit(1);
+    }
     // ── Core (frontend-agnostic) ──────────────────────────────────
     const core = createCore(config);
     const { bus } = core;
@@ -239,6 +234,7 @@ async function main() {
     const extCtx = core.extensionContext({ quit: cleanup });
     // Before loadExtensions: extensions look up shell handlers at activation.
     registerShellHandlers(extCtx);
+    activateAgent(extCtx);
     // Load before spawning the shell so PS1 lands below the banner.
     await loadBuiltinExtensions(extCtx, getSettings().disabledBuiltins);
     const loadExtensionsTimeoutMs = 10000;
@@ -340,6 +336,7 @@ async function main() {
         if (process.stdin.isTTY) {
             try {
                 process.stdin.setRawMode(true);
+                clearOpost();
             }
             catch {
                 // May fail if stdin is not a TTY

package/dist/{init.js → cli/init.js}

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { CONFIG_DIR } from "./settings.js";
+import { CONFIG_DIR } from "../core/settings.js";
 const EXTENSIONS_DIR = path.join(CONFIG_DIR, "extensions");
 const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const EXAMPLE_PATH = path.join(CONFIG_DIR, "settings.example.json");

package/dist/{install.js → cli/install.js}

@@ -2,13 +2,13 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
-import { CONFIG_DIR, getSettings } from "./settings.js";
+import { CONFIG_DIR, getSettings } from "../core/settings.js";
 // Kept in sync with extension-loader.ts SCRIPT_EXTS.
 const SCRIPT_EXTS = [".js", ".mjs", ".ts", ".tsx", ".mts"];
 function hasIndexFile(dir) {
     return SCRIPT_EXTS.some((ext) => fs.existsSync(path.join(dir, `index${ext}`)));
 }
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../");
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../");
 const BUNDLED_DIR = path.join(PACKAGE_ROOT, "examples/extensions");
 const EXT_DIR = path.join(CONFIG_DIR, "extensions");
 export function listBundled() {
@@ -75,6 +75,34 @@ function readPackageJson(target) {
         return null;
     return JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
 }
+/** Relative `file:` deps in bundled extensions (e.g. `"agent-sh": "file:../../.."`)
+ *  point at the wrong location after the source is copied into ~/.agent-sh/extensions/.
+ *  Resolve them against the original source dir so npm install in the target succeeds. */
+function rewriteFileDeps(target, sourcePath) {
+    const pkgJson = path.join(target, "package.json");
+    if (!fs.existsSync(pkgJson))
+        return;
+    const raw = fs.readFileSync(pkgJson, "utf-8");
+    const pkg = JSON.parse(raw);
+    const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+    let changed = false;
+    for (const section of sections) {
+        const deps = pkg[section];
+        if (!deps || typeof deps !== "object")
+            continue;
+        for (const [name, spec] of Object.entries(deps)) {
+            if (typeof spec !== "string" || !spec.startsWith("file:"))
+                continue;
+            const rel = spec.slice("file:".length);
+            if (path.isAbsolute(rel))
+                continue;
+            deps[name] = `file:${path.resolve(sourcePath, rel)}`;
+            changed = true;
+        }
+    }
+    if (changed)
+        fs.writeFileSync(pkgJson, `${JSON.stringify(pkg, null, 2)}\n`);
+}
 function maybeNpmInstall(target, pkg) {
     const deps = { ...(pkg.dependencies ?? {}), ...(pkg.peerDependencies ?? {}) };
     if (Object.keys(deps).length === 0)
@@ -170,6 +198,7 @@ export async function runInstall(spec, opts = {}) {
     if (resolved.isDirectory) {
         fs.cpSync(resolved.sourcePath, target, { recursive: true });
         try {
+            rewriteFileDeps(target, resolved.sourcePath);
             const pkg = readPackageJson(target);
             if (pkg) {
                 maybeNpmInstall(target, pkg);

package/dist/cli/subcommands.d.ts

@@ -0,0 +1 @@
+export declare function dispatchSubcommand(argv: string[]): Promise<boolean>;

package/dist/cli/subcommands.js

@@ -0,0 +1,17 @@
+import { runInit } from "./init.js";
+import { runInstall, runUninstall, runList } from "./install.js";
+import { runAuth } from "./auth/cli.js";
+const SUBCOMMANDS = {
+    init: (args) => runInit({ force: args.includes("--force") }),
+    install: (args) => runInstall(args[0] ?? "", { force: args.includes("--force") }),
+    uninstall: (args) => runUninstall(args[0] ?? ""),
+    list: () => runList(),
+    auth: (args) => runAuth(args),
+};
+export async function dispatchSubcommand(argv) {
+    const handler = SUBCOMMANDS[argv[0] ?? ""];
+    if (!handler)
+        return false;
+    await handler(argv.slice(1));
+    return true;
+}

package/dist/{event-bus.d.ts → core/event-bus.d.ts}

@@ -1,5 +1,5 @@
-import type { AgentMode } from "./types.js";
-import type { ToolResultDisplay } from "./agent/types.js";
+import type { AgentMode } from "../agent/host-types.js";
+import type { ToolResultDisplay } from "../agent/types.js";
 /**
  * Typed event map — every event has a known payload shape.
  */
@@ -50,7 +50,7 @@ export interface ShellEvents {
     "agent:append-user-message": {
         text: string;
     };
-    "input-mode:register": import("./types.js").InputModeConfig;
+    "input-mode:register": import("../shell/host-types.js").InputModeConfig;
     "agent:query": {
         query: string;
     };
@@ -136,6 +136,8 @@ export interface ShellEvents {
         rawInput?: unknown;
         /** Pre-formatted display detail from tool's formatCall(). */
         displayDetail?: string;
+        /** highlight.js-style identifier for syntax-highlighting `rawInput.source`. */
+        sourceLanguage?: string;
         batchIndex?: number;
         batchTotal?: number;
     };
@@ -162,14 +164,6 @@ export interface ShellEvents {
     };
     "tool:interactive-start": Record<string, never>;
     "tool:interactive-end": Record<string, never>;
-    "permission:request": {
-        kind: string;
-        title: string;
-        metadata: Record<string, unknown>;
-        /** Interactive UI capability — available when the built-in agent is active. */
-        ui?: unknown;
-        decision: Record<string, unknown>;
-    };
     "command:register": {
         name: string;
         description: string;
@@ -336,14 +330,14 @@ export interface ShellEvents {
         reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
     };
     "agent:register-tool": {
-        tool: import("./agent/types.js").ToolDefinition;
+        tool: import("../agent/types.js").ToolDefinition;
         extensionName?: string;
     };
     "agent:unregister-tool": {
         name: string;
     };
     "agent:get-tools": {
-        tools: import("./agent/types.js").ToolDefinition[];
+        tools: import("../agent/types.js").ToolDefinition[];
     };
     "agent:register-instruction": {
         name: string;

package/dist/{extension-loader.d.ts → core/extension-loader.d.ts}

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "./types.js";
+import type { ExtensionContext } from "../shell/host-types.js";
 /**
  * Load extensions from three sources (merged, deduplicated):
  *

package/dist/{extension-loader.js → core/extension-loader.js}

@@ -23,7 +23,6 @@ async function ensureTsSupport(force = false) {
     if (tsRegistered && !force)
         return;
     try {
-        // Unregister previous loader if reloading
         if (tsxUnregister) {
             try {
                 await tsxUnregister();
@@ -39,70 +38,84 @@ async function ensureTsSupport(force = false) {
     }
 }
 /**
- * Wrap an ExtensionContext to track all registrations (bus.on, bus.onPipe,
- * advise, command:register). Returns the wrapped context and a dispose()
- * function that tears down everything registered through it.
+ * Wrap an ExtensionContext to track all registrations (bus.on, advise,
+ * command:register, plus all agent/shell surface registrars). Returns
+ * the wrapped context and a dispose() that tears down everything
+ * registered through it.
  */
 function createScopedContext(ctx, extensionName) {
     const cleanups = [];
     const bus = ctx.bus;
     const scopedBus = Object.create(bus);
-    // Track bus.on registrations
     scopedBus.on = ((event, fn) => {
         bus.on(event, fn);
         cleanups.push(() => bus.off(event, fn));
     });
-    // Track bus.onPipe registrations
     scopedBus.onPipe = ((event, fn) => {
         bus.onPipe(event, fn);
         cleanups.push(() => bus.offPipe(event, fn));
     });
-    // Track advise registrations
-    const scopedAdvise = (name, wrapper) => {
-        const unadvise = ctx.advise(name, wrapper);
-        cleanups.push(unadvise);
-        return unadvise;
+    // Wrap any (name, fn) → unsubscribe registrar so its disposer runs on teardown.
+    const trackUnsub = (fn) => (a, b) => {
+        const unsub = fn(a, b);
+        cleanups.push(unsub);
+        return unsub;
     };
-    // Track instruction registrations — extension name captured in scope
-    const scopedRegisterInstruction = (name, text) => {
-        bus.emit("agent:register-instruction", { name, text, extensionName });
-        cleanups.push(() => bus.emit("agent:remove-instruction", { name }));
-    };
-    // Track skill registrations — extension name captured in scope
-    const scopedRegisterSkill = (name, description, filePath) => {
-        bus.emit("agent:register-skill", { name, description, filePath, extensionName });
-        cleanups.push(() => bus.emit("agent:remove-skill", { name }));
-    };
-    // Track dynamic-context producer registrations
-    const scopedRegisterContextProducer = (name, producer) => {
-        const dispose = ctx.registerContextProducer(name, producer);
-        cleanups.push(dispose);
-        return dispose;
-    };
-    // Track tool registrations — extension name captured in scope
-    const scopedRegisterTool = (tool) => {
-        bus.emit("agent:register-tool", { tool, extensionName });
-        cleanups.push(() => bus.emit("agent:unregister-tool", { name: tool.name }));
-    };
-    // Track slash command registrations — without this, reloading an
-    // extension stacks its commands (old `/status` + new `/status`) in
-    // the slash-commands registry.
+    // ── substrate / sugar ──────────────────────────────────────
+    const scopedAdvise = trackUnsub(ctx.advise);
+    // Without this, reloading an extension stacks its commands (old + new)
+    // in the slash-commands registry.
     const scopedRegisterCommand = (name, description, handler) => {
         ctx.registerCommand(name, description, handler);
         cleanups.push(() => bus.emit("command:unregister", { name }));
     };
+    const scopedAdviseCommand = trackUnsub(ctx.adviseCommand);
+    // ── agent surface (optional — bridge backends omit it) ───
+    const agent = ctx.agent;
+    let scopedAgent;
+    if (agent) {
+        scopedAgent = {
+            ...agent,
+            registerTool: (tool) => {
+                bus.emit("agent:register-tool", { tool, extensionName });
+                cleanups.push(() => bus.emit("agent:unregister-tool", { name: tool.name }));
+            },
+            adviseTool: trackUnsub(agent.adviseTool),
+            adviseToolSchema: trackUnsub(agent.adviseToolSchema),
+            registerInstruction: (name, text) => {
+                bus.emit("agent:register-instruction", { name, text, extensionName });
+                cleanups.push(() => bus.emit("agent:remove-instruction", { name }));
+            },
+            adviseInstruction: trackUnsub(agent.adviseInstruction),
+            registerSkill: (name, description, filePath) => {
+                bus.emit("agent:register-skill", { name, description, filePath, extensionName });
+                cleanups.push(() => bus.emit("agent:remove-skill", { name }));
+            },
+            adviseSkill: trackUnsub(agent.adviseSkill),
+            registerContextProducer: (name, producer, opts) => {
+                const dispose = agent.registerContextProducer(name, producer, opts);
+                cleanups.push(dispose);
+                return dispose;
+            },
+        };
+    }
+    // ── shell surface (optional — headless backends omit it) ──
+    const shell = ctx.shell;
+    let scopedShell;
+    if (shell) {
+        scopedShell = {
+            ...shell,
+            adviseInputMode: trackUnsub(shell.adviseInputMode),
+        };
+    }
     const scoped = {
         ...ctx,
         bus: scopedBus,
         advise: scopedAdvise,
-        registerInstruction: scopedRegisterInstruction,
-        removeInstruction: ctx.removeInstruction,
-        registerSkill: scopedRegisterSkill,
-        removeSkill: ctx.removeSkill,
-        registerContextProducer: scopedRegisterContextProducer,
-        registerTool: scopedRegisterTool,
-        unregisterTool: ctx.unregisterTool,
         registerCommand: scopedRegisterCommand,
+        adviseCommand: scopedAdviseCommand,
+        agent: scopedAgent,
+        shell: scopedShell,
         onDispose: (fn) => { cleanups.push(fn); },
     };
     const dispose = () => {
@@ -116,7 +129,6 @@ function createScopedContext(ctx, extensionName) {
     };
     return { scoped, dispose };
 }
-// Track disposers for user extensions so reload can tear them down
 const extensionDisposers = new Map();
 /**
  * Load extensions from three sources (merged, deduplicated):
@@ -134,19 +146,15 @@ const extensionDisposers = new Map();
  */
 export async function loadExtensions(ctx, cliExtensions) {
     const specifiers = [];
-    // 1. CLI -e / --extensions
     if (cliExtensions) {
         specifiers.push(...cliExtensions);
     }
-    // 2. settings.json
     const settings = getSettings();
     if (settings.extensions.length > 0) {
         specifiers.push(...settings.extensions);
     }
-    // 3. ~/.agent-sh/extensions/ directory
     const userSpecifiers = await discoverUserExtensions();
     specifiers.push(...userSpecifiers);
-    // Deduplicate
     const seen = new Set();
     const unique = specifiers.filter((s) => {
         if (seen.has(s))
@@ -154,8 +162,7 @@ export async function loadExtensions(ctx, cliExtensions) {
         seen.add(s);
         return true;
     });
-    // Load each extension (user extensions get scoped contexts for reloadability)
-    const loaded = await loadSpecifiers(unique, ctx, false, userSpecifiers);
+    const loaded = await loadSpecifiers(unique, ctx, false);
     return loaded;
 }
 async function discoverUserExtensions() {
@@ -188,8 +195,7 @@ async function discoverUserExtensions() {
     }
     return specifiers;
 }
-async function loadSpecifiers(specifiers, ctx, bustCache, userSpecifiers) {
-    const userSet = new Set(userSpecifiers ?? []);
+async function loadSpecifiers(specifiers, ctx, bustCache) {
     const loaded = [];
     for (const specifier of specifiers) {
         try {
@@ -197,7 +203,6 @@ async function loadSpecifiers(specifiers, ctx, bustCache, userSpecifiers) {
             if (TS_EXTS.some((ext) => importPath.endsWith(ext))) {
                 await ensureTsSupport(bustCache);
             }
-            // Append timestamp query to bust Node's module cache on reload
             if (bustCache) {
                 const sep = importPath.includes("?") ? "&" : "?";
                 importPath += `${sep}t=${Date.now()}`;
@@ -212,23 +217,13 @@ async function loadSpecifiers(specifiers, ctx, bustCache, userSpecifiers) {
             if (typeof activate === "function") {
                 const base = path.basename(specifier).replace(/\.(ts|js|mjs|mts|tsx)$/, "");
                 const name = base === "index" ? path.basename(path.dirname(specifier)) : base;
-                // Scoped context so /reload can tear user extensions down.
                 // Awaiting activate() lets extensions with async setup (e.g.
                 // openrouter fetching its model catalog) finish before we move
                 // on; a 10s outer timeout in index.ts guards against hangs.
-                if (userSet.has(specifier)) {
-                    // Dispose previous load if reloading
-                    extensionDisposers.get(name)?.();
-                    const { scoped, dispose } = createScopedContext(ctx, name);
-                    await activate(scoped);
-                    extensionDisposers.set(name, dispose);
-                }
-                else {
-                    const { scoped, dispose } = createScopedContext(ctx, name);
-                    await activate(scoped);
-                    // Non-user extensions aren't reloadable, but track for cleanup on shutdown
-                    extensionDisposers.set(name, dispose);
-                }
+                extensionDisposers.get(name)?.();
+                const { scoped, dispose } = createScopedContext(ctx, name);
+                await activate(scoped);
+                extensionDisposers.set(name, dispose);
                 loaded.push(name);
             }
         }
@@ -246,7 +241,7 @@ async function loadSpecifiers(specifiers, ctx, bustCache, userSpecifiers) {
  */
 export async function reloadExtensions(ctx) {
     const specifiers = await discoverUserExtensions();
-    return loadSpecifiers(specifiers, ctx, true, specifiers);
+    return loadSpecifiers(specifiers, ctx, true);
 }
 /**
  * Find an index file in a directory extension.
@@ -284,15 +279,12 @@ async function resolveSpecifier(specifier) {
         // Scoped packages ("@scope/pkg") contain "/" but are npm specifiers,
         // so the "@" prefix takes precedence over the "/" heuristic.
         if (specifier.includes("/") && !specifier.startsWith("@")) {
-            // Treat as relative path from cwd
             resolved = path.resolve(process.cwd(), specifier);
         }
         else {
-            // Bare specifier — npm package (including @scope/pkg)
             return specifier;
         }
     }
-    // If it's a directory, find the index file
     try {
         const stat = await fs.stat(resolved);
         if (stat.isDirectory()) {

package/dist/{core.d.ts → core/index.d.ts}

@@ -6,9 +6,9 @@
  * subscribing to bus events. Shell-specific tracking lives in the
  * shell-context built-in extension.
  *
- * Agent backends are loaded as extensions and register themselves via
- * the agent:register-backend bus event. The built-in "ash" backend is
- * loaded from src/extensions/agent-backend.ts.
+ * Agent backends register themselves via the agent:register-backend bus
+ * event. The built-in "ash" backend lives in src/agent/ and is activated
+ * by hosts via activateAgent().
  *
  * Usage:
  *   import { createCore } from "agent-sh";
@@ -18,18 +18,21 @@
  *   const response = await core.query("hello");
  */
 import { EventBus } from "./event-bus.js";
-import type { AgentShellConfig, ExtensionContext } from "./types.js";
-import { HandlerRegistry } from "./utils/handler-registry.js";
+import type { AppConfig, ExtensionContext } from "../shell/host-types.js";
+import { HandlerRegistry } from "../utils/handler-registry.js";
 export { EventBus } from "./event-bus.js";
-export type { ShellEvents } from "./event-bus.js";
-export type { AgentShellConfig, ExtensionContext, LlmInterface, LlmMessage, LlmSession } from "./types.js";
-export { palette, setPalette, resetPalette } from "./utils/palette.js";
-export type { ColorPalette } from "./utils/palette.js";
-export type { AgentBackend, ToolDefinition } from "./agent/types.js";
-export { runSubagent, type SubagentOptions } from "./agent/subagent.js";
-export { LlmClient } from "./utils/llm-client.js";
-export { HistoryFile, InMemoryHistory, NoopHistory, type HistoryAdapter } from "./agent/history-file.js";
-export type { NuclearEntry } from "./agent/nuclear-form.js";
+export type { ShellEvents, ContentBlock } from "./event-bus.js";
+export type { CoreContext, CoreConfig } from "./types.js";
+export type { AgentContext, AgentConfig, AgentSurface, AgentConfigSurface, AgentMode, LlmInterface, LlmMessage, LlmSession } from "../agent/host-types.js";
+export type { ShellContext, ShellConfig, ShellSurface, ShellConfigSurface, ExtensionContext, RemoteSession, RemoteSessionOptions, RenderSurface, InputModeConfig, TerminalSession, BlockTransformOptions, FencedBlockTransformOptions, AppConfig } from "../shell/host-types.js";
+export { palette, setPalette, resetPalette } from "../utils/palette.js";
+export type { ColorPalette } from "../utils/palette.js";
+export type { AgentBackend, ToolDefinition } from "../agent/types.js";
+export { runSubagent, type SubagentOptions } from "../agent/subagent.js";
+export { LlmClient } from "../utils/llm-client.js";
+export { HistoryFile, InMemoryHistory, NoopHistory, type HistoryAdapter } from "../agent/history-file.js";
+export type { NuclearEntry } from "../agent/nuclear-form.js";
+export { compileSearchRegex, matchEntry, formatNuclearLine } from "../agent/nuclear-form.js";
 export interface AgentShellCore {
     bus: EventBus;
     /** Handler registry for define/advise/call. */
@@ -51,4 +54,4 @@ export interface AgentShellCore {
     /** Tear down the agent and clean up. */
     kill(): void;
 }
-export declare function createCore(config: AgentShellConfig): AgentShellCore;
+export declare function createCore(config: AppConfig): AgentShellCore;