agent-sh 0.14.7 → 0.14.9

package/dist/agent/store.d.ts

@@ -0,0 +1,74 @@
+export interface Entry {
+    id: string;
+    parentId?: string;
+    ts: number;
+    kind: string;
+    payload: Record<string, unknown>;
+}
+export interface AppendOpts {
+    /** Memory-only; never persisted. */
+    ephemeral?: boolean;
+}
+export interface SearchHit {
+    entry: Entry;
+    line: string;
+}
+/** Append-only — no edit or delete. Implementations may apply bulk
+ *  retention (front-truncation, GC), but strategies cannot remove a
+ *  specific entry. */
+export interface Store {
+    append(entries: Entry[], opts?: AppendOpts): Promise<void>;
+    findById(id: string): Promise<Entry | null>;
+    readRecent(n?: number): Promise<Entry[]>;
+    search(query: string): Promise<SearchHit[]>;
+}
+export interface TreeStore extends Store {
+    getBranch(leafId?: string): Promise<Entry[]>;
+    setLeaf(id: string): void;
+    getLeaf(): string;
+}
+export declare function newEntryId(): string;
+export declare function isTreeStore(s: Store): s is TreeStore;
+export declare class NoopStore implements Store {
+    append(): Promise<void>;
+    findById(): Promise<Entry | null>;
+    readRecent(): Promise<Entry[]>;
+    search(): Promise<SearchHit[]>;
+}
+export declare class InMemoryStore implements TreeStore {
+    private entries;
+    private order;
+    private leaf;
+    constructor(opts?: {
+        root?: Entry;
+    });
+    append(entries: Entry[]): Promise<void>;
+    findById(id: string): Promise<Entry | null>;
+    readRecent(n?: number): Promise<Entry[]>;
+    search(query: string): Promise<SearchHit[]>;
+    getBranch(leafId?: string): Promise<Entry[]>;
+    setLeaf(id: string): void;
+    getLeaf(): string;
+}
+export interface SharedFileStoreOpts {
+    filePath: string;
+    /** Front-truncate above this size; truncation fires at 150% of the
+     *  cap to avoid frequent rewrites. */
+    maxBytes?: number;
+}
+export declare class SharedFileStore implements Store {
+    private filePath;
+    private lockPath;
+    private maxBytes;
+    constructor(opts: SharedFileStoreOpts);
+    append(entries: Entry[], opts?: AppendOpts): Promise<void>;
+    findById(id: string): Promise<Entry | null>;
+    readRecent(n?: number): Promise<Entry[]>;
+    search(query: string): Promise<SearchHit[]>;
+    /** Yield lines newest-first by reading reverse-chunked blocks,
+     *  stitching across boundaries. */
+    private streamReverseLines;
+    private maybeTruncate;
+    private acquireLock;
+    private releaseLock;
+}

package/dist/agent/store.js

@@ -0,0 +1,284 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+export function newEntryId() {
+    return crypto.randomBytes(4).toString("hex");
+}
+export function isTreeStore(s) {
+    return (typeof s.setLeaf === "function" &&
+        typeof s.getLeaf === "function" &&
+        typeof s.getBranch === "function");
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileSearchRegex(query) {
+    return new RegExp(escapeRegex(query), "i");
+}
+function matchEntry(entry, re) {
+    const line = JSON.stringify(entry);
+    return re.test(line) ? { entry, line } : null;
+}
+export class NoopStore {
+    async append() { }
+    async findById() { return null; }
+    async readRecent() { return []; }
+    async search() { return []; }
+}
+export class InMemoryStore {
+    entries = new Map();
+    order = [];
+    leaf;
+    constructor(opts) {
+        if (opts?.root) {
+            this.entries.set(opts.root.id, opts.root);
+            this.order.push(opts.root.id);
+            this.leaf = opts.root.id;
+        }
+        else {
+            this.leaf = "";
+        }
+    }
+    async append(entries) {
+        for (const e of entries) {
+            this.entries.set(e.id, e);
+            this.order.push(e.id);
+        }
+    }
+    async findById(id) {
+        return this.entries.get(id) ?? null;
+    }
+    async readRecent(n) {
+        const slice = n == null ? this.order : this.order.slice(-n);
+        return slice.map((id) => this.entries.get(id));
+    }
+    async search(query) {
+        if (!query.trim())
+            return [];
+        const re = compileSearchRegex(query);
+        const out = [];
+        for (let i = this.order.length - 1; i >= 0; i--) {
+            const m = matchEntry(this.entries.get(this.order[i]), re);
+            if (m)
+                out.push(m);
+        }
+        return out;
+    }
+    async getBranch(leafId = this.leaf) {
+        const out = [];
+        const seen = new Set();
+        let cur = leafId;
+        while (cur && !seen.has(cur)) {
+            seen.add(cur);
+            const e = this.entries.get(cur);
+            if (!e)
+                break;
+            out.push(e);
+            cur = e.parentId;
+        }
+        return out.reverse();
+    }
+    setLeaf(id) {
+        if (!this.entries.has(id))
+            throw new Error(`unknown entry: ${id}`);
+        this.leaf = id;
+    }
+    getLeaf() {
+        return this.leaf;
+    }
+}
+/** Multi-writer JSONL Store. O_APPEND with PIPE_BUF-bounded line
+ *  writes for atomic concurrent appends; lock-based front-truncation
+ *  for retention; reads stream the tail for cheap recent slices. */
+const LOCK_STALE_MS = 10_000;
+const DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+export class SharedFileStore {
+    filePath;
+    lockPath;
+    maxBytes;
+    constructor(opts) {
+        this.filePath = opts.filePath;
+        this.lockPath = opts.filePath + ".lock";
+        this.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        }
+        catch { /* ignore */ }
+    }
+    async append(entries, opts) {
+        if (entries.length === 0)
+            return;
+        if (opts?.ephemeral)
+            return; // memory-only writes are a no-op on a file-only store
+        const lines = entries.map((e) => JSON.stringify(e) + "\n").join("");
+        await fsp.appendFile(this.filePath, lines, { flag: "a" });
+        await this.maybeTruncate();
+    }
+    async findById(id) {
+        for await (const line of this.streamReverseLines()) {
+            try {
+                const e = JSON.parse(line);
+                if (e.id === id)
+                    return e;
+            }
+            catch { /* skip malformed */ }
+        }
+        return null;
+    }
+    async readRecent(n) {
+        const want = n ?? Infinity;
+        const recent = []; // newest-first
+        for await (const line of this.streamReverseLines()) {
+            try {
+                const e = JSON.parse(line);
+                if (!e.id)
+                    continue;
+                recent.push(e);
+                if (recent.length >= want)
+                    break;
+            }
+            catch { /* skip malformed */ }
+        }
+        return recent.reverse();
+    }
+    async search(query) {
+        if (!query.trim())
+            return [];
+        const re = compileSearchRegex(query);
+        const budgetBytes = 20 * 1024 * 1024;
+        let scanned = 0;
+        const out = [];
+        for await (const line of this.streamReverseLines()) {
+            scanned += line.length + 1;
+            if (scanned > budgetBytes)
+                break;
+            try {
+                const e = JSON.parse(line);
+                const m = matchEntry(e, re);
+                if (m)
+                    out.push(m);
+            }
+            catch { /* skip malformed */ }
+        }
+        return out;
+    }
+    /** Yield lines newest-first by reading reverse-chunked blocks,
+     *  stitching across boundaries. */
+    async *streamReverseLines(chunkBytes = 1 << 20) {
+        let handle;
+        let fileSize;
+        try {
+            const stat = await fsp.stat(this.filePath);
+            fileSize = stat.size;
+            if (fileSize === 0)
+                return;
+            handle = await fsp.open(this.filePath, "r");
+        }
+        catch {
+            return;
+        }
+        try {
+            let position = fileSize;
+            let pending = Buffer.alloc(0);
+            while (position > 0) {
+                const readSize = Math.min(chunkBytes, position);
+                position -= readSize;
+                const buf = Buffer.alloc(readSize);
+                await handle.read(buf, 0, readSize, position);
+                const combined = Buffer.concat([buf, pending]);
+                const newlineIdxs = [];
+                for (let i = 0; i < combined.length; i++) {
+                    if (combined[i] === 0x0A)
+                        newlineIdxs.push(i);
+                }
+                if (newlineIdxs.length === 0) {
+                    pending = combined;
+                    continue;
+                }
+                const firstNl = newlineIdxs[0];
+                const lastNl = newlineIdxs[newlineIdxs.length - 1];
+                const trailing = combined.subarray(lastNl + 1);
+                if (trailing.length > 0)
+                    yield trailing.toString("utf-8");
+                for (let i = newlineIdxs.length - 1; i >= 1; i--) {
+                    const seg = combined.subarray(newlineIdxs[i - 1] + 1, newlineIdxs[i]);
+                    if (seg.length > 0)
+                        yield seg.toString("utf-8");
+                }
+                const leading = combined.subarray(0, firstNl);
+                if (position === 0) {
+                    if (leading.length > 0)
+                        yield leading.toString("utf-8");
+                    pending = Buffer.alloc(0);
+                }
+                else {
+                    pending = leading;
+                }
+            }
+            if (pending.length > 0)
+                yield pending.toString("utf-8");
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async maybeTruncate() {
+        let size = 0;
+        try {
+            size = (await fsp.stat(this.filePath)).size;
+        }
+        catch {
+            return;
+        }
+        if (size <= this.maxBytes * 1.5)
+            return;
+        if (!(await this.acquireLock()))
+            return;
+        try {
+            let content;
+            try {
+                content = await fsp.readFile(this.filePath, "utf-8");
+            }
+            catch {
+                return;
+            }
+            const lines = content.split("\n").filter(Boolean);
+            let totalBytes = Buffer.byteLength(content, "utf-8");
+            let dropCount = 0;
+            while (totalBytes > this.maxBytes && dropCount < lines.length - 1) {
+                totalBytes -= Buffer.byteLength(lines[dropCount] + "\n", "utf-8");
+                dropCount++;
+            }
+            if (dropCount === 0)
+                return;
+            const remaining = lines.slice(dropCount).join("\n") + "\n";
+            const tmpPath = this.filePath + ".tmp." + process.pid;
+            await fsp.writeFile(tmpPath, remaining);
+            await fsp.rename(tmpPath, this.filePath);
+        }
+        finally {
+            await this.releaseLock();
+        }
+    }
+    async acquireLock() {
+        try {
+            try {
+                const stat = await fsp.stat(this.lockPath);
+                if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                    await fsp.unlink(this.lockPath).catch(() => { });
+                }
+            }
+            catch { /* lock absent — good */ }
+            const fd = await fsp.open(this.lockPath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
+            await fd.close();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async releaseLock() {
+        await fsp.unlink(this.lockPath).catch(() => { });
+    }
+}

package/dist/agent/subagent.js

@@ -1,5 +1,5 @@
 import { contentText } from "./types.js";
-import { ConversationState } from "./conversation-state.js";
+import { LiveView } from "./live-view.js";
 import { normalizeToolArgs } from "./normalize-args.js";
 import { wrapTrailingWithDynamicContext } from "../utils/message-utils.js";
 /**
@@ -17,7 +17,7 @@ export async function runSubagent(opts) {
             parameters: t.input_schema,
         },
     }));
-    const conversation = new ConversationState();
+    const conversation = new LiveView();
     conversation.addUserMessage(task);
     let fullResponseText = "";
     let iterations = 0;

package/dist/agent/tool-protocol.d.ts

@@ -11,7 +11,7 @@
  */
 import type { ChatCompletionTool } from "./llm-client.js";
 import { type ToolDefinition } from "./types.js";
-import type { ConversationState } from "./conversation-state.js";
+import type { LiveView } from "./live-view.js";
 export interface PendingToolCall {
     id: string;
     name: string;
@@ -39,9 +39,9 @@ export interface ToolProtocol {
     /** Rewrite a tool call before execution (e.g., unwrap meta-tool). */
     rewriteToolCall(tc: PendingToolCall): PendingToolCall;
     /** Record the assistant turn in conversation state. */
-    recordAssistant(conv: ConversationState, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
+    recordAssistant(conv: LiveView, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
     /** Record all tool results for a batch as conversation messages. */
-    recordResults(conv: ConversationState, results: ToolResult[]): void;
+    recordResults(conv: LiveView, results: ToolResult[]): void;
     /** Create a stream filter for stripping tool calls from display. null = pass-through. */
     createStreamFilter(toolNames: string[]): StreamFilter | null;
     /**
@@ -57,8 +57,8 @@ export declare class ApiToolProtocol implements ToolProtocol {
     getToolPrompt(): string;
     extractToolCalls(_text: string, streamedCalls: PendingToolCall[]): PendingToolCall[];
     rewriteToolCall(tc: PendingToolCall): PendingToolCall;
-    recordAssistant(conv: ConversationState, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
-    recordResults(conv: ConversationState, results: ToolResult[]): void;
+    recordAssistant(conv: LiveView, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
+    recordResults(conv: LiveView, results: ToolResult[]): void;
     createStreamFilter(): null;
 }
 export declare class InlineToolProtocol implements ToolProtocol {
@@ -68,8 +68,8 @@ export declare class InlineToolProtocol implements ToolProtocol {
     getToolPrompt(tools: ToolDefinition[]): string;
     rewriteToolCall(tc: PendingToolCall): PendingToolCall;
     extractToolCalls(text: string, _streamedCalls: PendingToolCall[]): PendingToolCall[];
-    recordAssistant(conv: ConversationState, text: string, _toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
-    recordResults(conv: ConversationState, results: ToolResult[]): void;
+    recordAssistant(conv: LiveView, text: string, _toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
+    recordResults(conv: LiveView, results: ToolResult[]): void;
     createStreamFilter(_toolNames: string[]): StreamFilter;
 }
 export declare class DeferredToolProtocol implements ToolProtocol {
@@ -82,8 +82,8 @@ export declare class DeferredToolProtocol implements ToolProtocol {
     getToolPrompt(): string;
     extractToolCalls(_text: string, streamedCalls: PendingToolCall[]): PendingToolCall[];
     rewriteToolCall(tc: PendingToolCall): PendingToolCall;
-    recordAssistant(conv: ConversationState, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
-    recordResults(conv: ConversationState, results: ToolResult[]): void;
+    recordAssistant(conv: LiveView, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
+    recordResults(conv: LiveView, results: ToolResult[]): void;
     createStreamFilter(): null;
 }
 export declare class DeferredLookupProtocol implements ToolProtocol {
@@ -97,8 +97,8 @@ export declare class DeferredLookupProtocol implements ToolProtocol {
     getToolPrompt(): string;
     extractToolCalls(_text: string, streamedCalls: PendingToolCall[]): PendingToolCall[];
     rewriteToolCall(tc: PendingToolCall): PendingToolCall;
-    recordAssistant(conv: ConversationState, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
-    recordResults(conv: ConversationState, results: ToolResult[]): void;
+    recordAssistant(conv: LiveView, text: string, toolCalls: PendingToolCall[], extras?: Record<string, unknown>): void;
+    recordResults(conv: LiveView, results: ToolResult[]): void;
     createStreamFilter(): null;
     getProtocolTools(): ToolDefinition[];
 }

package/dist/cli/auth/discover.js

@@ -1,15 +1,20 @@
 /** Bootstrap a throwaway core to enumerate provider ids extensions
  *  would register, so `auth list` shows ids the user hasn't keyed yet. */
+import * as path from "node:path";
 import { createCore } from "../../core/index.js";
 import { activateAgent } from "../../agent/index.js";
 import { loadExtensions } from "../../core/extension-loader.js";
 import { loadBuiltinExtensions } from "../../extensions/index.js";
-import { getSettings } from "../../core/settings.js";
+import { CONFIG_DIR, getSettings } from "../../core/settings.js";
+const EXT_DIR = path.join(CONFIG_DIR, "extensions");
+const BARE_IMPORT_RE = /Cannot find (?:package|module) ['"]agent-sh\/[^'"]+['"]/;
 let cached = null;
 export async function discoverExtensionProviders() {
     if (cached)
         return cached;
     const core = createCore({});
+    const errors = [];
+    core.bus.on("ui:error", ({ message }) => { errors.push(message); });
     try {
         const ctx = core.extensionContext({ quit: () => { } });
         activateAgent(ctx);
@@ -17,6 +22,18 @@ export async function discoverExtensionProviders() {
         await loadExtensions(ctx).catch(() => { });
         const { providers } = core.bus.emitPipe("agent:providers", { providers: [] });
         cached = providers.map((p) => ({ id: p.id, noAuth: p.noAuth }));
+        if (errors.length > 0) {
+            process.stderr.write(`\n[agent-sh] extension load errors during provider discovery:\n`);
+            for (const msg of errors) {
+                process.stderr.write(`  - ${msg}\n`);
+                if (BARE_IMPORT_RE.test(msg) && msg.includes(EXT_DIR)) {
+                    process.stderr.write(`      ↳ Single-file extensions can't runtime-import agent-sh modules from ${EXT_DIR}.\n` +
+                        `        Use ctx.call(...) for runtime needs, or convert to a directory extension\n` +
+                        `        with its own package.json + node_modules.\n`);
+                }
+            }
+            process.stderr.write(`\n`);
+        }
         return cached;
     }
     finally {

package/dist/cli/index.js

@@ -4,6 +4,7 @@ import { activateAgent } from "../agent/index.js";
 import { createCore } from "../core/index.js";
 import { palette as p } from "../utils/palette.js";
 import { loadBuiltinExtensions } from "../extensions/index.js";
+import activateRollingHistory from "../agent/extensions/rolling-history/index.js";
 import { loadExtensions } from "../core/extension-loader.js";
 import { getSettings } from "../core/settings.js";
 import { dispatchSubcommand } from "./subcommands.js";
@@ -95,7 +96,9 @@ async function main() {
     registerShellHandlers(extCtx);
     activateAgent(extCtx);
     // Load before spawning the shell so PS1 lands below the banner.
-    await loadBuiltinExtensions(extCtx, getSettings().disabledBuiltins);
+    const settings = getSettings();
+    await loadBuiltinExtensions(extCtx, settings.disabledBuiltins);
+    activateRollingHistory(extCtx);
     const loadExtensionsTimeoutMs = 10000;
     let loadedExtensions = [];
     await Promise.race([
@@ -124,7 +127,6 @@ async function main() {
             hint);
         process.exit(1);
     }
-    const settings = getSettings();
     if (settings.startupBanner !== false) {
         const termW = process.stdout.columns || 80;
         const bannerW = Math.min(termW, 60);

package/dist/core/index.d.ts

@@ -20,7 +20,6 @@ export type { ColorPalette } from "../utils/palette.js";
 export type { AgentBackend, ToolDefinition, ImageContent } from "../agent/types.js";
 export { runSubagent, type SubagentOptions } from "../agent/subagent.js";
 export { LlmClient } from "../agent/llm-client.js";
-export { HistoryFile, InMemoryHistory, NoopHistory, type HistoryAdapter } from "../agent/history-file.js";
 export type { NuclearEntry } from "../agent/nuclear-form.js";
 export { compileSearchRegex, matchEntry, formatNuclearLine } from "../agent/nuclear-form.js";
 export interface AgentShellCore {

package/dist/core/index.js

@@ -19,7 +19,6 @@ export { EventBus } from "./event-bus.js";
 export { palette, setPalette, resetPalette } from "../utils/palette.js";
 export { runSubagent } from "../agent/subagent.js";
 export { LlmClient } from "../agent/llm-client.js";
-export { HistoryFile, InMemoryHistory, NoopHistory } from "../agent/history-file.js";
 export { compileSearchRegex, matchEntry, formatNuclearLine } from "../agent/nuclear-form.js";
 export function createCore(config) {
     const bus = new EventBus();

package/dist/core/settings.d.ts

@@ -65,7 +65,7 @@ export interface Settings {
      * that boot agent-sh as a library against a specific working tree).
      */
     historyFilePath?: string;
-    /** Auto-compact threshold as fraction of conversation budget (0-1, default 0.5). */
+    autoCompact?: boolean;
     autoCompactThreshold?: number;
     /** Max command output lines shown inline in TUI. */
     maxCommandOutputLines?: number;
@@ -116,8 +116,12 @@ export interface Settings {
     disabledExtensions?: string[];
 }
 declare const DEFAULTS: Required<Settings>;
+export type SettingSource = "session" | "env" | "file" | "default";
 /** Load settings from disk (cached after first call). */
 export declare function getSettings(): Settings & typeof DEFAULTS;
+export declare function setSessionOverlay(patch: Partial<Settings>): void;
+export declare function clearSessionOverlay(...keys: (keyof Settings)[]): void;
+export declare function getSettingSource(key: keyof Settings): SettingSource;
 /**
  * Get settings for an extension, namespaced under its key in settings.json.
  *

package/dist/core/settings.js

@@ -28,6 +28,7 @@ const DEFAULTS = {
     historyMaxBytes: 104857600, // 100MB — history is only accessed via search/expand, never loaded wholesale
     historyStartupEntries: 100,
     historyFilePath: undefined,
+    autoCompact: true,
     autoCompactThreshold: 0.5,
     maxCommandOutputLines: 3,
     readOutputMaxLines: 10,
@@ -41,6 +42,42 @@ const DEFAULTS = {
     disabledExtensions: [],
 };
 let cached = null;
+let envOverrides = null;
+let sessionOverlay = {};
+function parseBoolEnv(raw, key) {
+    if (raw === undefined)
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === "on" || v === "true" || v === "1")
+        return true;
+    if (v === "off" || v === "false" || v === "0")
+        return false;
+    console.error(`[agent-sh] Warning: ${key}="${raw}" is not a boolean (off|on|true|false|0|1); ignoring.`);
+    return undefined;
+}
+function parseUnitFloatEnv(raw, key) {
+    if (raw === undefined)
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+        console.error(`[agent-sh] Warning: ${key}="${raw}" is not a number in [0, 1]; ignoring.`);
+        return undefined;
+    }
+    return n;
+}
+function loadEnvOverrides() {
+    if (envOverrides)
+        return envOverrides;
+    const out = {};
+    const ac = parseBoolEnv(process.env.AGENT_SH_AUTO_COMPACT, "AGENT_SH_AUTO_COMPACT");
+    if (ac !== undefined)
+        out.autoCompact = ac;
+    const th = parseUnitFloatEnv(process.env.AGENT_SH_AUTO_COMPACT_THRESHOLD, "AGENT_SH_AUTO_COMPACT_THRESHOLD");
+    if (th !== undefined)
+        out.autoCompactThreshold = th;
+    envOverrides = out;
+    return envOverrides;
+}
 /** Load settings from disk (cached after first call). */
 export function getSettings() {
     if (!cached) {
@@ -55,7 +92,29 @@ export function getSettings() {
             cached = {};
         }
     }
-    return { ...DEFAULTS, ...cached };
+    return { ...DEFAULTS, ...cached, ...loadEnvOverrides(), ...sessionOverlay };
+}
+export function setSessionOverlay(patch) {
+    sessionOverlay = { ...sessionOverlay, ...patch };
+}
+export function clearSessionOverlay(...keys) {
+    if (keys.length === 0) {
+        sessionOverlay = {};
+        return;
+    }
+    const next = { ...sessionOverlay };
+    for (const k of keys)
+        delete next[k];
+    sessionOverlay = next;
+}
+export function getSettingSource(key) {
+    if (key in sessionOverlay)
+        return "session";
+    if (key in loadEnvOverrides())
+        return "env";
+    if (cached && key in cached)
+        return "file";
+    return "default";
 }
 /**
  * Get settings for an extension, namespaced under its key in settings.json.
@@ -78,6 +137,8 @@ export function getExtensionSettings(namespace, defaults) {
 /** Reset cached settings (for testing or after external edit). */
 export function reloadSettings() {
     cached = null;
+    envOverrides = null;
+    sessionOverlay = {};
 }
 /**
  * Deep-merge a patch into ~/.agent-sh/settings.json on disk.

package/dist/extensions/index.d.ts

@@ -3,6 +3,7 @@
  * Module-owned built-ins activate inline:
  *   shell-context, tui-renderer → registerShellHandlers (src/shell/)
  *   ash (a specific backend)    → activateAgent         (src/agent/)
+ *   rolling-history              → activateRollingHistory (src/cli/)
  *   backend registry             → createCore           (src/core/)
  */
 import type { ExtensionContext } from "../shell/host-types.js";

package/dist/shell/events.d.ts

@@ -67,6 +67,7 @@ declare module "../core/event-bus.js" {
             data: string;
             consumed: boolean;
         };
+        "input:redraw": Record<string, never>;
         "compositor:write": {
             stream: string;
             text: string;

package/dist/shell/input-handler.js

@@ -35,6 +35,10 @@ export class InputHandler {
             if (this.activeMode)
                 this.drawPrompt();
         });
+        this.bus.on("input:redraw", () => {
+            if (this.activeMode)
+                this.renderModeInput();
+        });
         this.bus.on("input-mode:register", (config) => {
             this.registerMode(config);
         });