agent-sh 0.12.2 → 0.12.4

package/dist/agent/agent-loop.js

@@ -297,6 +297,18 @@ export class AgentLoop {
             recallArchiveSize: this.conversation.getRecallArchiveSize(),
             budgetTokens: this.currentMode.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
         }));
+        this.bus.onPipe("context:snapshot", (payload) => {
+            payload.messages = this.conversation.getMessages();
+            payload.contextWindow = this.currentMode.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+            payload.activeTokens = this.conversation.estimateTokens();
+            return payload;
+        });
+        this.bus.onPipeAsync("context:compact", async (payload) => {
+            const stats = await this.compactWithHooks(0, undefined, false, payload.strategy);
+            if (stats)
+                payload.stats = { before: stats.before, after: stats.after, evictedCount: stats.evictedCount };
+            return payload;
+        });
         // Prior-session preamble (non-blocking). Both the read and the
         // layout go through advisable handlers.
         Promise.resolve(this.handlers.call("history:read-recent"))
@@ -469,11 +481,12 @@ export class AgentLoop {
      * compaction, emit `conversation:after-compact` so listeners
      * (metrics, UI, agent-awareness notes) can react.
      */
-    compactWithHooks(target, keepRecent, force) {
+    compactWithHooks(target, keepRecent, force, strategy) {
         const stats = this.handlers.call("conversation:compact", {
             target,
             keepRecent,
             force: !!force,
+            strategy,
         });
         if (stats) {
             this.bus.emit("conversation:after-compact", {
@@ -819,7 +832,24 @@ export class AgentLoop {
         // Compaction strategy — default delegates to the two-tier pin
         // strategy in ConversationState; advisors replace wholesale.
         h.define("conversation:compact", (opts) => {
-            return this.conversation.compact(opts.target, opts.keepRecent, opts.force);
+            const strategy = opts.strategy;
+            // Synthesize a CompactResult for manual edits so conversation:after-compact
+            // listeners (metrics, file-read cache, system-prompt cache) still run.
+            if (strategy?.kind === "rewind" || strategy?.kind === "replace") {
+                const before = this.conversation.estimatePromptTokens();
+                const beforeLen = this.conversation.getMessages().length;
+                const next = strategy.kind === "rewind"
+                    ? this.conversation.getMessages().slice(0, strategy.toIndex)
+                    : strategy.messages;
+                this.conversation.replaceMessages(next);
+                const after = this.conversation.estimatePromptTokens();
+                const afterLen = this.conversation.getMessages().length;
+                return { before, after, evictedCount: Math.max(0, beforeLen - afterLen) };
+            }
+            const tgt = strategy?.kind === "two-tier-pin" ? strategy.target : opts.target;
+            const keep = strategy?.kind === "two-tier-pin" ? strategy.keepRecent : opts.keepRecent;
+            const force = strategy?.kind === "two-tier-pin" ? strategy.force : opts.force;
+            return this.conversation.compact(tgt, keep, force);
         });
         // Inject a system note mid-loop — used by extensions (subagents,
         // peer messages) to deliver async results into the next iteration.
@@ -1599,12 +1629,15 @@ export class AgentLoop {
                 tc.argumentsJson = "{}";
             }
         }
+        // Echo reasoning only for modes that opt in (e.g. DeepSeek-R1).
         const extras = {};
-        if (reasoning && reasoningField)
-            extras[reasoningField] = reasoning;
-        if (reasoningDetailsByIndex.size > 0) {
-            extras.reasoning_details = [...reasoningDetailsByIndex.entries()]
-                .sort((a, b) => a[0] - b[0]).map(([, v]) => v);
+        if (this.currentMode.echoReasoning) {
+            if (reasoning && reasoningField)
+                extras[reasoningField] = reasoning;
+            if (reasoningDetailsByIndex.size > 0) {
+                extras.reasoning_details = [...reasoningDetailsByIndex.entries()]
+                    .sort((a, b) => a[0] - b[0]).map(([, v]) => v);
+            }
         }
         return {
             text,

package/dist/agent/skills.js

@@ -13,7 +13,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-import { getSettings } from "../settings.js";
+import { CONFIG_DIR, getSettings } from "../settings.js";
 /** Parse YAML frontmatter from a SKILL.md file. */
 function parseFrontmatter(content) {
     const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
@@ -133,7 +133,7 @@ export function discoverGlobalSkills() {
         return _cachedGlobalSkills;
     const seen = new Set();
     const skills = [];
-    addUnique(skills, scanDir(path.join(os.homedir(), ".agent-sh", "skills")), seen);
+    addUnique(skills, scanDir(path.join(CONFIG_DIR, "skills")), seen);
     const settings = getSettings();
     for (const p of settings.skillPaths ?? []) {
         addUnique(skills, scanDir(path.resolve(expandHome(p))), seen);

package/dist/agent/system-prompt.js

@@ -14,9 +14,8 @@ export function formatSkillsBlock(skills) {
         + "Load a skill's full content with read_file on its file path when needed.\n\n"
         + skills.map(s => `- **${s.name}**: ${s.description}\n  Path: ${s.filePath}`).join("\n\n");
 }
-// Resolve to the user's home-based config dir — user's standing instructions to the agent
-import * as os from "node:os";
-const GLOBAL_AGENTS_MD = path.join(os.homedir(), ".agent-sh", "AGENTS.md");
+import { CONFIG_DIR } from "../settings.js";
+const GLOBAL_AGENTS_MD = path.join(CONFIG_DIR, "AGENTS.md");
 // ── File caches ─────────────────────────────────────────────────────
 // Convention files (CLAUDE.md/AGENT.md) are walked synchronously from
 // CWD to root on every query. In practice they almost never change,

package/dist/core.js

@@ -27,9 +27,8 @@ 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 * as os from "node:os";
 import { DefaultCompositor, StdoutSurface } from "./utils/compositor.js";
-const STORAGE_ROOT = path.join(os.homedir(), ".agent-sh");
+import { CONFIG_DIR } from "./settings.js";
 // Re-export types that library consumers need
 export { EventBus } from "./event-bus.js";
 export { palette, setPalette, resetPalette } from "./utils/palette.js";
@@ -43,6 +42,7 @@ export function createCore(config) {
     // short enough to read/remember. Legacy content may have 16-char iids; any
     // parsers should accept ≥6 hex chars.
     const instanceId = crypto.randomBytes(3).toString("hex");
+    bus.setSource(instanceId);
     const settings = settingsMod.getSettings();
     // Expose raw CLI config so the agent backend extension can resolve
     // providers and create the LLM client.
@@ -170,7 +170,7 @@ export function createCore(config) {
                 createFencedBlockTransform: (o) => streamTransform.createFencedBlockTransform(bus, o),
                 getExtensionSettings: settingsMod.getExtensionSettings,
                 getStoragePath: (namespace) => {
-                    const dir = path.join(STORAGE_ROOT, namespace);
+                    const dir = path.join(CONFIG_DIR, namespace);
                     fs.mkdirSync(dir, { recursive: true });
                     return dir;
                 },
@@ -188,6 +188,7 @@ export function createCore(config) {
                 list: () => handlers.list(),
                 get terminalBuffer() { return getTerminalBuffer(); },
                 compositor,
+                onDispose: () => { },
                 createRemoteSession: (opts) => {
                     const { surface } = opts;
                     const cleanups = [];

package/dist/event-bus.d.ts

@@ -233,6 +233,30 @@ export interface ShellEvents {
         totalTokens: number;
         budgetTokens: number;
     };
+    "context:snapshot": {
+        messages: unknown[];
+        contextWindow: number;
+        activeTokens: number;
+    };
+    "context:compact": {
+        strategy?: {
+            kind: "two-tier-pin";
+            target: number;
+            keepRecent?: number;
+            force?: boolean;
+        } | {
+            kind: "rewind";
+            toIndex: number;
+        } | {
+            kind: "replace";
+            messages: unknown[];
+        };
+        stats?: {
+            before: number;
+            after: number;
+            evictedCount: number;
+        };
+    };
     "agent:register-backend": {
         name: string;
         kill: () => void;
@@ -291,6 +315,7 @@ export interface ShellEvents {
             id: string;
             reasoning?: boolean;
             contextWindow?: number;
+            echoReasoning?: boolean;
         })[];
         /** Provider supports the reasoning_effort parameter. Default: true. */
         supportsReasoningEffort?: boolean;
@@ -357,6 +382,14 @@ export type ContentBlock = {
 type Listener<T> = (payload: T) => void;
 type PipeListener<T> = (payload: T) => T;
 type AsyncPipeListener<T> = (payload: T) => T | Promise<T>;
+/** Envelope stamped on every emitted event. */
+export interface BusMeta {
+    source: string;
+    ts: number;
+    id: string;
+    name: string;
+}
+export type AnyListener = (name: string, payload: unknown, meta: BusMeta) => void;
 /**
  * Typed event bus with two modes:
  * - emit/on/off: fire-and-forget notifications
@@ -367,12 +400,25 @@ export declare class EventBus {
     private emitter;
     private pipeListeners;
     private asyncPipeListeners;
+    private source;
+    private nextSeq;
+    private anyListeners;
+    /** Set the source id stamped onto every emitted event. */
+    setSource(src: string): void;
+    /** Subscribe to every emitted event with full envelope. Returns unsubscribe. */
+    onAny(fn: AnyListener): () => void;
+    /** Stamp + dispatch — used by every emit path. */
+    private dispatch;
     /** Subscribe to a fire-and-forget event. */
     on<K extends keyof ShellEvents>(event: K, fn: Listener<ShellEvents[K]>): void;
     /** Unsubscribe from a fire-and-forget event. */
     off<K extends keyof ShellEvents>(event: K, fn: Listener<ShellEvents[K]>): void;
     /** Emit a fire-and-forget event. */
     emit<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): void;
+    /** Re-dispatch an event with externally-supplied meta. Used by bridges
+     *  and replay tools to preserve the original source/ts/id of remote or
+     *  recorded events instead of restamping them as locally originated. */
+    relay(meta: BusMeta, payload: unknown): void;
     /**
      * Transform-then-notify: run the payload through any registered pipe
      * listeners (transforms), then emit the final result to regular `on`

package/dist/event-bus.js

@@ -9,6 +9,40 @@ export class EventBus {
     emitter = new EventEmitter().setMaxListeners(0);
     pipeListeners = new Map();
     asyncPipeListeners = new Map();
+    source = "0000";
+    nextSeq = 0;
+    anyListeners = [];
+    /** Set the source id stamped onto every emitted event. */
+    setSource(src) {
+        this.source = src;
+    }
+    /** Subscribe to every emitted event with full envelope. Returns unsubscribe. */
+    onAny(fn) {
+        this.anyListeners.push(fn);
+        return () => {
+            const i = this.anyListeners.indexOf(fn);
+            if (i !== -1)
+                this.anyListeners.splice(i, 1);
+        };
+    }
+    /** Stamp + dispatch — used by every emit path. */
+    dispatch(name, payload) {
+        if (this.anyListeners.length > 0) {
+            const meta = {
+                source: this.source,
+                ts: Date.now(),
+                id: `${this.source}:${this.nextSeq++}`,
+                name,
+            };
+            for (const fn of this.anyListeners) {
+                try {
+                    fn(name, payload, meta);
+                }
+                catch { /* swallow */ }
+            }
+        }
+        this.emitter.emit(name, payload);
+    }
     /** Subscribe to a fire-and-forget event. */
     on(event, fn) {
         this.emitter.on(event, fn);
@@ -19,7 +53,21 @@ export class EventBus {
     }
     /** Emit a fire-and-forget event. */
     emit(event, payload) {
-        this.emitter.emit(event, payload);
+        this.dispatch(event, payload);
+    }
+    /** Re-dispatch an event with externally-supplied meta. Used by bridges
+     *  and replay tools to preserve the original source/ts/id of remote or
+     *  recorded events instead of restamping them as locally originated. */
+    relay(meta, payload) {
+        if (this.anyListeners.length > 0) {
+            for (const fn of this.anyListeners) {
+                try {
+                    fn(meta.name, payload, meta);
+                }
+                catch { /* swallow */ }
+            }
+        }
+        this.emitter.emit(meta.name, payload);
     }
     /**
      * Transform-then-notify: run the payload through any registered pipe
@@ -38,7 +86,7 @@ export class EventBus {
             }
             transformed = payload; // fall back to untransformed
         }
-        this.emitter.emit(event, transformed);
+        this.dispatch(event, transformed);
     }
     /** Register a transform listener for a pipeline event. */
     onPipe(event, fn) {
@@ -103,7 +151,7 @@ export class EventBus {
      */
     async emitPipeAsync(event, payload) {
         // Phase 1: notify (lets renderers prepare for interactive I/O)
-        this.emitter.emit(event, payload);
+        this.dispatch(event, payload);
         // Phase 2: transform (extensions provide decisions)
         const listeners = this.asyncPipeListeners.get(event);
         if (!listeners)

package/dist/extension-loader.js

@@ -96,6 +96,7 @@ function createScopedContext(ctx, extensionName) {
         registerTool: scopedRegisterTool,
         unregisterTool: ctx.unregisterTool,
         registerCommand: scopedRegisterCommand,
+        onDispose: (fn) => { cleanups.push(fn); },
     };
     const dispose = () => {
         for (const fn of cleanups) {

package/dist/extensions/agent-backend.js

@@ -32,6 +32,7 @@ export default function agentBackend(ctx) {
                     contextWindow: mc?.contextWindow ?? p.contextWindow,
                     reasoning: mc?.reasoning,
                     supportsReasoningEffort: p.supportsReasoningEffort,
+                    echoReasoning: mc?.echoReasoning,
                 });
             }
         }
@@ -135,7 +136,7 @@ export default function agentBackend(ctx) {
             }
             else {
                 modelIds.push(m.id);
-                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, echoReasoning: m.echoReasoning });
             }
         }
         providerRegistry.set(p.id, {
@@ -156,6 +157,7 @@ export default function agentBackend(ctx) {
                 contextWindow: mc?.contextWindow,
                 reasoning: mc?.reasoning,
                 supportsReasoningEffort: p.supportsReasoningEffort,
+                echoReasoning: mc?.echoReasoning,
             };
         });
         bus.emit("config:add-modes", { modes: addModes });
@@ -197,6 +199,7 @@ export default function agentBackend(ctx) {
                 contextWindow: mc?.contextWindow ?? p.contextWindow,
                 reasoning: mc?.reasoning,
                 supportsReasoningEffort: p.supportsReasoningEffort,
+                echoReasoning: mc?.echoReasoning,
             };
         });
         bus.emit("config:set-modes", { modes: newModes });

package/dist/extensions/openrouter.js

@@ -1,5 +1,11 @@
+import { getSettings } from "../settings.js";
 const BASE_URL = "https://openrouter.ai/api/v1";
 const DEFAULT_MODELS = ["anthropic/claude-sonnet-4.6"];
+// Built-in defaults for models requiring reasoning_content echoed back
+// (server 400s without it). Extend or override in settings.json:
+//   providers.openrouter.echoReasoningPatterns = ["deepseek", "..."]
+//   providers.openrouter.models[*].echoReasoning = true | false
+const BUILTIN_ECHO_REASONING_PATTERNS = [/deepseek/i];
 export default function activate(ctx) {
     const apiKey = process.env.OPENROUTER_API_KEY;
     if (!apiKey)
@@ -14,6 +20,8 @@ export default function activate(ctx) {
     fetchModels(apiKey).then((models) => {
         if (models.length === 0)
             return;
+        const userOverrides = readUserOverrides();
+        const patterns = readEchoPatterns();
         ctx.bus.emit("provider:register", {
             id: "openrouter",
             apiKey,
@@ -24,10 +32,34 @@ export default function activate(ctx) {
                 id: m.id,
                 reasoning: m.supported_parameters?.includes("reasoning") ?? false,
                 contextWindow: m.context_length,
+                echoReasoning: userOverrides.get(m.id) ?? patterns.some((re) => re.test(m.id)),
             })),
         });
     }).catch(() => { });
 }
+function readEchoPatterns() {
+    const userPatterns = getSettings().providers?.openrouter?.echoReasoningPatterns ?? [];
+    const compiled = [];
+    for (const src of userPatterns) {
+        try {
+            compiled.push(new RegExp(src, "i"));
+        }
+        catch { /* skip invalid pattern */ }
+    }
+    return [...BUILTIN_ECHO_REASONING_PATTERNS, ...compiled];
+}
+function readUserOverrides() {
+    const out = new Map();
+    const models = getSettings().providers?.openrouter?.models;
+    if (!Array.isArray(models))
+        return out;
+    for (const m of models) {
+        if (typeof m === "object" && m && m.echoReasoning !== undefined) {
+            out.set(m.id, m.echoReasoning);
+        }
+    }
+    return out;
+}
 async function fetchModels(apiKey) {
     const res = await fetch(`${BASE_URL}/models`, {
         headers: { Authorization: `Bearer ${apiKey}` },

package/dist/init.js

@@ -1,7 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
-const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+import { CONFIG_DIR } from "./settings.js";
 const EXTENSIONS_DIR = path.join(CONFIG_DIR, "extensions");
 const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const EXAMPLE_PATH = path.join(CONFIG_DIR, "settings.example.json");

package/dist/settings.d.ts

@@ -1,3 +1,5 @@
+/** Root config directory. Override via AGENT_SH_HOME for isolated instances
+ *  (testing, multi-agent setups). Path is resolved at module load. */
 export declare const CONFIG_DIR: string;
 /** Per-model capability overrides. */
 export interface ModelCapabilityConfig {
@@ -7,6 +9,8 @@ export interface ModelCapabilityConfig {
     reasoning?: boolean;
     /** Context window size in tokens for this specific model. */
     contextWindow?: number;
+    /** Echo reasoning_content back on assistant turns. Required by DeepSeek. */
+    echoReasoning?: boolean;
 }
 /** Provider profile — a named LLM configuration. */
 export interface ProviderConfig {
@@ -20,6 +24,9 @@ export interface ProviderConfig {
     models?: (string | ModelCapabilityConfig)[];
     /** Context window size in tokens (e.g. 128000). Used for usage display. */
     contextWindow?: number;
+    /** Case-insensitive regex sources matched against model id; matches default
+     *  to echoReasoning=true. Per-model echoReasoning still wins. */
+    echoReasoningPatterns?: string[];
 }
 export interface Settings {
     /** Extensions to load (npm packages or file paths). */
@@ -136,6 +143,7 @@ export interface ResolvedProvider {
     modelCapabilities?: Map<string, {
         reasoning?: boolean;
         contextWindow?: number;
+        echoReasoning?: boolean;
     }>;
 }
 /**

package/dist/settings.js

@@ -7,7 +7,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-export const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+/** Root config directory. Override via AGENT_SH_HOME for isolated instances
+ *  (testing, multi-agent setups). Path is resolved at module load. */
+export const CONFIG_DIR = process.env.AGENT_SH_HOME
+    ? path.resolve(process.env.AGENT_SH_HOME)
+    : path.join(os.homedir(), ".agent-sh");
 const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const DEFAULTS = {
     extensions: [],
@@ -143,8 +147,8 @@ export function resolveProvider(name) {
         }
         else {
             modelIds.push(m.id);
-            if (m.reasoning !== undefined || m.contextWindow !== undefined) {
-                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
+            if (m.reasoning !== undefined || m.contextWindow !== undefined || m.echoReasoning !== undefined) {
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, echoReasoning: m.echoReasoning });
             }
         }
     }

package/dist/shell/input-handler.d.ts

@@ -1,9 +1,6 @@
 import type { EventBus } from "../event-bus.js";
-/**
- * Narrow contract between InputHandler and its host (Shell).
- * InputHandler never touches the PTY or EventBus directly —
- * it goes through this interface for all cross-cutting concerns.
- */
+import { TuiInputView } from "./tui-input-view.js";
+/** Narrow contract between InputHandler and its host (Shell). */
 export interface InputContext {
     isForegroundBusy(): boolean;
     getCwd(): string;
@@ -13,6 +10,7 @@ export interface InputContext {
     redrawPrompt(): void;
     freshPrompt(): void;
 }
+/** Line editor + shell-passthrough buffer. Delegates rendering to TuiInputView. */
 export declare class InputHandler {
     private ctx;
     private lineBuffer;
@@ -24,15 +22,13 @@ export declare class InputHandler {
     private autocompleteActive;
     private autocompleteIndex;
     private autocompleteItems;
-    private autocompleteLines;
     private history;
     private historyIndex;
     private savedBuffer;
-    private cursorRowsBelow;
-    private cursorTermCol;
     private escapeTimer;
     private bus;
     private onShowAgentInfo;
+    private view;
     constructor(opts: {
         ctx: InputContext;
         bus: EventBus;
@@ -40,29 +36,23 @@ export declare class InputHandler {
             info: string;
             model?: string;
         };
+        view?: TuiInputView;
     });
     private registerMode;
     private loadHistory;
     private saveHistory;
-    /** Write the mode prompt line with cursor at the correct position. */
-    private writeModePromptLine;
+    private drawPrompt;
     handleInput(data: string): void;
     private enterMode;
     private exitMode;
-    /** Move to the start of the prompt area and clear everything below. */
-    private clearPromptArea;
     printPrompt(): void;
-    /**
-     * Called when agent processing completes. Returns true if the input
-     * handler re-entered a mode (so caller should skip shell prompt).
-     */
+    /** Called when agent processing completes. Returns true if the input
+     *  handler re-entered a mode (so caller should skip shell prompt). */
     handleProcessingDone(): boolean;
     private renderModeInput;
     private updateAutocomplete;
-    private renderAutocomplete;
     private applyAutocomplete;
     private dismissAutocomplete;
-    private clearAutocompleteLines;
     private handleModeInput;
     private processModeActions;
 }