agent-sh 0.15.6 → 0.15.7

package/examples/extensions/ashi/src/compaction.ts

@@ -39,19 +39,16 @@ export function registerCompaction(
     }
 
     const older = messages.slice(0, cutIdx);
-    const kept = messages.slice(cutIdx);
     const tokensBefore = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
     const customSummary = (await ctx.call("ashi:compact:build-summary", older)) as string | null | undefined;
 
     const store = getStore().current();
     await store.appendCompaction(firstKeptId, tokensBefore, customSummary ?? undefined);
-    ctx.call("conversation:replace-messages", store.buildMessages());
 
-    const keptIds = kept.map((_, i) => capture.getEntryIdAt(cutIdx + i));
-    if (keptIds.some((id) => id === null)) {
-      ctx.bus.emit("ui:error", { message: "compaction: a kept message has no on-disk entry — capture invariant broken" });
-    }
-    capture.resetTo([null, ...keptIds]);
+    // Take messages and ids from one rebuild so capture's index→id map can't drift.
+    const { messages: rebuilt, entryIds } = store.buildBranchWithIds();
+    ctx.call("conversation:replace-messages", rebuilt);
+    capture.resetTo(entryIds);
 
     const tokensAfter = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
     return { before: tokensBefore, after: tokensAfter, evictedCount: older.length };

package/examples/extensions/ashi/src/frontend.ts

@@ -650,6 +650,8 @@ export function mountAshi(
     activeThinking = null;
     activeTools.clear();
     openGroup = null;
+    compactions = 0;
+    statusFooter.update({ compactions });
     clearChat();
     const branch = getStore().current().getBranch();
     const toolMap = new Map<string, ReplayEntry>();

package/examples/extensions/ashi/src/schema.ts

@@ -1,4 +1,5 @@
 import { theme } from "./theme.js";
+import { truncateToWidth } from "@earendil-works/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
 import type { ThemeColor } from "./theme.js";
 import type { ToolEntryConfig } from "./display-config.js";
@@ -188,6 +189,11 @@ export function renderBody(body: Body, env: Env, diff: DiffSlot): string {
 // The tail is capped even when expanded so a huge result can't flood scrollback; the agent still sees it all.
 const DEFAULT_EXPANDED_LINES = 200;
 
+function clampLines(lines: string[], width: number): string {
+  if (width <= 0) return lines.join("\n");
+  return lines.map((l) => truncateToWidth(l, width, "…")).join("\n");
+}
+
 function renderStream(buffer: string, env: Env): string {
   const display = buffer.replace(/\n+$/, "");
   if (env.expanded) {
@@ -205,14 +211,14 @@ function renderStream(buffer: string, env: Env): string {
   }
   if (env.mode === "summary") {
     if (!env.finalized) {
-      const tail = display.split("\n").slice(-2).join("\n");
+      const tail = clampLines(display.split("\n").slice(-2), env.width);
       return theme.fg("muted", tail);
     }
     return lineCountHint(buffer);
   }
   if (!display) return "";
   const lines = display.split("\n");
-  const trimmed = lines.slice(-env.previewLines).join("\n");
+  const trimmed = clampLines(lines.slice(-env.previewLines), env.width);
   const remaining = Math.max(0, lines.length - env.previewLines);
   // The preview is the tail, so the hidden lines come before it — note goes above.
   const overflow = remaining > 0

package/examples/extensions/command-suggest.ts

@@ -15,6 +15,10 @@ import type { ExtensionContext } from "agent-sh/types";
 
 export default function activate(ctx: ExtensionContext): void {
   const { bus } = ctx;
+
+  // No shell to deliver to (e.g. ashi) — the suggestion would go nowhere.
+  if (!ctx.shell) return;
+
   let pendingCommand: string | null = null;
 
   // ── Tool ────────────────────────────────────────────────────────

package/examples/extensions/solarized-theme.ts

@@ -23,5 +23,16 @@ export default function activate(ctx: ShellContext) {
     errorBg:       "\x1b[48;2;42;30;30m",   // base03 with red tint
     successBgEmph: "\x1b[48;2;20;70;50m",   // stronger green tint
     errorBgEmph:   "\x1b[48;2;70;30;30m",   // stronger red tint
+
+    mdHeading:         "\x1b[38;2;181;137;0m",  // yellow (#b58900)
+    mdLink:            "\x1b[38;2;38;139;210m", // blue (#268bd2)
+    mdLinkUrl:         "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdCode:            "\x1b[38;2;42;161;152m", // cyan (#2aa198)
+    mdCodeBlock:       "\x1b[38;2;133;153;0m",  // green (#859900)
+    mdCodeBlockBorder: "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdQuote:           "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdQuoteBorder:     "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdHr:              "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdListBullet:      "\x1b[38;2;38;139;210m", // blue (#268bd2)
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.15.6",
+  "version": "0.15.7",
   "description": "A composable agent runtime — pair any frontend with any agent backend over one shared extension layer",
   "type": "module",
   "workspaces": [

package/src/agent/agent-loop.ts

@@ -971,12 +971,9 @@ export class AgentLoop implements AgentBackend {
         // 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/src/agent/extensions/rolling-history/index.ts

@@ -111,32 +111,44 @@ export default function activate(ctx: ExtensionContext): void {
     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.",
+      "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 as string;
+      const offset = (args.offset as number) ?? 0;
+      const limit = (args.limit as number) ?? (action === "search" ? 30 : 25);
       let content: string;
       if (action === "search") {
-        content = await recallSearch(summaryStore, (args.query as string) ?? "");
+        content = await recallSearch(summaryStore, (args.query as string) ?? "", offset, limit);
       } else if (action === "expand") {
         content = await recallExpand(summaryStore, args.turn_id as string);
       } else {
-        content = await recallBrowse(summaryStore);
+        content = await recallBrowse(summaryStore, offset, limit);
       }
       return { content, exitCode: 0, isError: false };
     },

package/src/agent/extensions/rolling-history/recall.ts

@@ -76,7 +76,12 @@ async function findCacheChild(store: Store, parentId: string): Promise<RecallCac
   return null;
 }
 
-export async function recallSearch(store: Store, query: string): Promise<string> {
+export async function recallSearch(
+  store: Store,
+  query: string,
+  offset = 0,
+  maxResults = 30,
+): Promise<string> {
   if (!query.trim()) return "No query provided.";
   const regex = buildSearchRegex(query);
   const hits: string[] = [];
@@ -106,8 +111,13 @@ export async function recallSearch(store: Store, query: string): Promise<string>
 
   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: Store, id: string): Promise<string> {
@@ -124,8 +134,19 @@ export async function recallExpand(store: Store, id: string): Promise<string> {
   return `${header}\n\n(no expanded content available — recall cache may have been cleared)`;
 }
 
-export async function recallBrowse(store: Store, limit = 25): Promise<string> {
-  const lines = await readSummaryLines(store, limit);
-  if (lines.length === 0) return "No conversation history.";
-  return ["Recent summary entries:", ...lines.map((l) => `  ${l}`)].join("\n");
+export async function recallBrowse(
+  store: Store,
+  offset = 0,
+  limit = 25,
+): Promise<string> {
+  const overRead = Math.max(limit * 3, offset + limit);
+  const allLines = await readSummaryLines(store, overRead);
+  if (allLines.length === 0) return "No conversation history.";
+  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/src/agent/providers/openai-compatible.ts

@@ -28,17 +28,32 @@ export default function activate(ctx: AgentContext): void {
       id,
       apiKey,
       baseURL,
-      defaultModel: models[0],
+      defaultModel: models[0]!.id,
       models,
     });
   }).catch(() => { /* leave empty — user supplies via --model */ });
 }
 
-async function fetchModels(baseURL: string, apiKey: string): Promise<string[]> {
+export interface CatalogModel {
+  id: string;
+  meta?: { n_ctx?: number };
+  max_model_len?: number;
+}
+
+export function catalogContextWindow(m: CatalogModel): number | undefined {
+  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: string,
+  apiKey: string,
+): Promise<{ id: string; contextWindow?: number }[]> {
   const headers: Record<string, string> = {};
   if (apiKey && apiKey !== "no-key") headers.Authorization = `Bearer ${apiKey}`;
   const res = await fetch(`${baseURL.replace(/\/$/, "")}/models`, { headers });
   if (!res.ok) return [];
-  const data = await res.json() as { data?: { id: string }[] };
-  return (data.data ?? []).map((m) => m.id);
+  const data = await res.json() as { data?: CatalogModel[] };
+  return (data.data ?? []).map((m) => ({ id: m.id, contextWindow: catalogContextWindow(m) }));
 }

package/src/agent/store.ts

@@ -54,7 +54,11 @@ function escapeRegex(s: string): string {
 }
 
 function compileSearchRegex(query: string): RegExp {
-  return new RegExp(escapeRegex(query), "i");
+  try {
+    return new RegExp(query, "i");
+  } catch {
+    return new RegExp(escapeRegex(query), "i");
+  }
 }
 
 function matchEntry(entry: Entry, re: RegExp): SearchHit | null {

package/src/agent/token-budget.ts

@@ -8,5 +8,14 @@
 /** Response reserve — tokens reserved for the model's output. */
 export const RESPONSE_RESERVE = 8192;
 
+const FALLBACK_CONTEXT_WINDOW = 60_000;
+
+export function resolveDefaultContextWindow(
+  env: Record<string, string | undefined> = process.env,
+): number {
+  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/src/cli/index.ts

@@ -128,7 +128,6 @@ async function main(): Promise<void> {
   // 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: string[] = [];
   await Promise.race([
@@ -197,6 +196,7 @@ async function main(): Promise<void> {
   }
 
   await core.activateBackend(config.backend);
+  activateRollingHistory(extCtx);
 
   // 100ms sidesteps macOS SIGTTOU during fg-pgrp handoff.
   await new Promise(resolve => setTimeout(resolve, 100));

package/src/core/event-bus.ts

@@ -1,5 +1,3 @@
-import { EventEmitter } from "node:events";
-
 export interface BackendRegistration {
   name: string;
   kill: () => void;
@@ -49,6 +47,15 @@ export interface BusMeta {
 
 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
@@ -56,18 +63,54 @@ export type AnyListener = (name: string, payload: unknown, meta: BusMeta) => voi
  *   can modify the payload before passing to the next
  */
 export class EventBus {
-  private emitter = new EventEmitter().setMaxListeners(0);
+  private listeners = new Map<string, Listener<any>[]>();
   private pipeListeners = new Map<string, PipeListener<any>[]>();
   private asyncPipeListeners = new Map<string, AsyncPipeListener<any>[]>();
   private source = "0000";
   private nextSeq = 0;
   private anyListeners: AnyListener[] = [];
 
+  /** Default fault sink, overridable via setErrorReporter: silent unless DEBUG. */
+  private reportError: ErrorReporter = ({ 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: string): void {
     this.source = src;
   }
 
+  /** Install a fault reporter. */
+  setErrorReporter(fn: ErrorReporter): void {
+    this.reportError = fn;
+  }
+
+  /** Report a fault; guarded so a broken reporter can't break dispatch. */
+  private fault(phase: BusFault["phase"], event: string, err: unknown): void {
+    try {
+      this.reportError({ phase, event, err });
+    } catch {
+      /* swallow */
+    }
+  }
+
+  /** Fire every listener for `name`, isolating faults. */
+  private notify(name: string, payload: unknown): void {
+    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: AnyListener): () => void {
     this.anyListeners.push(fn);
@@ -87,10 +130,10 @@ export class EventBus {
         name,
       };
       for (const fn of this.anyListeners) {
-        try { fn(name, payload, meta); } catch { /* swallow */ }
+        try { fn(name, payload, meta); } catch (err) { this.fault("any", name, err); }
       }
     }
-    this.emitter.emit(name, payload);
+    this.notify(name, payload);
   }
 
   /** Subscribe to a fire-and-forget event. */
@@ -98,7 +141,12 @@ export class EventBus {
     event: K,
     fn: Listener<BusEvents[K]>,
   ): void {
-    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. */
@@ -106,7 +154,10 @@ export class EventBus {
     event: K,
     fn: Listener<BusEvents[K]>,
   ): void {
-    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. */
@@ -123,10 +174,10 @@ export class EventBus {
   relay(meta: BusMeta, payload: unknown): void {
     if (this.anyListeners.length > 0) {
       for (const fn of this.anyListeners) {
-        try { fn(meta.name, payload, meta); } catch { /* swallow */ }
+        try { fn(meta.name, payload, meta); } catch (err) { this.fault("any", meta.name, err); }
       }
     }
-    this.emitter.emit(meta.name, payload);
+    this.notify(meta.name, payload);
   }
 
   /**
@@ -191,12 +242,12 @@ export class EventBus {
       try {
         const out = fn(result);
         if (out && typeof (out as any).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;
@@ -245,7 +296,11 @@ export class EventBus {
     if (!listeners) 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/src/core/index.ts

@@ -48,6 +48,24 @@ export function createCore(config: AppConfig): AgentShellCore {
   // 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());