agent-sh 0.15.6 → 0.15.8

package/src/agent/agent-loop.ts

@@ -462,6 +462,17 @@ export class AgentLoop implements AgentBackend {
   }
 
 
+  /** Resume-stable conversation id from the frontend (e.g. ashi); undefined
+   *  when the frontend tracks no session. */
+  private currentSessionId(): string | undefined {
+    try {
+      const id = this.handlers.call("session:current-id");
+      return typeof id === "string" && id ? id : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
   private resolveEndpoint(m: Model): ModelEndpoint | undefined {
     try {
       return this.handlers.call("agent:resolve-endpoint", { provider: m.provider, id: m.id }) as ModelEndpoint | undefined;
@@ -971,12 +982,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;
@@ -1442,7 +1450,12 @@ export class AgentLoop implements AgentBackend {
     };
     this.bus.emit("llm:request", requestParams);
 
-    const stream = await this.llmClient.stream({ ...requestParams, signal });
+    const headers = this.activeEndpoint?.buildRequestHeaders?.({ sessionId: this.currentSessionId() });
+    const stream = await this.llmClient.stream({
+      ...requestParams,
+      signal,
+      ...(headers && Object.keys(headers).length ? { headers } : {}),
+    });
 
     try {
     for await (const chunk of stream) {

package/src/agent/events.ts

@@ -22,6 +22,7 @@ declare module "../core/event-bus.js" {
       id: string;
       reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
       cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+      requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
     };
 
     "agent:models-changed": Record<string, never>;

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/host-types.ts

@@ -93,6 +93,7 @@ export interface ModelEndpoint {
   baseURL?: string;
   buildReasoningParams?: (level: string) => Record<string, unknown>;
   extractCachedTokens?: (usage: Record<string, unknown>) => number | undefined;
+  buildRequestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
 }
 
 // ── Agent-host extension surface ─────────────────────────────────
@@ -111,6 +112,7 @@ export interface AgentSurface {
     configure: (id: string, opts: {
       reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
       cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+      requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
     }) => void;
   };
 

package/src/agent/index.ts

@@ -128,6 +128,7 @@ export default function agentBackend(ctx: ExtensionContext): void {
   const providerHooks = new Map<string, {
     reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
     cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+    requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
   }>();
 
   // Bakes model id so ModelEndpoint.buildReasoningParams keeps its (level) signature.
@@ -139,6 +140,9 @@ export default function agentBackend(ctx: ExtensionContext): void {
   const bindCacheTokens = (shapeId: string) =>
     providerHooks.get(shapeId)?.cacheTokens ?? defaultCacheTokens;
 
+  const bindRequestHeaders = (shapeId: string) =>
+    providerHooks.get(shapeId)?.requestHeaders;
+
   const agentSurface: AgentSurface = {
     llm: createLlmFacade({ list: ctx.list, call: ctx.call }),
     providers: {
@@ -345,6 +349,7 @@ export default function agentBackend(ctx: ExtensionContext): void {
       baseURL: p.baseURL,
       buildReasoningParams: bindReasoning(shapeId, modelId),
       extractCachedTokens: bindCacheTokens(shapeId),
+      buildRequestHeaders: bindRequestHeaders(shapeId),
     };
   };
 
@@ -388,10 +393,11 @@ export default function agentBackend(ctx: ExtensionContext): void {
     }
   });
 
-  bus.on("provider:configure", ({ id, reasoningParams, cacheTokens }) => {
+  bus.on("provider:configure", ({ id, reasoningParams, cacheTokens, requestHeaders }) => {
     const prev = providerHooks.get(id) ?? {};
     if (reasoningParams !== undefined) prev.reasoningParams = reasoningParams;
     if (cacheTokens !== undefined) prev.cacheTokens = cacheTokens;
+    if (requestHeaders !== undefined) prev.requestHeaders = requestHeaders;
     providerHooks.set(id, prev);
   });
 

package/src/agent/llm-client.ts

@@ -68,7 +68,7 @@ export class LlmClient {
   }
 
   stream(opts: StreamOpts) {
-    const { signal, messages, tools, model, max_tokens, ...rest } = opts;
+    const { signal, headers, messages, tools, model, max_tokens, ...rest } = opts;
     const body = {
       ...rest,
       model: model ?? this.model,
@@ -78,7 +78,7 @@ export class LlmClient {
       stream: true as const,
       stream_options: { include_usage: true },
     };
-    return this.client.chat.completions.create(body as ChatCompletionCreateParamsStreaming, { signal });
+    return this.client.chat.completions.create(body as ChatCompletionCreateParamsStreaming, { signal, headers });
   }
 
   async complete(opts: CompleteOpts): Promise<string> {
@@ -102,6 +102,8 @@ export type StreamOpts = {
   model?: string;
   max_tokens?: number;
   signal?: AbortSignal;
+  /** Per-request transport headers, forwarded to the SDK (not request body). */
+  headers?: Record<string, string>;
 } & Record<string, unknown>;
 
 export type CompleteOpts = {

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/providers/openrouter.ts

@@ -42,7 +42,16 @@ function toModalities(input?: string[]): ("text" | "image")[] | undefined {
 
 export default function activate(ctx: AgentContext): void {
   const apiKey = resolveApiKey("openrouter").key;
-  ctx.agent.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
+  ctx.agent.providers.configure("openrouter", {
+    reasoningParams: buildReasoningParams,
+    // x-session-id pins sticky provider routing across turns so prompt caches
+    // stay warm even when compaction rewrites the opening messages.
+    requestHeaders: ({ sessionId }) => {
+      const headers: Record<string, string> = {};
+      if (sessionId) headers["x-session-id"] = sessionId;
+      return headers;
+    },
+  });
   ctx.agent.providers.register({
     id: "openrouter",
     apiKey: apiKey ?? undefined,

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());
 

package/src/shell/strategies/bash.ts

@@ -47,8 +47,16 @@ export const bashStrategy: ShellStrategy = {
       '  [[ $__agent_sh_preexec_ran == 1 ]] && return',
       '  [[ -n $COMP_LINE ]] && return',
       "  __agent_sh_preexec_ran=1",
-      "  local this_cmd",
-      `  this_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+      "  local this_cmd hist_cmd",
+      `  hist_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+      "  # history 1 carries the full typed line but goes stale when the user's",
+      "  # PROMPT_COMMAND reloads history (history -c/-r). Trust it only when it",
+      "  # matches the command bash is about to run; else use $BASH_COMMAND.",
+      '  if [[ -n $hist_cmd && $hist_cmd == "$BASH_COMMAND"* ]]; then',
+      "    this_cmd=$hist_cmd",
+      "  else",
+      "    this_cmd=$BASH_COMMAND",
+      "  fi",
       `  printf '\\e]9997;${instanceTag};%s\\a' "$this_cmd"`,
       "}",
       "trap '__agent_sh_emit_preexec' DEBUG",