agent-sh 0.9.0 → 0.10.1

package/dist/extension-loader.js

@@ -5,12 +5,33 @@ const EXT_DIR = path.join(CONFIG_DIR, "extensions");
 const TS_EXTS = [".ts", ".tsx", ".mts"];
 const SCRIPT_EXTS = [".js", ".mjs", ".ts", ".tsx", ".mts"];
 let tsRegistered = false;
-async function ensureTsSupport() {
-    if (tsRegistered)
+let tsxUnregister = null;
+/**
+ * Register tsx's ESM loader for .ts file support.
+ *
+ * Called before importing .ts extensions. The tsx loader uses Node's
+ * module.register() which creates a background thread with a MessageChannel.
+ * On reload, the old loader may become stale (the MessageChannel port can be
+ * GC'd or the loader thread can stop responding), so we unregister the old
+ * handle and re-register on each reload.
+ *
+ * Initial load: registers fresh.
+ * Reload: unregisters old handle, registers new one.
+ * Non-reload calls within the same load: no-op (tsRegistered guard).
+ */
+async function ensureTsSupport(force = false) {
+    if (tsRegistered && !force)
         return;
     try {
+        // Unregister previous loader if reloading
+        if (tsxUnregister) {
+            try {
+                await tsxUnregister();
+            }
+            catch { /* ignore stale handle */ }
+        }
         const { register } = await import("tsx/esm/api");
-        register();
+        tsxUnregister = register();
         tsRegistered = true;
     }
     catch {
@@ -22,7 +43,7 @@ async function ensureTsSupport() {
  * advise, command:register). Returns the wrapped context and a dispose()
  * function that tears down everything registered through it.
  */
-function createScopedContext(ctx) {
+function createScopedContext(ctx, extensionName) {
     const cleanups = [];
     const bus = ctx.bus;
     const scopedBus = Object.create(bus);
@@ -42,15 +63,27 @@ function createScopedContext(ctx) {
         cleanups.push(unadvise);
         return unadvise;
     };
-    // Track instruction registrations
+    // Track instruction registrations — extension name captured in scope
     const scopedRegisterInstruction = (name, text) => {
-        ctx.registerInstruction(name, text);
-        cleanups.push(() => ctx.removeInstruction(name));
+        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 tool registrations
+    // Track tool registrations — extension name captured in scope
     const scopedRegisterTool = (tool) => {
-        ctx.registerTool(tool);
-        cleanups.push(() => ctx.unregisterTool(tool.name));
+        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.
+    const scopedRegisterCommand = (name, description, handler) => {
+        ctx.registerCommand(name, description, handler);
+        cleanups.push(() => bus.emit("command:unregister", { name }));
     };
     const scoped = {
         ...ctx,
@@ -58,8 +91,11 @@ function createScopedContext(ctx) {
         advise: scopedAdvise,
         registerInstruction: scopedRegisterInstruction,
         removeInstruction: ctx.removeInstruction,
+        registerSkill: scopedRegisterSkill,
+        removeSkill: ctx.removeSkill,
         registerTool: scopedRegisterTool,
         unregisterTool: ctx.unregisterTool,
+        registerCommand: scopedRegisterCommand,
     };
     const dispose = () => {
         for (const fn of cleanups) {
@@ -116,9 +152,16 @@ export async function loadExtensions(ctx, cliExtensions) {
 }
 async function discoverUserExtensions() {
     const specifiers = [];
+    const disabled = new Set(getSettings().disabledExtensions ?? []);
     try {
         const entries = await fs.readdir(EXT_DIR, { withFileTypes: true });
         for (const entry of entries) {
+            // Disable check: directory name for dir-extensions, or basename sans
+            // extension for file-extensions. Lets settings.json turn one off
+            // without renaming it.
+            const nameForDisable = entry.name.replace(/\.[^.]+$/, "");
+            if (disabled.has(nameForDisable))
+                continue;
             const fullPath = path.join(EXT_DIR, entry.name);
             const isDir = entry.isDirectory() ||
                 (entry.isSymbolicLink() && (await fs.stat(fullPath)).isDirectory());
@@ -144,7 +187,7 @@ async function loadSpecifiers(specifiers, ctx, bustCache, userSpecifiers) {
         try {
             let importPath = await resolveSpecifier(specifier);
             if (TS_EXTS.some((ext) => importPath.endsWith(ext))) {
-                await ensureTsSupport();
+                await ensureTsSupport(bustCache);
             }
             // Append timestamp query to bust Node's module cache on reload
             if (bustCache) {
@@ -161,16 +204,22 @@ 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;
-                // User extensions get a scoped context so /reload can tear them down
+                // 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);
-                    activate(scoped);
+                    const { scoped, dispose } = createScopedContext(ctx, name);
+                    await activate(scoped);
                     extensionDisposers.set(name, dispose);
                 }
                 else {
-                    activate(ctx);
+                    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);
                 }
                 loaded.push(name);
             }
@@ -223,8 +272,17 @@ async function resolveSpecifier(specifier) {
         resolved = specifier;
     }
     else {
-        // Bare specifier — npm package
-        return specifier;
+        // Distinguish bare npm specifier from a relative path lacking "./".
+        // 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 {

package/dist/extensions/agent-backend.d.ts

@@ -1,13 +1,14 @@
 /**
  * Built-in agent backend extension.
  *
- * Owns the full LLM lifecycle:
- *   1. Resolves providers from settings + CLI config
- *   2. Creates and manages the LlmClient
- *   3. Builds mode list for model cycling
- *   4. Creates AgentLoop and registers it as the "ash" backend
- *   5. Handles runtime provider switching and provider registration
- *   6. Exposes llm:get-client handler for other extensions (e.g. command-suggest)
+ * Constructs the AgentLoop synchronously with a placeholder LlmClient,
+ * so core handlers (history:append, system-prompt:build, conversation:*)
+ * are defined before user extensions activate. Mode resolution is
+ * deferred to `core:extensions-loaded`, giving runtime-registered
+ * providers (e.g. openrouter) a chance to register before we look up
+ * settings.defaultProvider. Without this deferral, a persisted
+ * `defaultProvider: "openrouter"` loses to a cold-start race and the
+ * backend bails silently.
  */
 import type { ExtensionContext } from "../types.js";
 export default function agentBackend(ctx: ExtensionContext): void;

package/dist/extensions/agent-backend.js

@@ -1,23 +1,23 @@
 import { AgentLoop } from "../agent/agent-loop.js";
 import { LlmClient } from "../utils/llm-client.js";
 import { resolveProvider, getProviderNames, getSettings } from "../settings.js";
+import { PACKAGE_VERSION } from "../utils/package-version.js";
+/** Read the user's persisted defaultModel for a provider, if any. */
+function persistedModelFor(providerName) {
+    if (!providerName)
+        return undefined;
+    return getSettings().providers?.[providerName]?.defaultModel;
+}
 export default function agentBackend(ctx) {
     const { bus } = ctx;
-    // ── Resolve providers ──────────────────────────────────────
     const config = ctx.call("config:get-shell-config") ?? {};
-    const settings = getSettings();
-    let activeProvider = null;
+    // Seed from settings.json; runtime provider:register events add more.
     const providerRegistry = new Map();
     for (const name of getProviderNames()) {
         const p = resolveProvider(name);
         if (p)
             providerRegistry.set(name, p);
     }
-    const providerName = config.provider ?? settings.defaultProvider;
-    if (providerName) {
-        activeProvider = providerRegistry.get(providerName) ?? null;
-    }
-    // ── Build modes ────────────────────────────────────────────
     const buildModes = () => {
         const allModes = [];
         for (const [id, p] of providerRegistry) {
@@ -37,59 +37,76 @@ export default function agentBackend(ctx) {
         }
         return allModes;
     };
-    const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;
-    const effectiveBaseURL = config.baseURL ?? activeProvider?.baseURL;
-    const effectiveModel = config.model ?? activeProvider?.defaultModel;
-    let modes = buildModes();
-    if (modes.length === 0 && effectiveApiKey && effectiveModel) {
-        modes = [{ model: effectiveModel }];
-    }
-    const initialModeIndex = Math.max(0, modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id)));
-    // ── Create LLM client ─────────────────────────────────────
-    if (!effectiveApiKey)
-        return; // No LLM provider configured — skip
-    if (!effectiveModel) {
-        bus.emit("ui:error", { message: "No model specified. Use --model or configure a provider with defaultModel in ~/.agent-sh/settings.json" });
-        return;
-    }
-    const llmClient = new LlmClient({
-        apiKey: effectiveApiKey,
-        baseURL: effectiveBaseURL,
-        model: effectiveModel,
-    });
-    // Expose LLM client for other extensions (e.g. command-suggest)
+    // Placeholder client — reconfigured at core:extensions-loaded. Any
+    // stream() call before then fails from the OpenAI SDK; start() won't
+    // wire the loop until we've resolved, so users never hit that path.
+    const llmClient = new LlmClient({ apiKey: "not-configured", model: "not-configured" });
     ctx.define("llm:get-client", () => llmClient);
-    // ── Initial modes (queryable via pipe) ─────────────────────
-    bus.onPipe("config:get-initial-modes", () => ({
-        modes,
-        initialModeIndex,
-    }));
-    // ── Create agent loop ──────────────────────────────────────
+    let modes = [];
+    let initialModeIndex = 0;
+    let resolved = false;
+    bus.onPipe("config:get-initial-modes", () => ({ modes, initialModeIndex }));
+    // AgentLoop must be constructed *before* user extensions activate,
+    // because its ctor defines handlers (history:append, etc.) that
+    // extensions like superash call synchronously during their own
+    // activate. Advise-before-define works for advisers, but plain calls
+    // would hit a no-op stub.
     const agentLoop = new AgentLoop({
         bus,
         contextManager: ctx.contextManager,
         llmClient,
-        handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call },
+        handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call, list: ctx.list },
         modes,
         initialModeIndex,
         compositor: ctx.compositor,
+        instanceId: ctx.instanceId,
     });
-    // Register as backend
     bus.emit("agent:register-backend", {
         name: "ash",
         kill: () => agentLoop.kill(),
         start: async () => {
+            if (!resolved) {
+                bus.emit("ui:error", { message: "Agent backend not started — no LLM provider available. See earlier messages." });
+                return;
+            }
             agentLoop.wire();
             bus.emit("agent:info", {
                 name: "ash",
-                version: "0.4",
+                version: PACKAGE_VERSION,
                 model: llmClient.model,
                 provider: modes[initialModeIndex]?.provider,
                 contextWindow: modes[initialModeIndex]?.contextWindow,
             });
         },
     });
-    // ── Runtime provider registration ──────────────────────────
+    bus.on("core:extensions-loaded", () => {
+        const settings = getSettings();
+        const providerName = config.provider ?? settings.defaultProvider;
+        const activeProvider = providerName ? providerRegistry.get(providerName) ?? null : null;
+        // User's persisted defaultModel wins over the provider's declared
+        // default. Dynamic providers (openrouter) re-register with their
+        // hardcoded DEFAULT_MODELS[0] each startup, which would otherwise
+        // clobber the user's /model selection.
+        const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;
+        const effectiveBaseURL = config.baseURL ?? activeProvider?.baseURL;
+        const effectiveModel = config.model ?? persistedModelFor(providerName) ?? activeProvider?.defaultModel;
+        if (!effectiveApiKey) {
+            bus.emit("ui:error", { message: "No LLM provider configured. Set --api-key, configure a provider in ~/.agent-sh/settings.json, or load a provider extension (e.g. openrouter) that sets OPENROUTER_API_KEY." });
+            return;
+        }
+        if (!effectiveModel) {
+            bus.emit("ui:error", { message: "No model specified. Use --model or configure a provider with defaultModel in ~/.agent-sh/settings.json" });
+            return;
+        }
+        modes = buildModes();
+        if (modes.length === 0)
+            modes = [{ model: effectiveModel }];
+        initialModeIndex = Math.max(0, modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id)));
+        llmClient.reconfigure({ apiKey: effectiveApiKey, baseURL: effectiveBaseURL, model: effectiveModel });
+        bus.emit("config:set-modes", { modes, activeIndex: initialModeIndex });
+        resolved = true;
+        // start() emits agent:info after wiring.
+    });
     bus.on("provider:register", (p) => {
         const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
         const modelIds = [];
@@ -124,16 +141,26 @@ export default function agentBackend(ctx) {
             };
         });
         bus.emit("config:add-modes", { modes: addModes });
+        // Late-registration reconcile: if this completes the user's persisted
+        // default (openrouter's async fetch delivers the full catalog after
+        // we've already fallen back to mode 0), quietly switch to it.
+        if (!resolved)
+            return;
+        const pendingProvider = getSettings().defaultProvider;
+        if (pendingProvider !== p.id)
+            return;
+        const pendingModel = persistedModelFor(pendingProvider);
+        if (pendingModel && modelIds.includes(pendingModel) && llmClient.model !== pendingModel) {
+            bus.emit("config:switch-model", { model: pendingModel });
+        }
     });
-    // ── Runtime provider switching ─────────────────────────────
     bus.on("config:switch-provider", ({ provider: name }) => {
         const p = providerRegistry.get(name);
         if (!p) {
             bus.emit("ui:error", { message: `Unknown provider: ${name}` });
             return;
         }
-        const newApiKey = p.apiKey;
-        if (!newApiKey) {
+        if (!p.apiKey) {
             bus.emit("ui:error", { message: `Provider "${name}" has no API key configured` });
             return;
         }
@@ -142,25 +169,20 @@ export default function agentBackend(ctx) {
             bus.emit("ui:error", { message: `Provider "${name}" has no models configured` });
             return;
         }
-        llmClient.reconfigure({
-            apiKey: newApiKey,
-            baseURL: p.baseURL,
-            model: switchModel,
-        });
+        llmClient.reconfigure({ apiKey: p.apiKey, baseURL: p.baseURL, model: switchModel });
         const newModes = p.models.map((m) => {
             const mc = p.modelCapabilities?.get(m);
             return {
                 model: m,
                 provider: name,
-                providerConfig: { apiKey: newApiKey, baseURL: p.baseURL },
+                providerConfig: { apiKey: p.apiKey, baseURL: p.baseURL },
                 contextWindow: mc?.contextWindow ?? p.contextWindow,
                 reasoning: mc?.reasoning,
                 supportsReasoningEffort: p.supportsReasoningEffort,
             };
         });
         bus.emit("config:set-modes", { modes: newModes });
-        activeProvider = p;
-        bus.emit("agent:info", { name: "ash", version: "0.4", model: switchModel, provider: name, contextWindow: p.contextWindow });
+        bus.emit("agent:info", { name: "ash", version: PACKAGE_VERSION, model: switchModel, provider: name, contextWindow: p.contextWindow });
         bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
         bus.emit("config:changed", {});
     });

package/dist/extensions/index.js

@@ -3,9 +3,7 @@ export const BUILTIN_EXTENSIONS = [
     { name: "tui-renderer", load: () => import("./tui-renderer.js").then(m => m.default) },
     { name: "slash-commands", load: () => import("./slash-commands.js").then(m => m.default) },
     { name: "file-autocomplete", load: () => import("./file-autocomplete.js").then(m => m.default) },
-    { name: "shell-recall", load: () => import("./shell-recall.js").then(m => m.default) },
     { name: "command-suggest", load: () => import("./command-suggest.js").then(m => m.default) },
-    { name: "terminal-buffer", load: () => import("./terminal-buffer.js").then(m => m.default) },
 ];
 /**
  * Load built-in extensions sequentially, skipping any in the disabled list.

package/dist/extensions/slash-commands.js

@@ -79,7 +79,7 @@ export default function activate(ctx) {
     });
     register({
         name: "/compact",
-        description: "Compact conversation (move full content to nuclear summaries)",
+        description: "Compact conversation via the active compaction strategy",
         handler: () => {
             bus.emit("agent:compact-request", {});
         },
@@ -90,19 +90,15 @@ export default function activate(ctx) {
         handler: () => {
             const stats = bus.emitPipe("context:get-stats", {
                 activeTokens: 0,
-                nuclearEntries: 0,
-                recallArchiveSize: 0,
+                totalTokens: 0,
                 budgetTokens: 0,
             });
             const pct = stats.budgetTokens > 0
                 ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
                 : 0;
-            const lines = [
-                `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
-                `Nuclear entries: ${stats.nuclearEntries} in-context`,
-                `Recall archive: ${stats.recallArchiveSize} entries`,
-            ];
-            bus.emit("ui:info", { message: lines.join("\n") });
+            bus.emit("ui:info", {
+                message: `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
+            });
         },
     });
     register({
@@ -118,10 +114,19 @@ export default function activate(ctx) {
             }
         },
     });
+    // Handler form so extensions can trigger reload programmatically
+    // (e.g. an ash-callable reload_extensions tool in superash).
+    ctx.define("extensions:reload", async () => {
+        return await reloadExtensions(ctx);
+    });
     // ── Extension registration ────────────────────────────────────
     bus.on("command:register", (cmd) => {
         register(cmd);
     });
+    bus.on("command:unregister", ({ name }) => {
+        const key = name.startsWith("/") ? name : `/${name}`;
+        commands.delete(key);
+    });
     // ── Skill commands (/skill:<name>) ────────────────────────────
     const getSkills = () => {
         const cwd = contextManager?.getCwd() ?? process.cwd();