agent-sh 0.12.13 → 0.12.15

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,10 +7,11 @@ 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
@@ -89,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;
@@ -598,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)) {
@@ -717,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)
@@ -793,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.
@@ -1032,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);
@@ -1083,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();
@@ -1104,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;
@@ -1519,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/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/agent/tools/pwsh.js

@@ -1,7 +1,30 @@
+import { spawnSync } from "node:child_process";
 import { executeArgv, killSession } from "../../executor.js";
-// Targets PowerShell 7+ (`pwsh`). Legacy `powershell.exe` is intentionally
-// not auto-fallback — its tool surface diverges enough that compatibility
-// shims aren't worth the maintenance.
+let cachedPwshPath;
+/** Resolve a usable PowerShell binary, or null if none is on PATH.
+ *  Prefers PowerShell 7+ (`pwsh`), falls back to Windows PowerShell (`powershell`). */
+function findPwsh() {
+    if (cachedPwshPath !== undefined)
+        return cachedPwshPath;
+    // Prefer PowerShell 7 (pwsh)
+    const pwsh = spawnSync("where", ["pwsh"], { encoding: "utf-8" });
+    if (pwsh.status === 0) {
+        cachedPwshPath = pwsh.stdout.split(/\r?\n/)[0].trim() || null;
+        if (cachedPwshPath)
+            return cachedPwshPath;
+    }
+    // Fallback to Windows PowerShell (powershell.exe)
+    const ps = spawnSync("where", ["powershell"], { encoding: "utf-8" });
+    cachedPwshPath = ps.status === 0 ? ps.stdout.split(/\r?\n/)[0].trim() || null : null;
+    return cachedPwshPath;
+}
+/** Return the PowerShell executable name for display purposes. */
+function getPwshDisplayName() {
+    const path = findPwsh();
+    if (!path)
+        return "PowerShell";
+    return path.toLowerCase().includes("pwsh") ? "pwsh" : "powershell";
+}
 export function createPwshTool(opts) {
     return {
         name: "pwsh",
@@ -54,8 +77,16 @@ export function createPwshTool(opts) {
                     isError: false,
                 };
             }
+            const pwshPath = findPwsh();
+            if (!pwshPath) {
+                return {
+                    content: "PowerShell not found on PATH. Neither pwsh (PowerShell 7+) nor powershell (Windows PowerShell) is available.",
+                    exitCode: 1,
+                    isError: true,
+                };
+            }
             const { session, done } = executeArgv({
-                file: "pwsh",
+                file: pwshPath,
                 args: ["-NoProfile", "-NonInteractive", "-Command", command],
                 cwd: opts.getCwd(),
                 env: opts.getEnv(),
@@ -72,7 +103,7 @@ export function createPwshTool(opts) {
             }
             if (session.spawnFailed) {
                 return {
-                    content: "PowerShell (pwsh) not found on PATH. Install PowerShell 7: winget install Microsoft.PowerShell.",
+                    content: `${getPwshDisplayName()} not found on PATH. Install PowerShell 7: winget install Microsoft.PowerShell.`,
                     exitCode: 1,
                     isError: true,
                 };

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.js

@@ -53,7 +53,8 @@ export function executeCommand(opts) {
             stdio: ["ignore", "pipe", "pipe"],
             cwd: opts.cwd,
             env,
-            detached: true,
+            detached: process.platform !== "win32",
+            windowsHide: true,
         });
     }
     catch (err) {
@@ -214,12 +215,14 @@ export function killSession(session) {
     if (!proc || !proc.pid)
         return () => { };
     // Try process-group kill first (works for executeCommand's detached bash
-    // children); fall back to direct kill (executeArgv's non-detached spawn,
-    // and Windows where negative pids aren't supported).
-    try {
-        process.kill(-proc.pid, "SIGTERM");
+    // children on Unix); fall back to direct kill (executeArgv's non-detached
+    // spawn, and Windows where negative pids aren't supported).
+    if (process.platform !== "win32") {
+        try {
+            process.kill(-proc.pid, "SIGTERM");
+        }
+        catch { }
     }
-    catch { }
     try {
         proc.kill("SIGTERM");
     }
@@ -227,10 +230,12 @@ export function killSession(session) {
     let settled = false;
     const fallback = setTimeout(() => {
         if (!settled && !session.done && proc.pid) {
-            try {
-                process.kill(-proc.pid, "SIGKILL");
+            if (process.platform !== "win32") {
+                try {
+                    process.kill(-proc.pid, "SIGKILL");
+                }
+                catch { }
             }
-            catch { }
             try {
                 proc.kill("SIGKILL");
             }

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;