agent-sh 0.15.6 → 0.15.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yilun Guan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -59,7 +59,7 @@ Once installed, pick a backend below.
 
 ### Option A: Use the built-in agent (ash) — recommended
 
-`ash` is agent-sh's own lightweight agent, and the path most users should start with: it shares its tool surface with the rest of the system, so extensions you install (new tools, content transforms, slash commands, themes) compose with it directly. It works with any OpenAI-compatible API — pick one of the zero-config paths below, no settings file needed. The built-in providers (openrouter, openai, openai-compatible, deepseek) register on startup; ash activates the first one with a usable key.
+`ash` is agent-sh's own lightweight agent, and the path most users should start with: it shares its tool surface with the rest of the system, so extensions you install (new tools, content transforms, slash commands, themes) compose with it directly. It works with any OpenAI-compatible API — pick one of the zero-config paths below, no settings file needed. The built-in providers (openrouter, openai, deepseek, ollama, zai-coding-plan, opencode — plus openai-compatible when `OPENAI_BASE_URL` is set) register on startup; ash activates the first one with a usable key.
 
 **Quickest path** — store a key once via the auth subcommand:
 

package/dist/agent/agent-loop.js

@@ -820,12 +820,9 @@ export class AgentLoop {
                 // tool-heavy workloads.
                 const target = Math.floor(threshold * 0.25);
                 const result = await this.compactWithHooks(target, 1);
-                if (!result) {
-                    // Auto-compact fired but nothing was evictable. This can happen
-                    // in short conversations with heavy tool output where the pin
-                    // fraction consumes all turns. Log it so it's not silent.
+                if (result) {
                     this.bus.emit("ui:info", {
-                        message: `[auto-compact] above threshold (${totalEstimate.toLocaleString()} > ${threshold.toLocaleString()}) but nothing to evict — conversation may be too short`,
+                        message: `(auto-compacted: ~${result.before.toLocaleString()} → ~${result.after.toLocaleString()} tokens, evicted ${result.evictedCount})`,
                     });
                 }
                 cachedSystemPrompt = undefined;

package/dist/agent/extensions/rolling-history/index.js

@@ -102,34 +102,46 @@ export default function activate(ctx) {
     const toolDef = {
         name: TOOL_NAME,
         displayName: "recall",
-        description: "Browse, search, or expand evicted conversation turns. " +
-            "Use when you need context from earlier in the conversation that was compacted away. " +
-            "Search is regex-based and covers both summaries and full body text. " +
-            "If search doesn't find what you expect, try broader/shorter terms or browse to scan the timeline.",
+        description: "Browse, search, or expand the persistent conversation memory — all captured turns across this and recent sessions. " +
+            "Use when you need context from prior turns or past sessions that may no longer be in the active window. " +
+            "Search accepts a regex pattern (e.g. 'foo|bar') and falls back to literal matching if the pattern is invalid. " +
+            "Covers both summaries and full body text. " +
+            "If search doesn't find what you expect, try broader/shorter terms or browse to scan the timeline. " +
+            "Use offset for pagination on both browse and search.",
         input_schema: {
             type: "object",
             properties: {
                 action: {
                     type: "string",
                     enum: ["browse", "search", "expand"],
-                    description: "browse: list evicted turns, search: regex search, expand: show full turn",
+                    description: "browse: list recent captured turns, search: regex search across memory, expand: show full turn body",
                 },
-                query: { type: "string", description: "Search query (for action=search)" },
+                query: { type: "string", description: "Search pattern — a regex (e.g. 'foo|bar') or literal text (for action=search)" },
                 turn_id: { type: "string", description: "Turn ID to expand (for action=expand)" },
+                offset: {
+                    type: "number",
+                    description: "Skip first N results; for browse, start at this entry offset; for search, skip first N hits. Default 0.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max entries to return for browse (default 25) or search (default 30).",
+                },
             },
             required: ["action"],
         },
         execute: async (args) => {
             const action = args.action;
+            const offset = args.offset ?? 0;
+            const limit = args.limit ?? (action === "search" ? 30 : 25);
             let content;
             if (action === "search") {
-                content = await recallSearch(summaryStore, args.query ?? "");
+                content = await recallSearch(summaryStore, args.query ?? "", offset, limit);
             }
             else if (action === "expand") {
                 content = await recallExpand(summaryStore, args.turn_id);
             }
             else {
-                content = await recallBrowse(summaryStore);
+                content = await recallBrowse(summaryStore, offset, limit);
             }
             return { content, exitCode: 0, isError: false };
         },

package/dist/agent/extensions/rolling-history/recall.d.ts

@@ -1,4 +1,4 @@
 import type { Store } from "../../store.js";
-export declare function recallSearch(store: Store, query: string): Promise<string>;
+export declare function recallSearch(store: Store, query: string, offset?: number, maxResults?: number): Promise<string>;
 export declare function recallExpand(store: Store, id: string): Promise<string>;
-export declare function recallBrowse(store: Store, limit?: number): Promise<string>;
+export declare function recallBrowse(store: Store, offset?: number, limit?: number): Promise<string>;

package/dist/agent/extensions/rolling-history/recall.js

@@ -64,7 +64,7 @@ async function findCacheChild(store, parentId) {
     }
     return null;
 }
-export async function recallSearch(store, query) {
+export async function recallSearch(store, query, offset = 0, maxResults = 30) {
     if (!query.trim())
         return "No query provided.";
     const regex = buildSearchRegex(query);
@@ -96,8 +96,12 @@ export async function recallSearch(store, query) {
     if (hits.length === 0)
         return `No results found for "${query}".`;
     const total = hits.length;
-    const summary = `Found ${total} match${total === 1 ? "" : "es"} for "${query}"`;
-    return `${summary}\n\n${hits.slice(0, 30).join("\n\n")}`;
+    const paged = hits.slice(offset, offset + maxResults);
+    const range = offset > 0 || paged.length < total
+        ? ` (showing ${offset + 1}–${offset + paged.length} of ${total})`
+        : "";
+    const summary = `Found ${total} match${total === 1 ? "" : "es"} for "${query}"${range}`;
+    return `${summary}\n\n${paged.join("\n\n")}`;
 }
 export async function recallExpand(store, id) {
     const entry = await store.findById(id);
@@ -114,9 +118,15 @@ export async function recallExpand(store, id) {
         return `${header}\n\n${body}`;
     return `${header}\n\n(no expanded content available — recall cache may have been cleared)`;
 }
-export async function recallBrowse(store, limit = 25) {
-    const lines = await readSummaryLines(store, limit);
-    if (lines.length === 0)
+export async function recallBrowse(store, offset = 0, limit = 25) {
+    const overRead = Math.max(limit * 3, offset + limit);
+    const allLines = await readSummaryLines(store, overRead);
+    if (allLines.length === 0)
         return "No conversation history.";
-    return ["Recent summary entries:", ...lines.map((l) => `  ${l}`)].join("\n");
+    const end = Math.min(offset + limit, allLines.length);
+    const paged = allLines.slice(offset, end);
+    const range = offset > 0 || end < allLines.length
+        ? ` (entries ${offset + 1}–${end} of ${allLines.length} shown)`
+        : "";
+    return [`Recent summary entries${range}:`, ...paged.map((l) => `  ${l}`)].join("\n");
 }

package/dist/agent/providers/openai-compatible.d.ts

@@ -7,3 +7,11 @@
  */
 import type { AgentContext } from "../host-types.js";
 export default function activate(ctx: AgentContext): void;
+export interface CatalogModel {
+    id: string;
+    meta?: {
+        n_ctx?: number;
+    };
+    max_model_len?: number;
+}
+export declare function catalogContextWindow(m: CatalogModel): number | undefined;

package/dist/agent/providers/openai-compatible.js

@@ -18,11 +18,18 @@ export default function activate(ctx) {
             id,
             apiKey,
             baseURL,
-            defaultModel: models[0],
+            defaultModel: models[0].id,
             models,
         });
     }).catch(() => { });
 }
+export function catalogContextWindow(m) {
+    if (typeof m.meta?.n_ctx === "number" && m.meta.n_ctx > 0)
+        return m.meta.n_ctx;
+    if (typeof m.max_model_len === "number" && m.max_model_len > 0)
+        return m.max_model_len;
+    return undefined;
+}
 async function fetchModels(baseURL, apiKey) {
     const headers = {};
     if (apiKey && apiKey !== "no-key")
@@ -31,5 +38,5 @@ async function fetchModels(baseURL, apiKey) {
     if (!res.ok)
         return [];
     const data = await res.json();
-    return (data.data ?? []).map((m) => m.id);
+    return (data.data ?? []).map((m) => ({ id: m.id, contextWindow: catalogContextWindow(m) }));
 }

package/dist/agent/store.js

@@ -14,7 +14,12 @@ function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function compileSearchRegex(query) {
-    return new RegExp(escapeRegex(query), "i");
+    try {
+        return new RegExp(query, "i");
+    }
+    catch {
+        return new RegExp(escapeRegex(query), "i");
+    }
 }
 function matchEntry(entry, re) {
     const line = JSON.stringify(entry);

package/dist/agent/token-budget.d.ts

@@ -6,5 +6,6 @@
  */
 /** Response reserve — tokens reserved for the model's output. */
 export declare const RESPONSE_RESERVE = 8192;
+export declare function resolveDefaultContextWindow(env?: Record<string, string | undefined>): number;
 /** Fallback when contextWindow is unknown. */
-export declare const DEFAULT_CONTEXT_WINDOW = 60000;
+export declare const DEFAULT_CONTEXT_WINDOW: number;

package/dist/agent/token-budget.js

@@ -6,5 +6,10 @@
  */
 /** Response reserve — tokens reserved for the model's output. */
 export const RESPONSE_RESERVE = 8192;
+const FALLBACK_CONTEXT_WINDOW = 60_000;
+export function resolveDefaultContextWindow(env = process.env) {
+    const n = Number(env.AGENT_SH_DEFAULT_CONTEXT_WINDOW);
+    return Number.isInteger(n) && n > 0 ? n : FALLBACK_CONTEXT_WINDOW;
+}
 /** Fallback when contextWindow is unknown. */
-export const DEFAULT_CONTEXT_WINDOW = 60_000;
+export const DEFAULT_CONTEXT_WINDOW = resolveDefaultContextWindow();

package/dist/cli/index.js

@@ -98,7 +98,6 @@ async function main() {
     // Load before spawning the shell so PS1 lands below the banner.
     const settings = getSettings();
     await loadBuiltinExtensions(extCtx, settings.disabledBuiltins);
-    activateRollingHistory(extCtx);
     const loadExtensionsTimeoutMs = 10000;
     let loadedExtensions = [];
     await Promise.race([
@@ -154,6 +153,7 @@ async function main() {
             borderLine + "\n\n");
     }
     await core.activateBackend(config.backend);
+    activateRollingHistory(extCtx);
     // 100ms sidesteps macOS SIGTTOU during fg-pgrp handoff.
     await new Promise(resolve => setTimeout(resolve, 100));
     shell = activateShell(extCtx, {

package/dist/core/event-bus.d.ts

@@ -58,6 +58,13 @@ export interface BusMeta {
     name: string;
 }
 export type AnyListener = (name: string, payload: unknown, meta: BusMeta) => void;
+/** A listener fault routed to the error reporter; `phase` is the callback site. */
+export interface BusFault {
+    phase: "on" | "any" | "pipe" | "pipe-async";
+    event: string;
+    err: unknown;
+}
+export type ErrorReporter = (fault: BusFault) => void;
 /**
  * Typed event bus with two modes:
  * - emit/on/off: fire-and-forget notifications
@@ -65,14 +72,22 @@ export type AnyListener = (name: string, payload: unknown, meta: BusMeta) => voi
  *   can modify the payload before passing to the next
  */
 export declare class EventBus {
-    private emitter;
+    private listeners;
     private pipeListeners;
     private asyncPipeListeners;
     private source;
     private nextSeq;
     private anyListeners;
+    /** Default fault sink, overridable via setErrorReporter: silent unless DEBUG. */
+    private reportError;
     /** Set the source id stamped onto every emitted event. */
     setSource(src: string): void;
+    /** Install a fault reporter. */
+    setErrorReporter(fn: ErrorReporter): void;
+    /** Report a fault; guarded so a broken reporter can't break dispatch. */
+    private fault;
+    /** Fire every listener for `name`, isolating faults. */
+    private notify;
     /** Subscribe to every emitted event with full envelope. Returns unsubscribe. */
     onAny(fn: AnyListener): () => void;
     /** Stamp + dispatch — used by every emit path. */

package/dist/core/event-bus.js

@@ -1,4 +1,3 @@
-import { EventEmitter } from "node:events";
 /**
  * Typed event bus with two modes:
  * - emit/on/off: fire-and-forget notifications
@@ -6,16 +5,60 @@ import { EventEmitter } from "node:events";
  *   can modify the payload before passing to the next
  */
 export class EventBus {
-    emitter = new EventEmitter().setMaxListeners(0);
+    listeners = new Map();
     pipeListeners = new Map();
     asyncPipeListeners = new Map();
     source = "0000";
     nextSeq = 0;
     anyListeners = [];
+    /** Default fault sink, overridable via setErrorReporter: silent unless DEBUG. */
+    reportError = ({ phase, event, err }) => {
+        if (process.env.DEBUG) {
+            const msg = err instanceof Error ? (err.stack ?? err.message) : String(err);
+            process.stderr.write(`[event-bus] ${phase} fault on "${event}": ${msg}\n`);
+        }
+    };
     /** Set the source id stamped onto every emitted event. */
     setSource(src) {
         this.source = src;
     }
+    /** Install a fault reporter. */
+    setErrorReporter(fn) {
+        this.reportError = fn;
+    }
+    /** Report a fault; guarded so a broken reporter can't break dispatch. */
+    fault(phase, event, err) {
+        try {
+            this.reportError({ phase, event, err });
+        }
+        catch {
+            /* swallow */
+        }
+    }
+    /** Fire every listener for `name`, isolating faults. */
+    notify(name, payload) {
+        const arr = this.listeners.get(name);
+        if (!arr || arr.length === 0)
+            return;
+        // snapshot so a listener that (un)subscribes mid-dispatch can't shift iteration
+        if (arr.length === 1) {
+            try {
+                arr[0](payload);
+            }
+            catch (err) {
+                this.fault("on", name, err);
+            }
+            return;
+        }
+        for (const fn of arr.slice()) {
+            try {
+                fn(payload);
+            }
+            catch (err) {
+                this.fault("on", name, err);
+            }
+        }
+    }
     /** Subscribe to every emitted event with full envelope. Returns unsubscribe. */
     onAny(fn) {
         this.anyListeners.push(fn);
@@ -38,18 +81,30 @@ export class EventBus {
                 try {
                     fn(name, payload, meta);
                 }
-                catch { /* swallow */ }
+                catch (err) {
+                    this.fault("any", name, err);
+                }
             }
         }
-        this.emitter.emit(name, payload);
+        this.notify(name, payload);
     }
     /** Subscribe to a fire-and-forget event. */
     on(event, fn) {
-        this.emitter.on(event, fn);
+        let arr = this.listeners.get(event);
+        if (!arr) {
+            arr = [];
+            this.listeners.set(event, arr);
+        }
+        arr.push(fn);
     }
     /** Unsubscribe from a fire-and-forget event. */
     off(event, fn) {
-        this.emitter.off(event, fn);
+        const arr = this.listeners.get(event);
+        if (!arr)
+            return;
+        const idx = arr.indexOf(fn);
+        if (idx !== -1)
+            arr.splice(idx, 1);
     }
     /** Emit a fire-and-forget event. */
     emit(event, payload) {
@@ -64,10 +119,12 @@ export class EventBus {
                 try {
                     fn(meta.name, payload, meta);
                 }
-                catch { /* swallow */ }
+                catch (err) {
+                    this.fault("any", meta.name, err);
+                }
             }
         }
-        this.emitter.emit(meta.name, payload);
+        this.notify(meta.name, payload);
     }
     /**
      * Transform-then-notify: run the payload through any registered pipe
@@ -120,13 +177,13 @@ export class EventBus {
             try {
                 const out = fn(result);
                 if (out && typeof out.then === "function") {
-                    console.error(`[event-bus] Warning: async handler in sync pipe "${String(event)}" — use onPipeAsync instead`);
+                    this.fault("pipe", String(event), new Error("async handler in sync pipe — use onPipeAsync instead"));
                     continue;
                 }
                 result = out;
             }
             catch (err) {
-                console.error(`[event-bus] Pipe handler error in "${String(event)}":`, err instanceof Error ? err.message : err);
+                this.fault("pipe", String(event), err);
             }
         }
         return result;
@@ -165,7 +222,12 @@ export class EventBus {
             return payload;
         let result = payload;
         for (const fn of listeners) {
-            result = await fn(result);
+            try {
+                result = await fn(result);
+            }
+            catch (err) {
+                this.fault("pipe-async", String(event), err);
+            }
         }
         return result;
     }

package/dist/core/index.js

@@ -27,6 +27,24 @@ export function createCore(config) {
     // should accept ≥6 hex chars.
     const instanceId = crypto.randomBytes(3).toString("hex");
     bus.setSource(instanceId);
+    // Surface faults on ui:error; `surfacing` stops a faulting renderer from looping.
+    let surfacing = false;
+    bus.setErrorReporter(({ phase, event, err }) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        if (process.env.DEBUG) {
+            const full = err instanceof Error ? (err.stack ?? err.message) : detail;
+            process.stderr.write(`[event-bus] ${phase} fault on "${event}": ${full}\n`);
+        }
+        if (surfacing)
+            return;
+        surfacing = true;
+        try {
+            bus.emit("ui:error", { message: `Handler error on "${event}": ${detail}` });
+        }
+        finally {
+            surfacing = false;
+        }
+    });
     handlers.define("config:get-app-config", () => config);
     handlers.define("cwd", () => process.cwd());
     // Empty defaults so advisors can wrap these regardless of load order;