agent-sh 0.12.26 → 0.13.0

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() {
@@ -69,11 +69,41 @@ function pickResolver(spec) {
             return r;
     return bundledResolver;
 }
-function maybeNpmInstall(target) {
+function readPackageJson(target) {
+    const pkgJson = path.join(target, "package.json");
+    if (!fs.existsSync(pkgJson))
+        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 pkg = JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
+    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)
         return;
@@ -88,6 +118,56 @@ function maybeNpmInstall(target) {
         throw new Error(`npm install failed in ${target}; run it manually.`);
     }
 }
+function normalizeBin(pkg) {
+    if (!pkg.bin)
+        return {};
+    if (typeof pkg.bin === "string") {
+        const name = pkg.name?.startsWith("@") ? pkg.name.split("/")[1] : pkg.name;
+        return name ? { [name]: pkg.bin } : {};
+    }
+    return pkg.bin;
+}
+function maybeNpmBuild(target, pkg) {
+    if (!pkg.scripts?.build)
+        return;
+    const binPaths = Object.values(normalizeBin(pkg)).map((p) => path.join(target, p));
+    if (binPaths.length === 0)
+        return;
+    if (binPaths.every((p) => fs.existsSync(p)))
+        return;
+    console.log(`Running npm run build in ${target}...`);
+    const result = spawnSync("npm", ["run", "build"], { cwd: target, stdio: "inherit" });
+    if (result.status !== 0) {
+        throw new Error(`npm run build failed in ${target}; run it manually.`);
+    }
+}
+function linkBins(target, pkg) {
+    const bins = normalizeBin(pkg);
+    if (Object.keys(bins).length === 0)
+        return [];
+    const binDir = path.join(CONFIG_DIR, "bin");
+    fs.mkdirSync(binDir, { recursive: true });
+    const linked = [];
+    for (const [name, relPath] of Object.entries(bins)) {
+        const src = path.resolve(target, relPath);
+        if (!fs.existsSync(src)) {
+            console.error(`agent-sh: skipping bin "${name}" — ${src} not found`);
+            continue;
+        }
+        try {
+            fs.chmodSync(src, 0o755);
+        }
+        catch { /* ignore */ }
+        const linkPath = path.join(binDir, name);
+        try {
+            fs.unlinkSync(linkPath);
+        }
+        catch { /* ignore */ }
+        fs.symlinkSync(src, linkPath);
+        linked.push(name);
+    }
+    return linked;
+}
 export async function runInstall(spec, opts = {}) {
     if (!spec) {
         console.error("Usage: agent-sh install <name|file:|npm:|github:> [--force]\n\n" +
@@ -114,10 +194,17 @@ export async function runInstall(spec, opts = {}) {
         }
         fs.rmSync(target, { recursive: true, force: true });
     }
+    let linkedBins = [];
     if (resolved.isDirectory) {
         fs.cpSync(resolved.sourcePath, target, { recursive: true });
         try {
-            maybeNpmInstall(target);
+            rewriteFileDeps(target, resolved.sourcePath);
+            const pkg = readPackageJson(target);
+            if (pkg) {
+                maybeNpmInstall(target, pkg);
+                maybeNpmBuild(target, pkg);
+                linkedBins = linkBins(target, pkg);
+            }
         }
         catch (err) {
             console.error(`agent-sh: ${err instanceof Error ? err.message : String(err)}`);
@@ -128,6 +215,11 @@ export async function runInstall(spec, opts = {}) {
         fs.copyFileSync(resolved.sourcePath, target);
     }
     console.log(`Installed: ${resolved.name} -> ${target}`);
+    if (linkedBins.length > 0) {
+        const binDir = path.join(CONFIG_DIR, "bin");
+        console.log(`Linked bins: ${linkedBins.join(", ")} -> ${binDir}`);
+        console.log(`Add to PATH: export PATH="${binDir}:$PATH"`);
+    }
 }
 export async function runUninstall(name) {
     if (!name) {
@@ -146,6 +238,23 @@ export async function runUninstall(name) {
         console.error(`agent-sh: not installed: ${name}`);
         process.exit(1);
     }
+    const pkg = readPackageJson(target);
+    if (pkg) {
+        const binDir = path.join(CONFIG_DIR, "bin");
+        const targetPrefix = path.resolve(target) + path.sep;
+        for (const binName of Object.keys(normalizeBin(pkg))) {
+            const linkPath = path.join(binDir, binName);
+            try {
+                const stat = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+                if (!stat?.isSymbolicLink())
+                    continue;
+                const dest = path.resolve(binDir, fs.readlinkSync(linkPath));
+                if (dest.startsWith(targetPrefix))
+                    fs.unlinkSync(linkPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
     fs.rmSync(target, { recursive: true, force: true });
     console.log(`Uninstalled: ${name}`);
 }

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()) {