agent-sh 0.12.12 → 0.12.14

package/dist/agent/agent-loop.d.ts

@@ -13,7 +13,6 @@
  */
 import type { EventBus } from "../event-bus.js";
 import type { AgentMode } from "../types.js";
-import type { ContextManager } from "../context-manager.js";
 import type { LlmClient } from "../utils/llm-client.js";
 import type { HandlerFunctions } from "../utils/handler-registry.js";
 import type { AgentBackend, ToolDefinition } from "./types.js";
@@ -21,7 +20,6 @@ import { type HistoryAdapter } from "./history-file.js";
 import type { Compositor } from "../utils/compositor.js";
 export interface AgentLoopConfig {
     bus: EventBus;
-    contextManager: ContextManager;
     llmClient: LlmClient;
     handlers: HandlerFunctions;
     modes?: AgentMode[];
@@ -57,14 +55,12 @@ export declare class AgentLoop implements AgentBackend {
     private lastErrorByFile;
     private static readonly THINKING_LEVELS;
     private bus;
-    private contextManager;
     private llmClient;
     private handlers;
     private thinkingLevel;
     private compositor;
     private toolProtocol;
     private instanceId;
-    private lastShellSeq;
     constructor(config: AgentLoopConfig);
     /** Subscribe to bus events — activates this backend. */
     wire(): void;

package/dist/agent/agent-loop.js

@@ -7,15 +7,17 @@ import { ToolRegistry } from "./tool-registry.js";
 import { ConversationState } from "./conversation-state.js";
 import { HistoryFile } from "./history-file.js";
 import { nucleate, formatNuclearLine, isReadOnly } from "./nuclear-form.js";
-import { STATIC_SYSTEM_PROMPT, buildDynamicContext, buildStaticByCwd, formatSkillsBlock, loadGlobalAgentsMd } from "./system-prompt.js";
+import { STATIC_SYSTEM_PROMPT, buildStaticByCwd, formatSkillsBlock, loadGlobalAgentsMd } from "./system-prompt.js";
 import { createToolUI } from "../utils/tool-interactive.js";
 import { RESPONSE_RESERVE, DEFAULT_CONTEXT_WINDOW } from "./token-budget.js";
 import { PACKAGE_VERSION } from "../utils/package-version.js";
+import { wrapTrailingWithDynamicContext } from "../utils/message-utils.js";
 import { getSettings, updateSettings } from "../settings.js";
 import { createToolProtocol } from "./tool-protocol.js";
 // Core tool factories
 import { createBashTool } from "./tools/bash.js";
 import { createPwshTool } from "./tools/pwsh.js";
+import { findBash } from "../executor.js";
 import { createReadFileTool } from "./tools/read-file.js";
 import { createWriteFileTool } from "./tools/write-file.js";
 import { createEditFileTool } from "./tools/edit-file.js";
@@ -88,20 +90,14 @@ export class AgentLoop {
     lastErrorByFile = new Map(); // file path → error summary
     static THINKING_LEVELS = ["off", "low", "medium", "high"];
     bus;
-    contextManager;
     llmClient;
     handlers;
     thinkingLevel = "off";
     compositor = null;
     toolProtocol;
     instanceId;
-    // Cursor into ContextManager's exchange stream. Events with id > this
-    // have not yet been shown to the LLM. We inject the delta as a user
-    // message before each stream so the prefix stays cacheable.
-    lastShellSeq = 0;
     constructor(config) {
         this.bus = config.bus;
-        this.contextManager = config.contextManager;
         this.llmClient = config.llmClient;
         this.handlers = config.handlers;
         this.compositor = config.compositor ?? null;
@@ -597,7 +593,7 @@ export class AgentLoop {
         return `${raw}${context}`;
     }
     registerCoreTools() {
-        const getCwd = () => this.contextManager.getCwd();
+        const getCwd = () => this.handlers.call("cwd");
         const getEnv = () => {
             const env = {};
             for (const [k, v] of Object.entries(process.env)) {
@@ -606,7 +602,9 @@ export class AgentLoop {
             }
             return env;
         };
-        this.toolRegistry.register(createBashTool({ getCwd, getEnv, bus: this.bus }));
+        if (findBash() !== null) {
+            this.toolRegistry.register(createBashTool({ getCwd, getEnv, bus: this.bus }));
+        }
         if (process.platform === "win32") {
             this.toolRegistry.register(createPwshTool({ getCwd, getEnv, bus: this.bus }));
         }
@@ -714,7 +712,7 @@ export class AgentLoop {
             // Placed here so they enter the provider's prompt cache with the
             // system prompt, and only re-materialize when cwd changes invalidate
             // cachedSystemPrompt in executeLoop.
-            const projectStatic = buildStaticByCwd(this.contextManager.getCwd());
+            const projectStatic = buildStaticByCwd(this.handlers.call("cwd"));
             if (projectStatic)
                 parts.push(projectStatic);
             // Extension sections (tools, skills, instructions grouped by extension)
@@ -790,12 +788,9 @@ export class AgentLoop {
             };
         });
         h.define("agent:get-self", () => this);
-        // Extensions compose additional context (git info, project rules, etc.)
-        h.define("dynamic-context:build", () => {
-            const contextWindow = this.currentMode.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
-            const promptTokens = this.conversation.estimatePromptTokens();
-            return buildDynamicContext(this.contextManager, { promptTokens, contextWindow });
-        });
+        // dynamic-context:build / query-context:build are defined in core.ts.
+        // ash consumes them via the envelope wrapping in streamResponse +
+        // handleQuery; other backends may ignore.
         // Full control over what the LLM sees: takes messages[], returns messages[].
         // Default: pass through. Extensions can advise to compact, summarize,
         // filter, reorder, inject — whatever strategy fits.
@@ -1029,14 +1024,14 @@ export class AgentLoop {
         this.bus.emit("agent:processing-start", {});
         let responseText = "";
         try {
-            // Prepend any shell events that preceded this query into the same
-            // user message, so the conversation reads chronologically and we
-            // don't emit two consecutive user-role messages (some providers
-            // reject that).
-            const preDelta = this.contextManager.getEventsSince(this.lastShellSeq);
-            const userContent = preDelta ? `${preDelta.text}\n\n${query}` : query;
-            if (preDelta)
-                this.lastShellSeq = preDelta.lastSeq;
+            // Per-query producers (shell events + any extension-registered
+            // per-query signals) produce content that gets frozen into this
+            // user message inside <query_context>, distinguishing it from the
+            // per-request <dynamic_context> wrapped on the trailing message.
+            const queryContext = (this.handlers.call("query-context:build") ?? "").trim();
+            const userContent = queryContext
+                ? `<query_context>\n${queryContext}\n</query_context>\n\n${query}`
+                : query;
             this.conversation.addUserMessage(userContent);
             this.bus.emit("conversation:message-appended", { role: "user", content: query });
             responseText = await this.executeLoop(signal);
@@ -1080,7 +1075,7 @@ export class AgentLoop {
         // so live signals (budget, in-flight subagents, metacognitive warnings)
         // are fresh.
         let cachedSystemPrompt;
-        let lastCwd = this.contextManager.getCwd();
+        let lastCwd = this.handlers.call("cwd");
         while (!signal.aborted) {
             // Auto-compact when total context approaches the window limit.
             const totalEstimate = this.conversation.estimatePromptTokens();
@@ -1101,7 +1096,7 @@ export class AgentLoop {
                 }
                 cachedSystemPrompt = undefined;
             }
-            const currentCwd = this.contextManager.getCwd();
+            const currentCwd = this.handlers.call("cwd");
             if (currentCwd !== lastCwd) {
                 cachedSystemPrompt = undefined;
                 lastCwd = currentCwd;
@@ -1516,24 +1511,17 @@ export class AgentLoop {
         let reasoning = "";
         const reasoningDetailsByIndex = new Map();
         const pendingToolCalls = [];
+        // Tool protocol controls what goes in the API tools param vs dynamic context
+        const apiTools = this.toolProtocol.getApiTools(this.toolRegistry.all());
+        const toolPrompt = this.toolProtocol.getToolPrompt(this.toolRegistry.all());
+        // Dynamic context rides on the trailing message — see
+        // wrapTrailingWithDynamicContext for the cache-stability rationale.
         const rawMessages = [
             { role: "system", content: systemPrompt },
-            { role: "user", content: `<context>\n${dynamicContext}\n</context>` },
-            { role: "assistant", content: "Understood." },
-            ...this.conversation.getMessages(),
+            ...wrapTrailingWithDynamicContext(this.conversation.getMessages(), dynamicContext, toolPrompt),
         ];
         // Let extensions transform the message array (compact, summarize, filter, etc.)
         const messages = this.handlers.call("conversation:prepare", rawMessages);
-        // Tool protocol controls what goes in the API tools param vs dynamic context
-        const apiTools = this.toolProtocol.getApiTools(this.toolRegistry.all());
-        const toolPrompt = this.toolProtocol.getToolPrompt(this.toolRegistry.all());
-        // Append tool catalog to dynamic context (closer to user query = better followed)
-        if (toolPrompt) {
-            const ctxMsg = messages[1]; // dynamic context user message
-            if (ctxMsg && typeof ctxMsg.content === "string") {
-                ctxMsg.content += "\n" + toolPrompt;
-            }
-        }
         // Stream filter strips tool tags from display (inline mode only)
         const streamFilter = this.toolProtocol.createStreamFilter(this.toolRegistry.all().map((t) => t.name));
         const requestParams = {

package/dist/agent/skills.d.ts

@@ -9,7 +9,9 @@ export declare function discoverGlobalSkills(): Skill[];
 export declare function invalidateGlobalSkillsCache(): void;
 /**
  * Discover project-level skills from .agents/skills/ in cwd hierarchy.
- * Scans from cwd up to git root.
+ * Walks from cwd up to $HOME (or filesystem root if cwd is outside HOME).
+ * Git boundaries are ignored — nested repos under a skills-bearing parent
+ * would otherwise hide the parent's skills.
  */
 export declare function discoverProjectSkills(cwd: string): Skill[];
 /**

package/dist/agent/skills.js

@@ -93,22 +93,6 @@ function scanDir(dir) {
     }
     return skills;
 }
-/** Find the git root from a directory. */
-function findGitRoot(dir) {
-    let current = path.resolve(dir);
-    while (true) {
-        try {
-            fs.accessSync(path.join(current, ".git"));
-            return current;
-        }
-        catch {
-            const parent = path.dirname(current);
-            if (parent === current)
-                return null;
-            current = parent;
-        }
-    }
-}
 /** Expand ~ to home directory. */
 function expandHome(p) {
     if (p.startsWith("~/") || p === "~") {
@@ -146,16 +130,18 @@ export function invalidateGlobalSkillsCache() {
 }
 /**
  * Discover project-level skills from .agents/skills/ in cwd hierarchy.
- * Scans from cwd up to git root.
+ * Walks from cwd up to $HOME (or filesystem root if cwd is outside HOME).
+ * Git boundaries are ignored — nested repos under a skills-bearing parent
+ * would otherwise hide the parent's skills.
  */
 export function discoverProjectSkills(cwd) {
     const seen = new Set();
     const skills = [];
-    const gitRoot = findGitRoot(cwd);
+    const home = path.resolve(os.homedir());
     let current = path.resolve(cwd);
     while (true) {
         addUnique(skills, scanDir(path.join(current, ".agents", "skills")), seen);
-        if (gitRoot && current === gitRoot)
+        if (current === home)
             break;
         const parent = path.dirname(current);
         if (parent === current)

package/dist/agent/subagent.js

@@ -1,4 +1,5 @@
 import { ConversationState } from "./conversation-state.js";
+import { wrapTrailingWithDynamicContext } from "../utils/message-utils.js";
 /**
  * Run a subagent to completion.
  * Returns the final response text.
@@ -99,15 +100,11 @@ async function streamOnce(llmClient, systemPrompt, conversation, apiTools, model
     const reasoningDetailsByIndex = new Map();
     const pendingToolCalls = [];
     let usage = null;
-    const messages = [
-        { role: "system", content: systemPrompt },
-    ];
-    if (dynamicContext) {
-        messages.push({ role: "user", content: `<context>\n${dynamicContext}\n</context>` });
-        messages.push({ role: "assistant", content: "Understood." });
-    }
     const stream = await llmClient.stream({
-        messages: [...messages, ...conversation.getMessages()],
+        messages: [
+            { role: "system", content: systemPrompt },
+            ...wrapTrailingWithDynamicContext(conversation.getMessages(), dynamicContext ?? ""),
+        ],
         tools: apiTools.length > 0 ? apiTools : undefined,
         model,
         signal,

package/dist/agent/system-prompt.d.ts

@@ -1,4 +1,3 @@
-import type { ContextManager } from "../context-manager.js";
 import { type Skill } from "./skills.js";
 /**
  * Format skills for inline display in prompt.
@@ -12,35 +11,9 @@ export declare function loadGlobalAgentsMd(): string | null;
  * Contains only identity and behavioral instructions.
  */
 export declare const STATIC_SYSTEM_PROMPT: string;
-/**
- * Build the dynamic context — injected as a user message before each query.
- * Contains everything that changes: shell context, conventions, cwd.
- *
- * Runs through the "dynamic-context:build" handler so extensions can advise.
- */
-export interface TokenStatus {
-    /** Estimated prompt tokens (API-grounded when available, else chars/4). */
-    promptTokens: number;
-    /** Model's context window in tokens. */
-    contextWindow: number;
-}
 /**
  * CWD-scoped static context: project conventions (CLAUDE.md / AGENT.md)
  * and discovered skills. Stable for a given cwd — callers should cache
  * on cwd identity rather than rebuilding per LLM iteration.
  */
 export declare function buildStaticByCwd(cwd: string): string;
-/**
- * Per-iteration dynamic context: date, working directory, token usage.
- * Rebuilt every LLM call. Extension advisors add more sections (budget,
- * subagents, metacognitive signals, etc.) on top.
- *
- * Skills, AGENTS.md, and project conventions live in the system prompt
- * (see `system-prompt:build` in agent-loop) so they enter the provider's
- * prefix cache instead of being rebuilt and re-sent every turn.
- *
- * Shell context is likewise not injected here — it flows into the
- * conversation as incremental <shell-events> messages (see
- * AgentLoop.injectShellDelta) for the same reason.
- */
-export declare function buildDynamicContext(contextManager: ContextManager, tokenStatus: TokenStatus): string;

package/dist/agent/system-prompt.js

@@ -107,6 +107,11 @@ Extensions may register additional tools — follow their instructions.
 - Keep bash commands focused; avoid long-running blocking commands
 - Always check command exit codes for errors
 
+# Context Envelopes
+- \`<query_context>\` (e.g. \`<shell_events>\`): the user's situation when they sent this turn — ground "fix this" / "what just happened" requests with it.
+- \`<dynamic_context>\`: current system state — in-flight work, mode markers, warnings.
+Either may be absent on any turn.
+
 # Preference Learning
 
 Treat the user's past commands as standing preferences. Before acting, check shell history
@@ -130,27 +135,3 @@ export function buildStaticByCwd(cwd) {
     }
     return sections.join("\n\n");
 }
-/**
- * Per-iteration dynamic context: date, working directory, token usage.
- * Rebuilt every LLM call. Extension advisors add more sections (budget,
- * subagents, metacognitive signals, etc.) on top.
- *
- * Skills, AGENTS.md, and project conventions live in the system prompt
- * (see `system-prompt:build` in agent-loop) so they enter the provider's
- * prefix cache instead of being rebuilt and re-sent every turn.
- *
- * Shell context is likewise not injected here — it flows into the
- * conversation as incremental <shell-events> messages (see
- * AgentLoop.injectShellDelta) for the same reason.
- */
-export function buildDynamicContext(contextManager, tokenStatus) {
-    const envLines = [
-        `Current date: ${new Date().toISOString().split("T")[0]}`,
-        `Working directory: ${contextManager.getCwd()}`,
-    ];
-    const usedK = (tokenStatus.promptTokens / 1000).toFixed(1);
-    const maxK = (tokenStatus.contextWindow / 1000).toFixed(0);
-    const pct = Math.min(100, Math.round((tokenStatus.promptTokens / tokenStatus.contextWindow) * 100));
-    envLines.push(`Token usage: ${usedK}k/${maxK}k (${pct}%)`);
-    return `<environment>\n${envLines.join("\n")}\n</environment>`;
-}

package/dist/core.d.ts

@@ -1,9 +1,10 @@
 /**
  * Core kernel — the minimum viable agent-sh.
  *
- * Wires up EventBus + ContextManager without any frontend or agent backend.
+ * Wires up EventBus + HandlerRegistry without any frontend or agent backend.
  * Consumers attach their own I/O (Shell, WebSocket, REST, tests) by
- * subscribing to bus events.
+ * subscribing to bus events. Shell-specific tracking lives in the
+ * shell-context built-in extension.
  *
  * Agent backends are loaded as extensions and register themselves via
  * the agent:register-backend bus event. The built-in "ash" backend is
@@ -17,7 +18,6 @@
  *   const response = await core.query("hello");
  */
 import { EventBus } from "./event-bus.js";
-import { ContextManager } from "./context-manager.js";
 import type { AgentShellConfig, ExtensionContext } from "./types.js";
 import { HandlerRegistry } from "./utils/handler-registry.js";
 export { EventBus } from "./event-bus.js";
@@ -32,7 +32,6 @@ export { HistoryFile, InMemoryHistory, NoopHistory, type HistoryAdapter } from "
 export type { NuclearEntry } from "./agent/nuclear-form.js";
 export interface AgentShellCore {
     bus: EventBus;
-    contextManager: ContextManager;
     /** Handler registry for define/advise/call. */
     handlers: HandlerRegistry;
     /** Unique id for this agent process; used for shell-marker tagging and lineage tracking. */

package/dist/core.js

@@ -1,9 +1,10 @@
 /**
  * Core kernel — the minimum viable agent-sh.
  *
- * Wires up EventBus + ContextManager without any frontend or agent backend.
+ * Wires up EventBus + HandlerRegistry without any frontend or agent backend.
  * Consumers attach their own I/O (Shell, WebSocket, REST, tests) by
- * subscribing to bus events.
+ * subscribing to bus events. Shell-specific tracking lives in the
+ * shell-context built-in extension.
  *
  * Agent backends are loaded as extensions and register themselves via
  * the agent:register-backend bus event. The built-in "ash" backend is
@@ -17,17 +18,15 @@
  *   const response = await core.query("hello");
  */
 import { EventBus } from "./event-bus.js";
-import { ContextManager } from "./context-manager.js";
 import { createLlmFacade } from "./utils/llm-facade.js";
 import { setPalette } from "./utils/palette.js";
 import * as streamTransform from "./utils/stream-transform.js";
 import * as settingsMod from "./settings.js";
 import { HandlerRegistry } from "./utils/handler-registry.js";
-import { TerminalBuffer } from "./utils/terminal-buffer.js";
 import crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { DefaultCompositor, StdoutSurface } from "./utils/compositor.js";
+import { DefaultCompositor } from "./utils/compositor.js";
 import { CONFIG_DIR } from "./settings.js";
 // Re-export types that library consumers need
 export { EventBus } from "./event-bus.js";
@@ -38,7 +37,6 @@ export { HistoryFile, InMemoryHistory, NoopHistory } from "./agent/history-file.
 export function createCore(config) {
     const bus = new EventBus();
     const handlers = new HandlerRegistry();
-    const contextManager = new ContextManager(bus, handlers);
     // 3 bytes = 6 hex chars, ~16M values — ample for per-lineage uniqueness and
     // short enough to read/remember. Legacy content may have 16-char iids; any
     // parsers should accept ≥6 hex chars.
@@ -48,6 +46,14 @@ export function createCore(config) {
     // Expose raw CLI config so the agent backend extension can resolve
     // providers and create the LLM client.
     handlers.define("config:get-shell-config", () => config);
+    // Default; shell-context advises with the PTY-tracked cwd when loaded.
+    handlers.define("cwd", () => process.cwd());
+    // Empty defaults so registerContextProducer can advise regardless of
+    // backend. Each backend chooses whether to consume the strings — ash
+    // wraps them in <dynamic_context>/<query_context>; bridges may pull
+    // query-context:build and splice into the target SDK however they like.
+    handlers.define("dynamic-context:build", () => "");
+    handlers.define("query-context:build", () => "");
     const backends = new Map();
     let activeBackendName = null;
     const activateByName = async (name, silent = false) => {
@@ -91,22 +97,12 @@ export function createCore(config) {
         return { names, active: activeBackendName };
     });
     // ── Compositor ──────────────────────────────────────────────
+    // Generic surface-routing primitive. No defaults here — the active
+    // frontend (src/shell/, a web bridge, headless test harness, etc.)
+    // sets its own surfaces during activation.
     const compositor = new DefaultCompositor(bus);
-    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 = () => {
-        if (terminalBufferSingleton !== undefined)
-            return terminalBufferSingleton;
-        terminalBufferSingleton = TerminalBuffer.createWired(bus);
-        return terminalBufferSingleton;
-    };
     return {
         bus,
-        contextManager,
         handlers,
         instanceId,
         activateBackend() {
@@ -162,7 +158,6 @@ export function createCore(config) {
         extensionContext(opts) {
             const ctx = {
                 bus,
-                contextManager,
                 instanceId,
                 llm: createLlmFacade(handlers),
                 providers: {
@@ -186,11 +181,25 @@ export function createCore(config) {
                 removeInstruction: (name) => bus.emit("agent:remove-instruction", { name }),
                 registerSkill: (name, description, filePath) => bus.emit("agent:register-skill", { name, description, filePath, extensionName: "" }),
                 removeSkill: (name) => bus.emit("agent:remove-skill", { name }),
+                registerContextProducer: (_name, producer, opts) => {
+                    const handlerName = opts?.mode === "per-query"
+                        ? "query-context:build"
+                        : "dynamic-context:build";
+                    return handlers.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;
+                    });
+                },
                 define: (name, fn) => handlers.define(name, fn),
                 advise: (name, wrapper) => handlers.advise(name, wrapper),
                 call: (name, ...args) => handlers.call(name, ...args),
                 list: () => handlers.list(),
-                get terminalBuffer() { return getTerminalBuffer(); },
                 compositor,
                 onDispose: () => { },
                 createRemoteSession: (opts) => {
@@ -214,12 +223,6 @@ export function createCore(config) {
                     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; },

package/dist/executor.d.ts

@@ -1,4 +1,8 @@
 import { type ChildProcess } from "node:child_process";
+/** Resolve a usable bash binary, or null if none is on PATH.
+ *  Unix: `/bin/bash` (canonical, present on every Linux/macOS install).
+ *  Windows: probe via `where bash` so Git Bash users keep working. */
+export declare function findBash(): string | null;
 export interface ExecutorSession {
     id: string;
     command: string;

package/dist/executor.js

@@ -1,5 +1,20 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { stripAnsi } from "./utils/ansi.js";
+let cachedBashPath;
+/** Resolve a usable bash binary, or null if none is on PATH.
+ *  Unix: `/bin/bash` (canonical, present on every Linux/macOS install).
+ *  Windows: probe via `where bash` so Git Bash users keep working. */
+export function findBash() {
+    if (cachedBashPath !== undefined)
+        return cachedBashPath;
+    if (process.platform !== "win32") {
+        cachedBashPath = "/bin/bash";
+        return cachedBashPath;
+    }
+    const r = spawnSync("where", ["bash"], { encoding: "utf-8" });
+    cachedBashPath = r.status === 0 ? r.stdout.split(/\r?\n/)[0].trim() || null : null;
+    return cachedBashPath;
+}
 const DEFAULT_TIMEOUT = 60_000;
 const DEFAULT_MAX_OUTPUT = 256 * 1024; // 256KB
 /**
@@ -29,9 +44,12 @@ export function executeCommand(opts) {
         if (v !== undefined)
             env[k] = v;
     }
+    const bashPath = findBash();
     let child;
     try {
-        child = spawn("/bin/bash", ["-c", opts.command], {
+        if (!bashPath)
+            throw new Error("bash not found on PATH");
+        child = spawn(bashPath, ["-c", opts.command], {
             stdio: ["ignore", "pipe", "pipe"],
             cwd: opts.cwd,
             env,

package/dist/extension-loader.js

@@ -73,6 +73,12 @@ function createScopedContext(ctx, extensionName) {
         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 });
@@ -93,6 +99,7 @@ function createScopedContext(ctx, extensionName) {
         removeInstruction: ctx.removeInstruction,
         registerSkill: scopedRegisterSkill,
         removeSkill: ctx.removeSkill,
+        registerContextProducer: scopedRegisterContextProducer,
         registerTool: scopedRegisterTool,
         unregisterTool: ctx.unregisterTool,
         registerCommand: scopedRegisterCommand,

package/dist/extensions/agent-backend.js

@@ -67,7 +67,6 @@ export default function agentBackend(ctx) {
     // would hit a no-op stub.
     const agentLoop = new AgentLoop({
         bus,
-        contextManager: ctx.contextManager,
         llmClient,
         handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call, list: ctx.list },
         modes,

package/dist/extensions/file-autocomplete.d.ts

@@ -1,2 +1,2 @@
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, contextManager }: ExtensionContext): void;
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/file-autocomplete.js

@@ -7,8 +7,8 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-export default function activate({ bus, contextManager }) {
-    bus.onPipe("autocomplete:request", (payload) => {
+export default function activate(ctx) {
+    ctx.bus.onPipe("autocomplete:request", (payload) => {
         const atPos = payload.buffer.lastIndexOf("@");
         if (atPos < 0 || (atPos > 0 && payload.buffer[atPos - 1] !== " ")) {
             return payload;
@@ -17,7 +17,7 @@ export default function activate({ bus, contextManager }) {
         if (afterAt.includes(" ") || !/^[a-zA-Z0-9_.\/-]*$/.test(afterAt)) {
             return payload;
         }
-        const files = listFiles(afterAt, contextManager.getCwd());
+        const files = listFiles(afterAt, ctx.call("cwd"));
         if (files.length === 0)
             return payload;
         return { ...payload, items: [...payload.items, ...files] };

package/dist/extensions/index.d.ts

@@ -4,6 +4,10 @@
  * These extensions ship with agent-sh and load before user extensions.
  * They receive unscoped contexts (not reloadable) and can be individually
  * disabled via the `disabledBuiltins` setting in ~/.agent-sh/settings.json.
+ *
+ * For order-critical frontend bootstrap (the PTY shell), see `src/shell/`.
+ * That module exposes its own `activate(ctx, opts)` entry point, loaded
+ * specially from `src/index.ts` rather than through this manifest.
  */
 import type { ExtensionContext } from "../types.js";
 type ActivateFn = (ctx: ExtensionContext) => void;

package/dist/extensions/index.js

@@ -1,4 +1,5 @@
 export const BUILTIN_EXTENSIONS = [
+    { name: "shell-context", load: () => import("./shell-context.js").then(m => m.default) },
     { name: "agent-backend", load: () => import("./agent-backend.js").then(m => m.default) },
     { name: "openrouter",
         when: () => !!process.env.OPENROUTER_API_KEY,

package/dist/extensions/shell-context.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tracks PTY commands and cwd, spills long outputs, contributes the
+ * `<shell_events>` per-query envelope. Frontends without a PTY skip this
+ * built-in and the agent runs cwd-aware via core's process.cwd() default.
+ */
+import type { ExtensionContext } from "../types.js";
+export default function activate(ctx: ExtensionContext): void;