agent-sh 0.10.3 → 0.12.0

package/dist/event-bus.d.ts

@@ -65,6 +65,15 @@ export interface ShellEvents {
         completion_tokens: number;
         total_tokens: number;
     };
+    "llm:request": {
+        messages: unknown[];
+        tools?: unknown;
+        model?: string;
+        reasoning_effort?: string;
+    };
+    "llm:chunk": {
+        chunk: unknown;
+    };
     "agent:processing-start": Record<string, never>;
     "agent:processing-done": Record<string, never>;
     "agent:cancelled": Record<string, never>;
@@ -275,7 +284,9 @@ export interface ShellEvents {
         id: string;
         apiKey?: string;
         baseURL?: string;
-        defaultModel: string;
+        /** Optional — providers for custom endpoints may not know the catalog
+         *  at registration time. Falls back to models[0] when absent. */
+        defaultModel?: string;
         models?: (string | {
             id: string;
             reasoning?: boolean;

package/dist/extensions/agent-backend.js

@@ -42,6 +42,12 @@ export default function agentBackend(ctx) {
     // 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);
+    ctx.define("llm:invoke", (messages, opts) => {
+        return llmClient.complete({
+            messages: messages,
+            max_tokens: opts?.maxTokens,
+        });
+    });
     let modes = [];
     let initialModeIndex = 0;
     let resolved = false;
@@ -61,27 +67,12 @@ export default function agentBackend(ctx) {
         compositor: ctx.compositor,
         instanceId: ctx.instanceId,
     });
-    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: PACKAGE_VERSION,
-                model: llmClient.model,
-                provider: modes[initialModeIndex]?.provider,
-                contextWindow: modes[initialModeIndex]?.contextWindow,
-            });
-        },
-    });
     bus.on("core:extensions-loaded", () => {
         const settings = getSettings();
-        const providerName = config.provider ?? settings.defaultProvider;
+        // If the user didn't pick a default, fall back to the first registered
+        // provider (built-in load order biases to openrouter → openai).
+        const providerName = config.provider ?? settings.defaultProvider
+            ?? (providerRegistry.size > 0 ? providerRegistry.keys().next().value : undefined);
         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
@@ -90,22 +81,49 @@ export default function agentBackend(ctx) {
         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" });
+        // No provider → don't register ash at all, so another backend (e.g.
+        // claude-code-bridge) can own activation. index.ts hard-fails only
+        // when no backend ended up registered.
+        if (!effectiveApiKey || !effectiveModel)
             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)));
+        let foundIdx = modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id));
+        // Persisted default may not be in the provider's curated list yet (e.g.
+        // openrouter's async catalog fetch hasn't returned). Prepend a stub so
+        // the initial config:set-modes activeIndex points at the real model —
+        // otherwise AgentLoop reconfigures llmClient back to modes[0].
+        if (foundIdx === -1 && activeProvider) {
+            modes = [
+                {
+                    model: effectiveModel,
+                    provider: activeProvider.id,
+                    providerConfig: { apiKey: effectiveApiKey, baseURL: effectiveBaseURL },
+                    supportsReasoningEffort: activeProvider.supportsReasoningEffort,
+                },
+                ...modes,
+            ];
+            foundIdx = 0;
+        }
+        initialModeIndex = Math.max(0, foundIdx);
         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.emit("agent:register-backend", {
+            name: "ash",
+            kill: () => agentLoop.kill(),
+            start: async () => {
+                agentLoop.wire();
+                bus.emit("agent:info", {
+                    name: "ash",
+                    version: PACKAGE_VERSION,
+                    model: llmClient.model,
+                    provider: modes[initialModeIndex]?.provider,
+                    contextWindow: modes[initialModeIndex]?.contextWindow,
+                });
+            },
+        });
     });
     bus.on("provider:register", (p) => {
         const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);

package/dist/extensions/index.d.ts

@@ -9,11 +9,13 @@ import type { ExtensionContext } from "../types.js";
 type ActivateFn = (ctx: ExtensionContext) => void;
 export declare const BUILTIN_EXTENSIONS: Array<{
     name: string;
+    when?: () => boolean;
     load: () => Promise<ActivateFn>;
 }>;
 /**
- * Load built-in extensions sequentially, skipping any in the disabled list.
- * Returns the names of extensions that were loaded.
+ * Load built-in extensions sequentially, skipping any in the disabled list
+ * or whose `when` predicate returns false. Returns the names of extensions
+ * that were loaded.
  */
 export declare function loadBuiltinExtensions(ctx: ExtensionContext, disabled?: string[]): Promise<string[]>;
 export {};

package/dist/extensions/index.js

@@ -1,13 +1,19 @@
 export const BUILTIN_EXTENSIONS = [
     { name: "agent-backend", load: () => import("./agent-backend.js").then(m => m.default) },
+    { name: "openrouter",
+        when: () => !!process.env.OPENROUTER_API_KEY,
+        load: () => import("./openrouter.js").then(m => m.default) },
+    { name: "openai",
+        when: () => !!process.env.OPENAI_API_KEY,
+        load: () => import("./openai.js").then(m => m.default) },
     { 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: "command-suggest", load: () => import("./command-suggest.js").then(m => m.default) },
 ];
 /**
- * Load built-in extensions sequentially, skipping any in the disabled list.
- * Returns the names of extensions that were loaded.
+ * Load built-in extensions sequentially, skipping any in the disabled list
+ * or whose `when` predicate returns false. Returns the names of extensions
+ * that were loaded.
  */
 export async function loadBuiltinExtensions(ctx, disabled = []) {
     const disabledSet = new Set(disabled);
@@ -15,6 +21,8 @@ export async function loadBuiltinExtensions(ctx, disabled = []) {
     for (const ext of BUILTIN_EXTENSIONS) {
         if (disabledSet.has(ext.name))
             continue;
+        if (ext.when && !ext.when())
+            continue;
         const activate = await ext.load();
         activate(ctx);
         loaded.push(ext.name);

package/dist/extensions/openai.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Built-in OpenAI-compatible provider — auto-activates when OPENAI_API_KEY
+ * is set. OPENAI_BASE_URL redirects to local servers (Ollama, LM Studio,
+ * vLLM, llama.cpp) which then get their catalog via /models.
+ */
+import type { ExtensionContext } from "../types.js";
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/openai.js

@@ -0,0 +1,46 @@
+const DEFAULT_MODELS = [
+    "gpt-5",
+    "gpt-4.1",
+    "gpt-4o",
+    "gpt-4o-mini",
+    "o3",
+    "o3-mini",
+];
+export default function activate(ctx) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey)
+        return;
+    const baseURL = process.env.OPENAI_BASE_URL;
+    const id = baseURL ? "openai-compatible" : "openai";
+    if (!baseURL) {
+        ctx.bus.emit("provider:register", {
+            id,
+            apiKey,
+            defaultModel: DEFAULT_MODELS[0],
+            models: DEFAULT_MODELS,
+        });
+        return;
+    }
+    // Register empty immediately so the provider resolves; refill from /models.
+    ctx.bus.emit("provider:register", { id, apiKey, baseURL, models: [] });
+    fetchModels(baseURL, apiKey).then((models) => {
+        if (models.length === 0)
+            return;
+        ctx.bus.emit("provider:register", {
+            id,
+            apiKey,
+            baseURL,
+            defaultModel: models[0],
+            models,
+        });
+    }).catch(() => { });
+}
+async function fetchModels(baseURL, apiKey) {
+    const res = await fetch(`${baseURL.replace(/\/$/, "")}/models`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok)
+        return [];
+    const data = await res.json();
+    return (data.data ?? []).map((m) => m.id);
+}

package/dist/extensions/openrouter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Built-in OpenRouter provider — auto-activates when OPENROUTER_API_KEY is set.
+ * Registers curated defaults synchronously so the first query works, then
+ * fetches the full catalog to populate /model autocomplete.
+ */
+import type { ExtensionContext } from "../types.js";
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/openrouter.js

@@ -0,0 +1,39 @@
+const BASE_URL = "https://openrouter.ai/api/v1";
+const DEFAULT_MODELS = ["anthropic/claude-sonnet-4.6"];
+export default function activate(ctx) {
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey)
+        return;
+    ctx.bus.emit("provider:register", {
+        id: "openrouter",
+        apiKey,
+        baseURL: BASE_URL,
+        defaultModel: DEFAULT_MODELS[0],
+        models: DEFAULT_MODELS,
+    });
+    fetchModels(apiKey).then((models) => {
+        if (models.length === 0)
+            return;
+        ctx.bus.emit("provider:register", {
+            id: "openrouter",
+            apiKey,
+            baseURL: BASE_URL,
+            defaultModel: DEFAULT_MODELS[0],
+            supportsReasoningEffort: true,
+            models: models.map((m) => ({
+                id: m.id,
+                reasoning: m.supported_parameters?.includes("reasoning") ?? false,
+                contextWindow: m.context_length,
+            })),
+        });
+    }).catch(() => { });
+}
+async function fetchModels(apiKey) {
+    const res = await fetch(`${BASE_URL}/models`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok)
+        return [];
+    const data = await res.json();
+    return data.data ?? [];
+}

package/dist/extensions/tui-renderer.js

@@ -50,6 +50,7 @@ function createRenderState() {
         spinnerStartTime: 0,
         openTool: null,
         pendingToolCompletes: new Map(),
+        orphanContHeaderKind: undefined,
         currentToolKind: undefined,
         toolStartTime: 0,
         toolExitCode: null,
@@ -178,11 +179,8 @@ export default function activate(ctx) {
                 stopCurrentSpinner();
                 if (!s.renderer)
                     startAgentResponse();
-                s.renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
-                drain();
             }
             else {
-                // Restart spinner with ctrl+t hint now that we know thinking is available
                 startThinkingSpinner();
             }
         }
@@ -256,6 +254,7 @@ export default function activate(ctx) {
             return;
         fencedTransform.flush();
         finalizeToolGroup();
+        s.orphanContHeaderKind = undefined;
         batchGroups = new Map();
         for (const group of e.groups) {
             batchGroups.set(group.kind, {
@@ -272,6 +271,7 @@ export default function activate(ctx) {
         stopCurrentSpinner();
         s.currentToolKind = e.kind;
         s.toolStartTime = Date.now();
+        s.orphanContHeaderKind = undefined;
         if (e.title === "user_shell") {
             finalizeToolGroup();
             closeToolLine();
@@ -315,10 +315,12 @@ export default function activate(ctx) {
                 showToolCall(e.title, "", { ...e, groupContinuation: true });
                 s.toolGroupRendered++;
             }
-            // Record identity so late completes (after a premature finalize
-            // from a cross-kind standalone start) can render as labeled ⎿ lines.
             if (e.toolCallId) {
-                s.pendingToolCompletes.set(e.toolCallId, { title: e.title });
+                s.pendingToolCompletes.set(e.toolCallId, {
+                    title: e.title,
+                    kind,
+                    displayDetail: e.displayDetail ?? extractDetail(e),
+                });
             }
         }
         else {
@@ -342,13 +344,25 @@ export default function activate(ctx) {
                 s.pendingToolCompletes.delete(e.toolCallId);
             s.toolGroupCompletedCount++;
             s.currentToolKind = undefined;
+            // Finalize as soon as all members return so aggregate lands right
+            // after its children, not below out-of-band renders from the next tool.
+            const batchGroup = batchGroups.get(s.toolGroupKind);
+            if (batchGroup && s.toolGroupCompletedCount >= batchGroup.total) {
+                finalizeToolGroup();
+            }
         }
         else {
-            // Route by callId — tools that lost the inline slot get a labeled ⎿ line.
+            // Tools that lost the inline slot render as a labeled ⎿. Orphans
+            // (group finalized before they returned) reroute via showOrphanedComplete.
             const pending = e.toolCallId ? s.pendingToolCompletes.get(e.toolCallId) : undefined;
             if (pending)
                 s.pendingToolCompletes.delete(e.toolCallId);
-            showToolComplete(e.exitCode, e.resultDisplay, pending?.title);
+            if (pending?.orphaned) {
+                showOrphanedComplete(e.exitCode, e.resultDisplay, pending.title, pending.kind, pending.displayDetail);
+            }
+            else {
+                showToolComplete(e.exitCode, e.resultDisplay, pending?.displayDetail ?? pending?.title);
+            }
             s.currentToolKind = undefined;
             s.spinnerStartTime = 0;
             startThinkingSpinner();
@@ -746,8 +760,14 @@ export default function activate(ctx) {
             }
             else {
                 out().write(`  ${batchPrefix}${lines[lines.length - 1]}`);
-                if (extra?.toolCallId)
-                    s.openTool = { callId: extra.toolCallId, title };
+                if (extra?.toolCallId) {
+                    s.openTool = {
+                        callId: extra.toolCallId,
+                        title,
+                        kind: extra.kind,
+                        displayDetail: extra.displayDetail ?? extractDetail(extra),
+                    };
+                }
             }
         }
         s.hadToolCalls = true;
@@ -775,6 +795,26 @@ export default function activate(ctx) {
         if (resultDisplay?.body)
             renderResultBody(resultDisplay.body);
     }
+    /** Late completion from a finalized group — re-emit the kind header
+     *  in muted "(cont.)" form so the ⎿ has a legitimate parent, then
+     *  render the completion as a normal labeled ⎿. Subsequent orphans
+     *  of the same kind reuse the existing (cont.) header. */
+    function showOrphanedComplete(exitCode, resultDisplay, title, kind, displayDetail) {
+        if (s.orphanContHeaderKind !== kind) {
+            stopCurrentSpinner();
+            closeToolLine();
+            flushCommandOutput();
+            if (!s.renderer)
+                startAgentResponse();
+            showCollapsedThinking();
+            const icon = (kind && KIND_ICONS[kind]) ?? "▶";
+            const label = kind ?? "tool";
+            s.renderer.writeLine(`${p.muted}${icon} ${label} (cont.)${p.reset}`);
+            drain();
+            s.orphanContHeaderKind = kind;
+        }
+        showToolComplete(exitCode, resultDisplay, displayDetail || title);
+    }
     function renderResultBody(body) {
         if (!s.renderer)
             return;
@@ -796,10 +836,7 @@ export default function activate(ctx) {
         stopCurrentSpinner();
         const thinking = hasThinkingMode();
         s.spinnerLabel = thinking ? "Thinking" : "Working";
-        const hint = thinking
-            ? (s.showThinkingText ? "(ctrl+t to collapse)" : "(ctrl+t to expand)")
-            : "";
-        s.spinnerOpts = { hint: hint || undefined, startTime: s.spinnerStartTime };
+        s.spinnerOpts = { startTime: s.spinnerStartTime };
         s.spinner = createSpinner({ startTime: s.spinnerStartTime });
         s.spinnerInterval = setInterval(() => {
             if (s.spinner) {
@@ -825,13 +862,25 @@ export default function activate(ctx) {
         if (s.openTool) {
             out().write("\n");
             // Stash identity so the completion renders as ⎿ labeled, not orphan ✓.
-            s.pendingToolCompletes.set(s.openTool.callId, { title: s.openTool.title });
+            s.pendingToolCompletes.set(s.openTool.callId, {
+                title: s.openTool.title,
+                kind: s.openTool.kind,
+                displayDetail: s.openTool.displayDetail,
+            });
             s.openTool = null;
         }
     }
     /** Render the group aggregate ⎿ line, or skip if no members have
      *  completed yet (late completes will render individually as ⎿ labeled). */
     function finalizeToolGroup() {
+        // Late completes from this group have lost their inline slot; mark
+        // them so showOrphanedComplete re-emits a (cont.) header for their ⎿.
+        if (s.toolGroupKind) {
+            for (const pending of s.pendingToolCompletes.values()) {
+                if (pending.kind === s.toolGroupKind)
+                    pending.orphaned = true;
+            }
+        }
         const skipAggregate = s.toolGroupCount > 1 && s.toolGroupCompletedCount === 0;
         if (s.toolGroupCount <= 1 || skipAggregate) {
             s.toolGroupKind = undefined;
@@ -842,6 +891,7 @@ export default function activate(ctx) {
             s.toolGroupSummaries = [];
             return;
         }
+        stopCurrentSpinner();
         closeToolLine();
         if (!s.renderer)
             startAgentResponse();
@@ -938,14 +988,10 @@ export default function activate(ctx) {
         if (s.spinner) {
             stopCurrentSpinner();
             if (s.showThinkingText) {
-                // Expanding: replace spinner with thinking text header
                 if (!s.renderer)
                     startAgentResponse();
-                s.renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
-                drain();
             }
             else {
-                // Collapsing: restart spinner with updated hint
                 startThinkingSpinner();
             }
             return;

package/dist/index.js

@@ -8,6 +8,7 @@ import { loadBuiltinExtensions } from "./extensions/index.js";
 import { loadExtensions } from "./extension-loader.js";
 import { getSettings } from "./settings.js";
 import { discoverSkills } from "./agent/skills.js";
+import { runInit } from "./init.js";
 /**
  * Capture the user's full shell environment.
  * This picks up env vars exported in .zshrc/.bashrc that the
@@ -105,6 +106,7 @@ function parseArgs(argv) {
             console.log(`agent-sh — a shell-first terminal where AI is one keystroke away
 
 Usage: agent-sh [options]
+       agent-sh init [--force]    Scaffold ~/.agent-sh/ (settings, examples, AGENTS.md)
 
 Provider Profiles:
   --provider <name>   Use a provider from ~/.agent-sh/settings.json
@@ -145,13 +147,19 @@ Inside the shell:
     return { shell, model, extensions, apiKey, baseURL, provider };
 }
 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") });
+        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);
     }
     process.on("SIGTTOU", () => { });
     process.on("SIGTTIN", () => { });
-    const config = parseArgs(process.argv.slice(2));
+    const config = parseArgs(rawArgs);
     // Capture user's full shell environment
     const baseEnv = {};
     for (const [k, v] of Object.entries(process.env)) {
@@ -262,6 +270,16 @@ async function main() {
     // ── Activate agent backend ────────────────────────────────────
     // Extensions had their chance to register via agent:register-backend.
     // If none did, the built-in AgentLoop gets wired to bus events.
+    const { names: backendNames } = core.bus.emitPipe("config:get-backends", { names: [], active: null });
+    if (backendNames.length === 0) {
+        shell.kill();
+        console.error("\nagent-sh: no agent backend available.\n\n" +
+            "  Export OPENROUTER_API_KEY or OPENAI_API_KEY for zero-config launch, or\n" +
+            "  pass --api-key on the command line, or\n" +
+            "  run `agent-sh init` for a settings.json template.\n" +
+            "  Alternatively, install a bridge extension (claude-code-bridge, pi-bridge).\n");
+        process.exit(1);
+    }
     core.activateBackend();
     // ── Startup banner ───────────────────────────────────────────
     const settings = getSettings();
@@ -270,6 +288,7 @@ async function main() {
         const bannerW = Math.min(termW, 60);
         const productName = `${p.accent}${p.bold}agent-sh${p.reset}`;
         const info = agentInfo;
+        const backendReady = !!info?.model;
         const backendName = info?.name ?? "ash";
         const model = info?.model;
         const provider = info?.provider;
@@ -277,7 +296,7 @@ async function main() {
             ? provider ? `${model} [${provider}]` : model
             : null;
         let sections = "";
-        sections += `\n\n  ${p.muted}Backend:${p.reset} ${p.dim}${backendName}${p.reset}`;
+        sections += `\n\n  ${p.muted}Backend:${p.reset} ${p.dim}${backendName}${backendReady ? "" : " (not configured)"}${p.reset}`;
         if (modelValue) {
             sections += `\n  ${p.muted}Model:${p.reset} ${p.dim}${modelValue}${p.reset}`;
         }
@@ -300,7 +319,9 @@ async function main() {
                 sections += `\n    ${p.dim}${item}${p.reset}`;
             }
         }
-        const hint = `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}>/help${p.muted} for commands${p.reset}`;
+        const hint = backendReady
+            ? `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}>/help${p.muted} for commands${p.reset}`
+            : `${p.muted}Set ${p.warning}OPENROUTER_API_KEY${p.muted} or ${p.warning}OPENAI_API_KEY${p.muted} and restart to enable AI${p.reset}`;
         const borderLine = `${p.muted}${"─".repeat(bannerW)}${p.reset}`;
         process.stdout.write("\n" + borderLine + "\n" +
             "  " + productName +

package/dist/init.d.ts

@@ -0,0 +1,3 @@
+export declare function runInit(opts: {
+    force: boolean;
+}): void;

package/dist/init.js

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+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");
+const AGENTS_PATH = path.join(CONFIG_DIR, "AGENTS.md");
+// Shape-discoverable stub — all fields present, none filled in.
+const STARTER_SETTINGS = {
+    defaultProvider: null,
+    providers: {},
+    extensions: [],
+    disabledBuiltins: [],
+    disabledExtensions: [],
+};
+// Not loaded at runtime — users copy blocks from here into settings.json.
+const EXAMPLE_SETTINGS = {
+    defaultProvider: "openrouter",
+    providers: {
+        openrouter: {
+            apiKey: "$OPENROUTER_API_KEY",
+            baseURL: "https://openrouter.ai/api/v1",
+            defaultModel: "anthropic/claude-sonnet-4.6",
+        },
+        openai: {
+            apiKey: "$OPENAI_API_KEY",
+            defaultModel: "gpt-5",
+        },
+        anthropic: {
+            apiKey: "$ANTHROPIC_API_KEY",
+            baseURL: "https://api.anthropic.com/v1",
+            defaultModel: "claude-sonnet-4-5",
+        },
+        ollama: {
+            apiKey: "ollama",
+            baseURL: "http://localhost:11434/v1",
+            defaultModel: "llama3.3",
+        },
+    },
+    extensions: [
+        "./examples/extensions/openrouter.ts",
+    ],
+    disabledBuiltins: [],
+    disabledExtensions: [],
+};
+function writeIfMissing(filePath, content, force) {
+    if (!force && fs.existsSync(filePath))
+        return "kept";
+    fs.writeFileSync(filePath, content);
+    return "written";
+}
+export function runInit(opts) {
+    fs.mkdirSync(EXTENSIONS_DIR, { recursive: true });
+    const settingsResult = writeIfMissing(SETTINGS_PATH, JSON.stringify(STARTER_SETTINGS, null, 2) + "\n", opts.force);
+    // Always refreshed — reference material, not user state.
+    fs.writeFileSync(EXAMPLE_PATH, JSON.stringify(EXAMPLE_SETTINGS, null, 2) + "\n");
+    console.log(`agent-sh initialized at ${CONFIG_DIR}`);
+    console.log();
+    console.log(`  settings.json         ${settingsResult}${opts.force ? "" : settingsResult === "kept" ? " (exists — pass --force to overwrite)" : ""}`);
+    console.log(`  settings.example.json refreshed`);
+    console.log(`  extensions/           ready`);
+    console.log();
+    console.log("Next steps:");
+    console.log(`  1. Open ${SETTINGS_PATH}`);
+    console.log(`  2. Copy a provider block from settings.example.json into \`providers\` and set \`defaultProvider\`.`);
+    console.log(`  3. Export the referenced env var (e.g. \`export OPENROUTER_API_KEY=...\`).`);
+    console.log(`  4. Run \`agent-sh\`.`);
+    console.log();
+    console.log(`Optional: create ${AGENTS_PATH} with standing instructions`);
+    console.log(`(code style, commands to avoid, etc.) to load them into every session.`);
+}

package/dist/shell/input-handler.js

@@ -253,6 +253,36 @@ export class InputHandler {
                             seq += data[i];
                         }
                     }
+                    else if (next === "]" || next === "P" || next === "_" || next === "^") {
+                        // String sequences terminated by BEL or ST (ESC \):
+                        //   OSC (ESC ]) — OSC 10/11 color-query responses
+                        //   DCS (ESC P) — tmux XTVERSION query response (iTerm2 etc.)
+                        //   APC (ESC _), PM (ESC ^) — rarer, same termination
+                        // Forward as a unit so the payload doesn't leak into lineBuffer
+                        // and onto the bash command line after a foreground app exits.
+                        let j = i + 2;
+                        let termEnd = -1;
+                        while (j < data.length) {
+                            const c = data[j];
+                            if (c === "\x07") {
+                                termEnd = j;
+                                break;
+                            }
+                            if (c === "\x1b" && j + 1 < data.length && data[j + 1] === "\\") {
+                                termEnd = j + 1;
+                                break;
+                            }
+                            j++;
+                        }
+                        if (termEnd !== -1) {
+                            seq = data.slice(i, termEnd + 1);
+                            i = termEnd;
+                        }
+                        else {
+                            seq += next;
+                            i++;
+                        }
+                    }
                     else {
                         // ESC + single char (alt-key, etc.)
                         seq += next;