agent-sh 0.8.0 → 0.9.0

package/dist/core.js

@@ -1,13 +1,13 @@
 /**
  * Core kernel — the minimum viable agent-sh.
  *
- * Wires up EventBus + ContextManager + AgentBackend without any frontend.
+ * Wires up EventBus + ContextManager without any frontend or agent backend.
  * Consumers attach their own I/O (Shell, WebSocket, REST, tests) by
  * subscribing to bus events.
  *
- * The default backend (AgentLoop) is created eagerly but wired lazily —
- * extensions can register alternative backends via agent:register-backend
- * before activateBackend() is called.
+ * 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.
  *
  * Usage:
  *   import { createCore } from "agent-sh";
@@ -18,15 +18,13 @@
  */
 import { EventBus } from "./event-bus.js";
 import { ContextManager } from "./context-manager.js";
-import { AgentLoop } from "./agent/agent-loop.js";
-import { LlmClient } from "./utils/llm-client.js";
 import { setPalette } from "./utils/palette.js";
 import * as streamTransform from "./utils/stream-transform.js";
 import * as settingsMod from "./settings.js";
-import { resolveProvider, getProviderNames } from "./settings.js";
 import { HandlerRegistry } from "./utils/handler-registry.js";
 import { TerminalBuffer } from "./utils/terminal-buffer.js";
-import { FloatingPanel } from "./utils/floating-panel.js";
+import crypto from "node:crypto";
+import { DefaultCompositor, StdoutSurface } from "./utils/compositor.js";
 // Re-export types that library consumers need
 export { EventBus } from "./event-bus.js";
 export { palette, setPalette, resetPalette } from "./utils/palette.js";
@@ -36,92 +34,26 @@ export function createCore(config) {
     const bus = new EventBus();
     const handlers = new HandlerRegistry();
     const contextManager = new ContextManager(bus, handlers);
-    // ── Resolve provider ─────────────────────────────────────────
+    const instanceId = crypto.randomBytes(2).toString("hex");
     const settings = settingsMod.getSettings();
-    let activeProvider = null;
-    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 flat modes list across all providers
-    const buildModes = () => {
-        const allModes = [];
-        for (const [id, p] of providerRegistry) {
-            if (!p.apiKey)
-                continue;
-            for (const model of p.models) {
-                const mc = p.modelCapabilities?.get(model);
-                allModes.push({
-                    model,
-                    provider: id,
-                    providerConfig: { apiKey: p.apiKey, baseURL: p.baseURL },
-                    contextWindow: mc?.contextWindow ?? p.contextWindow,
-                    reasoning: mc?.reasoning,
-                    supportsReasoningEffort: p.supportsReasoningEffort,
-                });
-            }
-        }
-        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)));
-    // Shared LLM client — used by agent loop AND fast-path features
-    let llmClient = null;
-    if (effectiveApiKey) {
-        if (!effectiveModel) {
-            throw new Error("No model specified. Use --model or configure a provider with defaultModel in ~/.agent-sh/settings.json");
-        }
-        llmClient = new LlmClient({
-            apiKey: effectiveApiKey,
-            baseURL: effectiveBaseURL,
-            model: effectiveModel,
-        });
-    }
-    // Create AgentLoop (unwired — tools only, no bus subscriptions yet)
-    const agentLoop = llmClient
-        ? new AgentLoop(bus, contextManager, llmClient, handlers, modes, initialModeIndex)
-        : null;
+    // Expose raw CLI config so the agent backend extension can resolve
+    // providers and create the LLM client.
+    handlers.define("config:get-shell-config", () => config);
     const backends = new Map();
     let activeBackendName = null;
     const activateByName = async (name, silent = false) => {
-        const backend = name === "agent-sh" ? null : backends.get(name);
-        if (name !== "agent-sh" && !backend) {
+        const backend = backends.get(name);
+        if (!backend) {
             bus.emit("ui:error", { message: `Unknown backend: ${name}` });
             return;
         }
         // Deactivate current backend
-        if (activeBackendName === "agent-sh") {
-            agentLoop?.unwire();
-        }
-        else if (activeBackendName) {
+        if (activeBackendName) {
             backends.get(activeBackendName)?.kill();
         }
         // Activate new backend
-        if (name === "agent-sh") {
-            if (!agentLoop) {
-                bus.emit("ui:error", { message: "No LLM provider configured for built-in backend" });
-                return;
-            }
-            agentLoop.wire();
-            activeBackendName = "agent-sh";
-            bus.emit("agent:info", { name: "agent-sh", version: "0.4", model: llmClient?.model, provider: activeProvider?.id, contextWindow: activeProvider?.contextWindow });
-        }
-        else {
-            await backend.start?.();
-            activeBackendName = name;
-        }
+        await backend.start?.();
+        activeBackendName = name;
         if (!silent) {
             bus.emit("ui:info", { message: `Backend: ${name}` });
         }
@@ -134,104 +66,22 @@ export function createCore(config) {
         activateByName(name);
     });
     bus.on("config:list-backends", () => {
-        const names = [];
-        if (agentLoop)
-            names.push("agent-sh");
-        for (const name of backends.keys())
-            names.push(name);
+        const names = [...backends.keys()];
         const list = names
             .map((n) => n === activeBackendName ? `${n} (active)` : n)
             .join(", ");
         bus.emit("ui:info", { message: `Backends: ${list}` });
     });
-    bus.onPipe("config:get-backends", (payload) => {
-        const names = [];
-        if (agentLoop)
-            names.push("agent-sh");
-        for (const name of backends.keys())
-            names.push(name);
+    bus.onPipe("config:get-backends", () => {
+        const names = [...backends.keys()];
         return { names, active: activeBackendName };
     });
-    // ── Runtime provider management ──────────────────────────────
-    bus.on("provider:register", (p) => {
-        const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
-        const modelIds = [];
-        const caps = new Map();
-        for (const m of rawModels) {
-            if (typeof m === "string") {
-                modelIds.push(m);
-            }
-            else {
-                modelIds.push(m.id);
-                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
-            }
-        }
-        providerRegistry.set(p.id, {
-            id: p.id,
-            apiKey: p.apiKey,
-            baseURL: p.baseURL,
-            defaultModel: p.defaultModel,
-            models: modelIds,
-            supportsReasoningEffort: p.supportsReasoningEffort,
-            modelCapabilities: caps.size > 0 ? caps : undefined,
-        });
-        // Push registered models into the agent loop so they appear in
-        // autocomplete and are selectable via /model.
-        const addModes = modelIds.map((m) => {
-            const mc = caps.get(m);
-            return {
-                model: m,
-                provider: p.id,
-                providerConfig: { apiKey: p.apiKey ?? "", baseURL: p.baseURL },
-                contextWindow: mc?.contextWindow,
-                reasoning: mc?.reasoning,
-                supportsReasoningEffort: p.supportsReasoningEffort,
-            };
-        });
-        bus.emit("config:add-modes", { modes: addModes });
-    });
-    bus.on("config:switch-provider", ({ provider: name }) => {
-        const p = providerRegistry.get(name);
-        if (!p) {
-            bus.emit("ui:error", { message: `Unknown provider: ${name}` });
-            return;
-        }
-        if (!llmClient) {
-            bus.emit("ui:error", { message: `Provider switching requires internal agent mode` });
-            return;
-        }
-        const newApiKey = p.apiKey;
-        if (!newApiKey) {
-            bus.emit("ui:error", { message: `Provider "${name}" has no API key configured` });
-            return;
-        }
-        const switchModel = p.defaultModel ?? p.models[0];
-        if (!switchModel) {
-            bus.emit("ui:error", { message: `Provider "${name}" has no models configured` });
-            return;
-        }
-        llmClient.reconfigure({
-            apiKey: newApiKey,
-            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 },
-                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: "agent-sh", version: "0.4", model: switchModel, provider: name, contextWindow: p.contextWindow });
-        bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
-        bus.emit("config:changed", {});
-    });
+    // ── Compositor ──────────────────────────────────────────────
+    const compositor = new DefaultCompositor();
+    const stdoutSurface = new StdoutSurface();
+    compositor.setDefault("agent", stdoutSurface);
+    compositor.setDefault("query", stdoutSurface);
+    compositor.setDefault("status", stdoutSurface);
     // ── Lazy singleton terminal buffer ──────────────────────────
     let terminalBufferSingleton; // undefined = not yet created
     const getTerminalBuffer = () => {
@@ -243,23 +93,17 @@ export function createCore(config) {
     return {
         bus,
         contextManager,
-        llmClient,
+        handlers,
         activateBackend() {
             // Silent — backend info is shown in the startup banner.
             // Runtime switches (config:switch-backend) still emit ui:info.
+            if (backends.size === 0)
+                return;
             const preferred = settings.defaultBackend;
             if (preferred && backends.has(preferred)) {
                 activateByName(preferred, true);
             }
-            else if (backends.size > 0 && !agentLoop) {
-                activateByName(backends.keys().next().value, true);
-            }
-            else if (agentLoop) {
-                agentLoop.wire();
-                activeBackendName = "agent-sh";
-                bus.emit("agent:info", { name: "agent-sh", version: "0.4", model: llmClient?.model, provider: activeProvider?.id, contextWindow: activeProvider?.contextWindow });
-            }
-            else if (backends.size > 0) {
+            else {
                 activateByName(backends.keys().next().value, true);
             }
         },
@@ -304,30 +148,68 @@ export function createCore(config) {
             return {
                 bus,
                 contextManager,
-                llmClient,
+                instanceId,
                 quit: opts.quit,
                 setPalette,
                 createBlockTransform: (o) => streamTransform.createBlockTransform(bus, o),
                 createFencedBlockTransform: (o) => streamTransform.createFencedBlockTransform(bus, o),
                 getExtensionSettings: settingsMod.getExtensionSettings,
                 registerCommand: (name, description, handler) => bus.emit("command:register", { name, description, handler }),
-                registerTool: (tool) => agentLoop?.registerTool(tool),
-                getTools: () => agentLoop?.getTools() ?? [],
+                registerTool: (tool) => bus.emit("agent:register-tool", { tool }),
+                unregisterTool: (name) => bus.emit("agent:unregister-tool", { name }),
+                getTools: () => bus.emitPipe("agent:get-tools", { tools: [] }).tools,
+                registerInstruction: (name, text) => bus.emit("agent:register-instruction", { name, text }),
+                removeInstruction: (name) => bus.emit("agent:remove-instruction", { name }),
                 define: (name, fn) => handlers.define(name, fn),
                 advise: (name, wrapper) => handlers.advise(name, wrapper),
                 call: (name, ...args) => handlers.call(name, ...args),
                 get terminalBuffer() { return getTerminalBuffer(); },
-                createFloatingPanel: (config) => {
-                    const tb = config.dimBackground !== false ? getTerminalBuffer() : null;
-                    return new FloatingPanel(bus, { ...config, terminalBuffer: tb ?? undefined });
+                compositor,
+                createRemoteSession: (opts) => {
+                    const { surface } = opts;
+                    const cleanups = [];
+                    let active = true;
+                    // Redirect all render streams
+                    cleanups.push(compositor.redirect("agent", surface));
+                    cleanups.push(compositor.redirect("query", surface));
+                    cleanups.push(compositor.redirect("status", surface));
+                    // Keep shell interactive
+                    cleanups.push(handlers.advise("shell:on-processing-start", (next) => active ? undefined : next()));
+                    cleanups.push(handlers.advise("shell:on-processing-done", (next) => active ? undefined : next()));
+                    // Suppress chrome
+                    if (opts.suppressBorders !== false) {
+                        cleanups.push(handlers.advise("tui:response-border", (next, ...a) => active ? null : next(...a)));
+                    }
+                    if (opts.suppressQueryBox) {
+                        cleanups.push(handlers.advise("tui:render-user-query", (next, ...a) => active ? [] : next(...a)));
+                    }
+                    if (opts.suppressUsage !== false) {
+                        cleanups.push(handlers.advise("tui:render-usage", (next, ...a) => active ? "" : next(...a)));
+                    }
+                    if (opts.interactive) {
+                        cleanups.push(handlers.advise("dynamic-context:build", (next) => {
+                            const base = next();
+                            return active ? base + "\ninteractive-session: true\n" : base;
+                        }));
+                    }
+                    return {
+                        submit(query) { bus.emit("agent:submit", { query }); },
+                        get surface() { return surface; },
+                        get active() { return active; },
+                        close() {
+                            if (!active)
+                                return;
+                            active = false;
+                            for (const fn of cleanups.reverse())
+                                fn();
+                            cleanups.length = 0;
+                        },
+                    };
                 },
             };
         },
         kill() {
-            if (activeBackendName === "agent-sh") {
-                agentLoop?.kill();
-            }
-            else if (activeBackendName) {
+            if (activeBackendName) {
                 backends.get(activeBackendName)?.kill();
             }
         },

package/dist/event-bus.d.ts

@@ -115,10 +115,14 @@ export interface ShellEvents {
     "agent:tool-output-chunk": {
         chunk: string;
     };
+    "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": {
@@ -218,6 +222,10 @@ export interface ShellEvents {
     "config:switch-provider": {
         provider: string;
     };
+    "config:get-initial-modes": {
+        modes: AgentMode[];
+        initialModeIndex: number;
+    };
     "config:set-modes": {
         modes: AgentMode[];
     };
@@ -237,6 +245,22 @@ export interface ShellEvents {
         /** Provider supports the reasoning_effort parameter. Default: true. */
         supportsReasoningEffort?: boolean;
     };
+    "agent:register-tool": {
+        tool: import("./agent/types.js").ToolDefinition;
+    };
+    "agent:unregister-tool": {
+        name: string;
+    };
+    "agent:get-tools": {
+        tools: import("./agent/types.js").ToolDefinition[];
+    };
+    "agent:register-instruction": {
+        name: string;
+        text: string;
+    };
+    "agent:remove-instruction": {
+        name: string;
+    };
     "autocomplete:request": {
         buffer: string;
         /** Parsed slash command name (e.g. "/backend"), or null if not a command. */
@@ -291,6 +315,8 @@ export declare class EventBus {
     emitTransform<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): void;
     /** Register a transform listener for a pipeline event. */
     onPipe<K extends keyof ShellEvents>(event: K, fn: PipeListener<ShellEvents[K]>): void;
+    /** Remove a transform listener from a pipeline event. */
+    offPipe<K extends keyof ShellEvents>(event: K, fn: PipeListener<ShellEvents[K]>): void;
     /**
      * Emit a pipeline event — each registered pipe listener receives the
      * output of the previous one. Returns the final transformed payload.

package/dist/event-bus.js

@@ -49,6 +49,15 @@ export class EventBus {
         }
         listeners.push(fn);
     }
+    /** Remove a transform listener from a pipeline event. */
+    offPipe(event, fn) {
+        const listeners = this.pipeListeners.get(event);
+        if (!listeners)
+            return;
+        const idx = listeners.indexOf(fn);
+        if (idx !== -1)
+            listeners.splice(idx, 1);
+    }
     /**
      * Emit a pipeline event — each registered pipe listener receives the
      * output of the previous one. Returns the final transformed payload.
@@ -60,7 +69,17 @@ export class EventBus {
             return payload;
         let result = payload;
         for (const fn of listeners) {
-            result = fn(result);
+            try {
+                const out = fn(result);
+                if (out && typeof out.then === "function") {
+                    console.error(`[event-bus] Warning: async handler in sync pipe "${String(event)}" — use onPipeAsync instead`);
+                    continue;
+                }
+                result = out;
+            }
+            catch (err) {
+                console.error(`[event-bus] Pipe handler error in "${String(event)}":`, err instanceof Error ? err.message : err);
+            }
         }
         return result;
     }

package/dist/extension-loader.d.ts

@@ -14,3 +14,8 @@ import type { ExtensionContext } from "./types.js";
  * Errors are non-fatal — logged via ui:error and skipped.
  */
 export declare function loadExtensions(ctx: ExtensionContext, cliExtensions?: string[]): Promise<string[]>;
+/**
+ * Reload user extensions (from ~/.agent-sh/extensions/).
+ * Tears down old registrations, busts the module cache, and re-activates.
+ */
+export declare function reloadExtensions(ctx: ExtensionContext): Promise<string[]>;

package/dist/extension-loader.js

@@ -17,6 +17,63 @@ async function ensureTsSupport() {
         // tsx not available — TS extensions will fail with a clear error
     }
 }
+/**
+ * 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.
+ */
+function createScopedContext(ctx) {
+    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;
+    };
+    // Track instruction registrations
+    const scopedRegisterInstruction = (name, text) => {
+        ctx.registerInstruction(name, text);
+        cleanups.push(() => ctx.removeInstruction(name));
+    };
+    // Track tool registrations
+    const scopedRegisterTool = (tool) => {
+        ctx.registerTool(tool);
+        cleanups.push(() => ctx.unregisterTool(tool.name));
+    };
+    const scoped = {
+        ...ctx,
+        bus: scopedBus,
+        advise: scopedAdvise,
+        registerInstruction: scopedRegisterInstruction,
+        removeInstruction: ctx.removeInstruction,
+        registerTool: scopedRegisterTool,
+        unregisterTool: ctx.unregisterTool,
+    };
+    const dispose = () => {
+        for (const fn of cleanups) {
+            try {
+                fn();
+            }
+            catch { /* ignore */ }
+        }
+        cleanups.length = 0;
+    };
+    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):
  *
@@ -43,19 +100,32 @@ export async function loadExtensions(ctx, cliExtensions) {
         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))
+            return false;
+        seen.add(s);
+        return true;
+    });
+    // Load each extension (user extensions get scoped contexts for reloadability)
+    const loaded = await loadSpecifiers(unique, ctx, false, userSpecifiers);
+    return loaded;
+}
+async function discoverUserExtensions() {
+    const specifiers = [];
     try {
         const entries = await fs.readdir(EXT_DIR, { withFileTypes: true });
         for (const entry of entries) {
             const fullPath = path.join(EXT_DIR, entry.name);
-            // Resolve symlinks to check if they point to directories
             const isDir = entry.isDirectory() ||
                 (entry.isSymbolicLink() && (await fs.stat(fullPath)).isDirectory());
             if (isDir) {
-                // Directory extension: look for index.{ts,js,mjs,...}
                 const indexFile = await findIndex(fullPath);
-                if (indexFile) {
+                if (indexFile)
                     specifiers.push(indexFile);
-                }
             }
             else if (SCRIPT_EXTS.some((ext) => entry.name.endsWith(ext))) {
                 specifiers.push(fullPath);
@@ -65,22 +135,22 @@ export async function loadExtensions(ctx, cliExtensions) {
     catch {
         // Directory doesn't exist — no user extensions
     }
-    // Deduplicate
-    const seen = new Set();
-    const unique = specifiers.filter((s) => {
-        if (seen.has(s))
-            return false;
-        seen.add(s);
-        return true;
-    });
-    // Load each extension
+    return specifiers;
+}
+async function loadSpecifiers(specifiers, ctx, bustCache, userSpecifiers) {
+    const userSet = new Set(userSpecifiers ?? []);
     const loaded = [];
-    for (const specifier of unique) {
+    for (const specifier of specifiers) {
         try {
-            const importPath = await resolveSpecifier(specifier);
+            let importPath = await resolveSpecifier(specifier);
             if (TS_EXTS.some((ext) => importPath.endsWith(ext))) {
                 await ensureTsSupport();
             }
+            // Append timestamp query to bust Node's module cache on reload
+            if (bustCache) {
+                const sep = importPath.includes("?") ? "&" : "?";
+                importPath += `${sep}t=${Date.now()}`;
+            }
             const mod = await import(importPath);
             // tsx may double-wrap default exports: mod.default.default
             const activate = typeof mod.default === "function"
@@ -89,10 +159,19 @@ export async function loadExtensions(ctx, cliExtensions) {
                     ? mod.default.default
                     : mod.activate;
             if (typeof activate === "function") {
-                activate(ctx);
-                // Extract a short name from the specifier
                 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
+                if (userSet.has(specifier)) {
+                    // Dispose previous load if reloading
+                    extensionDisposers.get(name)?.();
+                    const { scoped, dispose } = createScopedContext(ctx);
+                    activate(scoped);
+                    extensionDisposers.set(name, dispose);
+                }
+                else {
+                    activate(ctx);
+                }
                 loaded.push(name);
             }
         }
@@ -104,6 +183,14 @@ export async function loadExtensions(ctx, cliExtensions) {
     }
     return loaded;
 }
+/**
+ * Reload user extensions (from ~/.agent-sh/extensions/).
+ * Tears down old registrations, busts the module cache, and re-activates.
+ */
+export async function reloadExtensions(ctx) {
+    const specifiers = await discoverUserExtensions();
+    return loadSpecifiers(specifiers, ctx, true, specifiers);
+}
 /**
  * Find an index file in a directory extension.
  */

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

@@ -0,0 +1,13 @@
+/**
+ * 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)
+ */
+import type { ExtensionContext } from "../types.js";
+export default function agentBackend(ctx: ExtensionContext): void;