agent-sh 0.12.26 → 0.13.0

package/dist/agent/index.js

@@ -1,9 +1,360 @@
-/**
- * Agent backend exports.
- *
- * The default backend is AgentLoop (in-process, OpenAI-compatible API).
- * Extensions can register alternative backends via agent:register-backend.
- */
+import { AgentLoop } from "./agent-loop.js";
+import { LlmClient } from "../utils/llm-client.js";
+import { createLlmFacade } from "../utils/llm-facade.js";
+import { resolveProvider, getProviderNames, getSettings } from "../core/settings.js";
+import { PACKAGE_VERSION } from "../utils/package-version.js";
+import { discoverSkills } from "./skills.js";
+import { resolveApiKey } from "../cli/auth/keys.js";
+import activateOpenrouter from "./providers/openrouter.js";
+import activateOpenai from "./providers/openai.js";
+import activateOpenaiCompatible from "./providers/openai-compatible.js";
+import activateDeepseek from "./providers/deepseek.js";
+function persistedModelFor(providerName) {
+    if (!providerName)
+        return undefined;
+    return getSettings().providers?.[providerName]?.defaultModel;
+}
+function defaultReasoningBuilder(level) {
+    return level === "off" ? {} : { reasoning_effort: level };
+}
+function mergeCaps(settingsCaps, payloadCaps, modelIds) {
+    if (!settingsCaps)
+        return payloadCaps.size > 0 ? payloadCaps : undefined;
+    const out = new Map();
+    for (const id of modelIds) {
+        const s = settingsCaps.get(id);
+        const p = payloadCaps.get(id);
+        if (!s && !p)
+            continue;
+        out.set(id, {
+            reasoning: s?.reasoning ?? p?.reasoning,
+            contextWindow: s?.contextWindow ?? p?.contextWindow,
+            maxTokens: s?.maxTokens ?? p?.maxTokens,
+            echoReasoning: s?.echoReasoning ?? p?.echoReasoning,
+        });
+    }
+    return out.size > 0 ? out : undefined;
+}
+export default function agentBackend(ctx) {
+    const { bus } = ctx;
+    const config = ctx.call("config:get-app-config") ?? {};
+    const agentSurface = {
+        llm: createLlmFacade({ list: ctx.list, call: ctx.call }),
+        providers: {
+            configure: (id, configureOpts) => bus.emit("provider:configure", { id, ...configureOpts }),
+        },
+        registerTool: (tool) => bus.emit("agent:register-tool", { tool, extensionName: "" }),
+        unregisterTool: (name) => bus.emit("agent:unregister-tool", { name }),
+        adviseTool: (name, advisor) => ctx.advise(`tool:${name}`, advisor),
+        adviseToolSchema: (name, advisor) => ctx.advise(`tool:${name}:schema`, advisor),
+        getTools: () => bus.emitPipe("agent:get-tools", { tools: [] }).tools,
+        registerInstruction: (name, text) => bus.emit("agent:register-instruction", { name, text, extensionName: "" }),
+        removeInstruction: (name) => bus.emit("agent:remove-instruction", { name }),
+        adviseInstruction: (name, advisor) => ctx.advise(`instruction:${name}`, advisor),
+        registerSkill: (name, description, filePath) => bus.emit("agent:register-skill", { name, description, filePath, extensionName: "" }),
+        removeSkill: (name) => bus.emit("agent:remove-skill", { name }),
+        adviseSkill: (name, advisor) => ctx.advise(`skill:${name}:view`, advisor),
+        registerContextProducer: (_name, producer, producerOpts) => {
+            const handlerName = producerOpts?.mode === "per-query"
+                ? "query-context:build"
+                : "dynamic-context:build";
+            return ctx.advise(handlerName, (next) => {
+                const base = next();
+                const part = producer();
+                if (!part)
+                    return base;
+                const trimmed = part.trim();
+                if (!trimmed)
+                    return base;
+                return base ? `${base}\n\n${trimmed}` : trimmed;
+            });
+        },
+    };
+    ctx.agent = agentSurface;
+    // Immutable settings snapshot; provider:register payloads merge against it.
+    const providerRegistry = new Map();
+    const settingsProviders = new Map();
+    for (const name of getProviderNames()) {
+        const p = resolveProvider(name);
+        if (p) {
+            providerRegistry.set(name, p);
+            settingsProviders.set(name, p);
+        }
+    }
+    const providerHooks = new Map();
+    // Bakes model id into the hook so AgentMode.buildReasoningParams keeps
+    // its (level) signature while the hook can branch on model.
+    const bindReasoning = (shapeId, model) => {
+        const hook = providerHooks.get(shapeId)?.reasoningParams;
+        return hook ? (level) => hook(level, model) : defaultReasoningBuilder;
+    };
+    const buildModes = () => {
+        const allModes = [];
+        for (const [id, p] of providerRegistry) {
+            if (!p.apiKey)
+                continue;
+            const shapeId = p.reasoningShape ?? id;
+            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,
+                    maxTokens: mc?.maxTokens ?? (mc?.contextWindow ? Math.min(Math.floor(mc.contextWindow * 0.4), 65536) : undefined),
+                    reasoning: mc?.reasoning,
+                    supportsReasoningEffort: p.supportsReasoningEffort,
+                    echoReasoning: mc?.echoReasoning,
+                    buildReasoningParams: bindReasoning(shapeId, model),
+                });
+            }
+        }
+        return allModes;
+    };
+    // 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);
+    ctx.define("llm:invoke", (messages, opts) => {
+        return llmClient.complete({
+            messages: messages,
+            max_tokens: opts?.maxTokens,
+            model: opts?.model,
+            reasoning_effort: opts?.reasoningEffort,
+        });
+    });
+    let modes = [];
+    let initialModeIndex = 0;
+    let resolved = false;
+    // Gates late-registration reconcile so its config:switch-model emit doesn't misroute under a non-ash backend.
+    let ashActive = 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,
+        llmClient,
+        handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call, list: ctx.list },
+        modes,
+        initialModeIndex,
+        compositor: ctx.shell?.compositor,
+        instanceId: ctx.instanceId,
+        history: config.history,
+    });
+    let loadedExtensionNames = [];
+    bus.on("core:extensions-loaded", ({ names }) => {
+        loadedExtensionNames = names;
+        const settings = getSettings();
+        // 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
+        // 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;
+        // 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 }];
+        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;
+        bus.emit("agent:register-backend", {
+            name: "ash",
+            kill: () => {
+                ashActive = false;
+                bus.emit("command:unregister", { name: "/compact" });
+                bus.emit("command:unregister", { name: "/context" });
+                agentLoop.kill();
+            },
+            start: async () => {
+                agentLoop.wire();
+                ashActive = true;
+                bus.emit("command:register", {
+                    name: "/compact",
+                    description: "Compact conversation via the active compaction strategy",
+                    handler: () => bus.emit("agent:compact-request", {}),
+                });
+                bus.emit("command:register", {
+                    name: "/context",
+                    description: "Show context budget usage",
+                    handler: () => {
+                        const stats = bus.emitPipe("context:get-stats", {
+                            activeTokens: 0,
+                            totalTokens: 0,
+                            budgetTokens: 0,
+                        });
+                        const pct = stats.budgetTokens > 0
+                            ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
+                            : 0;
+                        bus.emit("ui:info", {
+                            message: `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
+                        });
+                    },
+                });
+                bus.emit("agent:info", {
+                    name: "ash",
+                    version: PACKAGE_VERSION,
+                    model: llmClient.model,
+                    provider: modes[initialModeIndex]?.provider,
+                    contextWindow: modes[initialModeIndex]?.contextWindow,
+                });
+            },
+        });
+    });
+    bus.on("provider:configure", ({ id, reasoningParams }) => {
+        const prev = providerHooks.get(id) ?? {};
+        if (reasoningParams !== undefined)
+            prev.reasoningParams = reasoningParams;
+        providerHooks.set(id, prev);
+    });
+    bus.on("provider:register", (p) => {
+        const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
+        const payloadModelIds = [];
+        const payloadCaps = new Map();
+        for (const m of rawModels) {
+            if (typeof m === "string") {
+                payloadModelIds.push(m);
+            }
+            else {
+                payloadModelIds.push(m.id);
+                payloadCaps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, maxTokens: m.maxTokens, echoReasoning: m.echoReasoning });
+            }
+        }
+        const settings = settingsProviders.get(p.id);
+        const modelIds = settings?.modelsExplicit && settings.models.length > 0 ? settings.models : payloadModelIds;
+        const mergedCaps = mergeCaps(settings?.modelCapabilities, payloadCaps, modelIds);
+        const merged = {
+            id: p.id,
+            apiKey: settings?.apiKey ?? p.apiKey,
+            baseURL: settings?.baseURL ?? p.baseURL,
+            defaultModel: settings?.defaultModel ?? p.defaultModel,
+            models: modelIds,
+            modelsExplicit: settings?.modelsExplicit ?? false,
+            contextWindow: settings?.contextWindow,
+            supportsReasoningEffort: settings?.supportsReasoningEffort ?? p.supportsReasoningEffort,
+            modelCapabilities: mergedCaps,
+            reasoningShape: settings?.reasoningShape,
+        };
+        providerRegistry.set(p.id, merged);
+        const addModes = modelIds.map((m) => {
+            const mc = mergedCaps?.get(m);
+            return {
+                model: m,
+                provider: p.id,
+                providerConfig: { apiKey: merged.apiKey ?? "", baseURL: merged.baseURL },
+                contextWindow: mc?.contextWindow,
+                maxTokens: mc?.maxTokens,
+                reasoning: mc?.reasoning,
+                supportsReasoningEffort: merged.supportsReasoningEffort,
+                echoReasoning: mc?.echoReasoning,
+                buildReasoningParams: bindReasoning(p.id, m),
+            };
+        });
+        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 || !ashActive)
+            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 });
+        }
+    });
+    bus.on("config:switch-provider", ({ provider: name }) => {
+        const p = providerRegistry.get(name);
+        if (!p) {
+            bus.emit("ui:error", { message: `Unknown provider: ${name}` });
+            return;
+        }
+        if (!p.apiKey) {
+            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: 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: p.apiKey, baseURL: p.baseURL },
+                contextWindow: mc?.contextWindow ?? p.contextWindow,
+                maxTokens: mc?.maxTokens ?? (mc?.contextWindow ? Math.min(Math.floor(mc.contextWindow * 0.4), 65536) : undefined),
+                reasoning: mc?.reasoning,
+                supportsReasoningEffort: p.supportsReasoningEffort,
+                echoReasoning: mc?.echoReasoning,
+            };
+        });
+        bus.emit("config:set-modes", { modes: newModes });
+        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", {});
+    });
+    bus.onPipe("banner:collect", (e) => {
+        if (e.activeBackend && e.activeBackend !== "ash")
+            return e;
+        if (loadedExtensionNames.length > 0) {
+            e.sections.push({ label: "Extensions", items: [...loadedExtensionNames] });
+        }
+        const skills = discoverSkills(ctx.call("cwd") ?? process.cwd());
+        if (skills.length > 0) {
+            e.sections.push({ label: "Skills", items: skills.map((s) => s.name) });
+        }
+        return e;
+    });
+}
 export { AgentLoop } from "./agent-loop.js";
 export { ToolRegistry } from "./tool-registry.js";
 export { runSubagent } from "./subagent.js";
+/** Activate the ash backend and any provider whose key is configured. */
+export function activateAgent(ctx) {
+    agentBackend(ctx);
+    const agentCtx = ctx;
+    if (resolveApiKey("openrouter").key)
+        activateOpenrouter(agentCtx);
+    if (resolveApiKey("openai").key && !process.env.OPENAI_BASE_URL)
+        activateOpenai(agentCtx);
+    if (process.env.OPENAI_BASE_URL)
+        activateOpenaiCompatible(agentCtx);
+    activateDeepseek(agentCtx);
+}

package/dist/agent/nuclear-form.d.ts

@@ -32,6 +32,13 @@ export interface NuclearEntry {
      * survives into summaries. Displayed as `{why}` in formatNuclearLine.
      */
     why?: string;
+    /**
+     * Optional parent pointer for tree-shaped history. The default
+     * HistoryFile adapter ignores this and treats the file as linear;
+     * tree-aware HistoryAdapter implementations use it to fork and to
+     * walk a single path on resume.
+     */
+    parentSeq?: number;
 }
 /**
  * Create a session-start marker entry. Markers use seq=0 by default —

package/dist/{extensions → agent}/providers/deepseek.d.ts

@@ -4,5 +4,5 @@
  * to enabled. The hook always attaches; provider registration via env
  * is opt-in alongside any settings.json entry.
  */
-import type { ExtensionContext } from "../../types.js";
-export default function activate(ctx: ExtensionContext): void;
+import type { AgentContext } from "../host-types.js";
+export default function activate(ctx: AgentContext): void;

package/dist/{extensions → agent}/providers/deepseek.js

@@ -1,7 +1,8 @@
+import { resolveApiKey } from "../../cli/auth/keys.js";
 const BASE_URL = "https://api.deepseek.com";
 const DEFAULT_MODELS = [
-    { id: "deepseek-v4-flash", reasoning: true, echoReasoning: true },
-    { id: "deepseek-v4-pro", reasoning: true, echoReasoning: true },
+    { id: "deepseek-v4-flash", reasoning: true, echoReasoning: true, contextWindow: 1_000_000 },
+    { id: "deepseek-v4-pro", reasoning: true, echoReasoning: true, contextWindow: 1_000_000 },
 ];
 function buildReasoningParams(level, _model) {
     return level === "off"
@@ -9,8 +10,8 @@ function buildReasoningParams(level, _model) {
         : { thinking: { type: "enabled" }, reasoning_effort: level };
 }
 export default function activate(ctx) {
-    ctx.providers.configure("deepseek", { reasoningParams: buildReasoningParams });
-    const apiKey = process.env.DEEPSEEK_API_KEY;
+    ctx.agent.providers.configure("deepseek", { reasoningParams: buildReasoningParams });
+    const apiKey = resolveApiKey("deepseek").key;
     if (!apiKey)
         return;
     ctx.bus.emit("provider:register", {

package/dist/{extensions → agent}/providers/openai-compatible.d.ts

@@ -3,5 +3,5 @@
  * Studio, vLLM, llama.cpp, …). No reasoning hook — the right shape depends
  * on which model the server is serving; user extensions can add one.
  */
-import type { ExtensionContext } from "../../types.js";
-export default function activate(ctx: ExtensionContext): void;
+import type { AgentContext } from "../host-types.js";
+export default function activate(ctx: AgentContext): void;

package/dist/{extensions → agent}/providers/openai.d.ts

@@ -3,5 +3,5 @@
  * family: o-series has no off; gpt-5-codex floors at "low"; plain gpt-5
  * floors at "minimal"; gpt-5.1+ accepts "none" as documented full off.
  */
-import type { ExtensionContext } from "../../types.js";
-export default function activate(ctx: ExtensionContext): void;
+import type { AgentContext } from "../host-types.js";
+export default function activate(ctx: AgentContext): void;

package/dist/{extensions → agent}/providers/openai.js

@@ -1,3 +1,4 @@
+import { resolveApiKey } from "../../cli/auth/keys.js";
 const CLOUD_MODELS = [
     { id: "gpt-5", reasoning: true },
     { id: "gpt-4.1", reasoning: false },
@@ -24,12 +25,12 @@ function buildReasoningParams(level, model) {
     return off ? { reasoning_effort: off } : {};
 }
 export default function activate(ctx) {
-    const apiKey = process.env.OPENAI_API_KEY;
+    const apiKey = resolveApiKey("openai").key;
     if (!apiKey)
         return;
     if (process.env.OPENAI_BASE_URL)
         return; // openai-compatible handles this
-    ctx.providers.configure("openai", { reasoningParams: buildReasoningParams });
+    ctx.agent.providers.configure("openai", { reasoningParams: buildReasoningParams });
     ctx.bus.emit("provider:register", {
         id: "openai",
         apiKey,

package/dist/{extensions → agent}/providers/openrouter.d.ts

@@ -3,5 +3,5 @@
  * 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;
+import type { AgentContext } from "../host-types.js";
+export default function activate(ctx: AgentContext): void;

package/dist/{extensions → agent}/providers/openrouter.js

@@ -1,4 +1,5 @@
-import { getSettings } from "../../settings.js";
+import { getSettings } from "../../core/settings.js";
+import { resolveApiKey } from "../../cli/auth/keys.js";
 const BASE_URL = "https://openrouter.ai/api/v1";
 const DEFAULT_MODELS = ["deepseek/deepseek-v4-flash"];
 // Built-in defaults for models requiring reasoning_content echoed back
@@ -14,10 +15,10 @@ function buildReasoningParams(level, _model) {
         : { reasoning: { effort: level } };
 }
 export default function activate(ctx) {
-    const apiKey = process.env.OPENROUTER_API_KEY;
+    const apiKey = resolveApiKey("openrouter").key;
     if (!apiKey)
         return;
-    ctx.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
+    ctx.agent.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
     ctx.bus.emit("provider:register", {
         id: "openrouter",
         apiKey,

package/dist/agent/skills.js

@@ -13,20 +13,64 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-import { CONFIG_DIR, getSettings } from "../settings.js";
-/** Parse YAML frontmatter from a SKILL.md file. */
+import { CONFIG_DIR, getSettings } from "../core/settings.js";
+/** Parse YAML frontmatter from a SKILL.md file. Supports inline scalars
+ *  and block scalars (`>`, `>-`, `|`, `|-`) for multi-line descriptions. */
 function parseFrontmatter(content) {
     const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
     if (!match)
         return null;
     const meta = {};
-    for (const line of match[1].split("\n")) {
+    const lines = match[1].split("\n");
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const indent = line.length - line.trimStart().length;
         const colon = line.indexOf(":");
-        if (colon > 0) {
-            const key = line.slice(0, colon).trim();
-            const value = line.slice(colon + 1).trim();
-            meta[key] = value;
+        if (colon <= 0 || indent > 0) {
+            i++;
+            continue;
+        }
+        const key = line.slice(0, colon).trim();
+        const rawValue = line.slice(colon + 1).trim();
+        const blockStyle = rawValue.match(/^([>|])([+-]?)\s*$/);
+        if (!blockStyle) {
+            meta[key] = rawValue;
+            i++;
+            continue;
+        }
+        const folded = blockStyle[1] === ">";
+        const chomp = blockStyle[2];
+        const body = [];
+        let blockIndent = -1;
+        let j = i + 1;
+        while (j < lines.length) {
+            const next = lines[j];
+            if (next.trim() === "") {
+                body.push("");
+                j++;
+                continue;
+            }
+            const ind = next.length - next.trimStart().length;
+            if (blockIndent === -1)
+                blockIndent = ind;
+            if (ind < blockIndent)
+                break;
+            body.push(next.slice(blockIndent));
+            j++;
+        }
+        let end = body.length;
+        if (chomp !== "+") {
+            while (end > 0 && body[end - 1] === "")
+                end--;
+            if (chomp !== "-" && end < body.length)
+                end++;
         }
+        const kept = body.slice(0, end);
+        meta[key] = folded
+            ? kept.join(" ").replace(/\s+/g, " ").trim()
+            : kept.join("\n");
+        i = j;
     }
     return { meta, body: match[2] };
 }

package/dist/agent/subagent.d.ts

@@ -9,7 +9,7 @@
  *
  * Used by the subagent extension to delegate tasks from the main agent.
  */
-import type { EventBus } from "../event-bus.js";
+import type { EventBus } from "../core/event-bus.js";
 import type { LlmClient } from "../utils/llm-client.js";
 import type { ToolDefinition } from "./types.js";
 export interface SubagentOptions {

package/dist/agent/system-prompt.js

@@ -11,10 +11,10 @@ export function formatSkillsBlock(skills) {
     if (skills.length === 0)
         return "";
     return "# Available Skills\n\n"
-        + "Load a skill's full content with read_file on its file path when needed.\n\n"
+        + "Load a skill's full content from its file path with your file-reading tool when needed.\n\n"
         + skills.map(s => `- **${s.name}**: ${s.description}\n  Path: ${s.filePath}`).join("\n\n");
 }
-import { CONFIG_DIR } from "../settings.js";
+import { CONFIG_DIR } from "../core/settings.js";
 const GLOBAL_AGENTS_MD = path.join(CONFIG_DIR, "AGENTS.md");
 // ── File caches ─────────────────────────────────────────────────────
 // Convention files (CLAUDE.md/AGENT.md) are walked synchronously from
@@ -88,24 +88,21 @@ function loadConventionFiles(dir) {
  * Static system prompt — identical across all queries, cacheable.
  * Contains only identity and behavioral instructions.
  */
-export const STATIC_SYSTEM_PROMPT = `You are ash, an AI coding assistant running inside agent-sh, a terminal shell.
-You have access to the user's shell environment and can read, write, and execute code.
-You share the user's working directory, environment variables, and shell history.
-agent-sh documentation is at ${path.join(CODE_DIR, "docs")} — start with README.md for an index. Read the docs when you need to understand how the runtime works.
+export const STATIC_SYSTEM_PROMPT = `You are ash, an AI coding assistant running inside agent-sh — a composable agent runtime with a small core and everything else, including the shell integration, layered on as extensions.
 
-# Tool Decision Guide
-bash, read_file, grep, glob, ls, edit_file, write_file::
-Use these to investigate, search, read, and modify files. Output is returned
-to you for reasoning — the user doesn't see it directly.
+You may be paired with a terminal shell that shares the user's CWD, environment, and history — in that mode you can read shell events and act on the user's session. Otherwise you may be embedded as a library, exposed over a bridge protocol, or running headless, with no shell available; in those modes you operate purely through your registered tools.
 
-Extensions may register additional tools — follow their instructions.
+agent-sh source and documentation live at ${CODE_DIR}. Read them when you need to understand how the runtime works, or when the user asks how to modify or extend it:
+- ${path.join(CODE_DIR, "docs")} — start with README.md; architecture.md and extensions.md cover the kernel boundary and extension API
+- ${path.join(CODE_DIR, "src")} — kernel in src/core, default backend in src/agent, shell host in src/shell, built-in extensions in src/extensions
+- ${path.join(CODE_DIR, "examples/extensions")} — reference extensions to study or copy when adding functionality
 
-# Tool Usage Guidelines
-- Use read_file before editing a file you haven't seen
-- Prefer edit_file over write_file for modifying existing files
-- Use grep/glob to find files before reading them
-- Keep bash commands focused; avoid long-running blocking commands
-- Always check command exit codes for errors
+# Tools
+
+Use your registered tools to investigate, search, read, and modify files.
+Each tool's description tells you when and how to use it; follow that
+guidance rather than assuming a particular tool exists. Tool output is
+returned to you for reasoning — the user doesn't see it directly.
 
 # Context Envelopes
 - \`<query_context>\` (contains \`<cwd>\` always, and \`<shell_events>\` when there were user shell commands since the last turn): the user's situation when they sent this turn — \`<cwd>\` anchors where they are right now, \`<shell_events>\` grounds "fix this" / "what just happened" requests. Trust the most recent \`<cwd>\` over any cwd referenced in earlier history.

package/dist/agent/tool-protocol.d.ts

@@ -102,4 +102,4 @@ export declare class DeferredLookupProtocol implements ToolProtocol {
     createStreamFilter(): null;
     getProtocolTools(): ToolDefinition[];
 }
-export declare function createToolProtocol(mode: "api" | "inline" | "deferred" | "deferred-lookup"): ToolProtocol;
+export declare function createToolProtocol(mode: "api" | "inline" | "deferred" | "deferred-lookup", extraCore?: string[]): ToolProtocol;

package/dist/agent/tool-protocol.js

@@ -545,13 +545,15 @@ const CORE_TOOLS = [
     "bash", "read_file", "write_file", "edit_file",
     "grep", "glob", "ls",
     "list_skills",
+    "conversation_recall",
 ];
-export function createToolProtocol(mode) {
+export function createToolProtocol(mode, extraCore = []) {
+    const core = extraCore.length === 0 ? CORE_TOOLS : [...CORE_TOOLS, ...extraCore];
     if (mode === "inline")
         return new InlineToolProtocol();
     if (mode === "deferred")
-        return new DeferredToolProtocol(CORE_TOOLS);
+        return new DeferredToolProtocol(core);
     if (mode === "deferred-lookup")
-        return new DeferredLookupProtocol(CORE_TOOLS);
+        return new DeferredLookupProtocol(core);
     return new ApiToolProtocol();
 }