@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/runtime/runtime-catalog.js

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { BUILTIN_CATALOG, buildAllModels, createProvider, parseCatalogYAML, } from "@chengchenccc/ai";
+/** Candidate file paths for runtime model config, in priority order. */
+function catalogPaths(env) {
+    const paths = [];
+    if (env.OMA_HOME)
+        paths.push(join(env.OMA_HOME, "models.yml"));
+    paths.push(join(homedir(), ".oma", "models.yml"));
+    paths.push(resolve(".oma", "models.yml"));
+    return paths;
+}
+/** Read and merge the first available runtime models.yml with BUILTIN_CATALOG.
+ *  Returns BUILTIN_CATALOG unchanged if no file is found. */
+export function loadRuntimeCatalog(env = process.env) {
+    for (const p of catalogPaths(env)) {
+        if (!existsSync(p))
+            continue;
+        const runtime = parseCatalogYAML(readFileSync(p, "utf-8"));
+        return mergeCatalogs(BUILTIN_CATALOG, runtime);
+    }
+    return BUILTIN_CATALOG;
+}
+/** Deep-merge two catalogs: override providers/models win; new entries added.
+ *  Provider-level fields (api, baseUrl, apiKeyEnv) are overridden when present.
+ *  Within a provider, models merge by id. */
+export function mergeCatalogs(base, override) {
+    const providers = { ...base.providers };
+    for (const [pid, oSpec] of Object.entries(override.providers)) {
+        const bSpec = providers[pid];
+        providers[pid] = bSpec
+            ? { ...bSpec, ...oSpec, models: mergeModelLists(bSpec.models, oSpec.models) }
+            : oSpec;
+    }
+    return { providers };
+}
+function mergeModelLists(base, override) {
+    const byId = new Map();
+    for (const m of base)
+        byId.set(m.id, m);
+    for (const m of override)
+        byId.set(m.id, m);
+    return [...byId.values()];
+}
+/** Register every provider in the catalog whose apiKey env var is set.
+ *  Providers without credentials are silently skipped. */
+export function registerProvidersFromCatalog(runtime, catalog, env) {
+    const built = buildAllModels(catalog);
+    for (const [pid, entry] of Object.entries(built)) {
+        const apiKey = resolveApiKey(pid, entry.spec.apiKeyEnv, entry.spec.apiKey, env);
+        if (!apiKey)
+            continue;
+        const baseUrl = resolveBaseUrl(pid, entry.spec.baseUrl, env);
+        runtime.registerProvider(createProvider({
+            id: pid,
+            name: pid,
+            baseUrl,
+            auth: { apiKey, ...(entry.spec.headers ? { headers: entry.spec.headers } : {}) },
+            models: entry.models,
+        }));
+    }
+}
+/** Resolve API key: env var first, then the provider's inline apiKey from
+ *  models.yml, then provider-specific fallbacks (ANTHROPIC_AUTH_TOKEN as a
+ *  fallback for ANTHROPIC_API_KEY — proxy users depend on it). */
+function resolveApiKey(pid, primaryEnv, inlineApiKey, env) {
+    const key = env[primaryEnv];
+    if (key)
+        return key;
+    if (inlineApiKey)
+        return inlineApiKey;
+    // ponytail: anthropic-specific fallback, delete when ProviderSpec gets
+    // a generic fallbackEnv field.
+    if (pid === "anthropic")
+        return env.ANTHROPIC_AUTH_TOKEN;
+    return undefined;
+}
+/** Resolve baseUrl with env override (ANTHROPIC_BASE_URL for proxy setups). */
+function resolveBaseUrl(pid, specBaseUrl, env) {
+    // ponytail: anthropic-specific override, delete when ProviderSpec gets
+    // a generic baseUrlEnv field.
+    if (pid === "anthropic" && env.ANTHROPIC_BASE_URL)
+        return env.ANTHROPIC_BASE_URL;
+    let url = specBaseUrl.trim().replace(/\/+$/, "");
+    if (!url.endsWith("/v1"))
+        url += "/v1";
+    return url;
+}

package/dist/core/runtime/stream-rules.d.ts

@@ -0,0 +1,9 @@
+import type { StreamRule } from "../agent-runtime.js";
+/** Load TTSR-style stream rules (absorbed from oh-my-pi) from
+ * `<root>/.oma/rules/*.md`. Frontmatter `condition: <regex>` is required;
+ * the body below the frontmatter is the reminder text injected when the
+ * rule matches mid-stream. Rule name = filename without `.md`.
+ * Fail-open: an unreadable file, missing condition, empty body, or invalid
+ * regex is skipped — rules must never block session startup. */
+export declare function loadStreamRules(root: string): StreamRule[];
+//# sourceMappingURL=stream-rules.d.ts.map

package/dist/core/runtime/stream-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-rules.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/stream-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;;gEAKgE;AAChE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CA+B1D"}

package/dist/core/runtime/stream-rules.js

@@ -0,0 +1,44 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Load TTSR-style stream rules (absorbed from oh-my-pi) from
+ * `<root>/.oma/rules/*.md`. Frontmatter `condition: <regex>` is required;
+ * the body below the frontmatter is the reminder text injected when the
+ * rule matches mid-stream. Rule name = filename without `.md`.
+ * Fail-open: an unreadable file, missing condition, empty body, or invalid
+ * regex is skipped — rules must never block session startup. */
+export function loadStreamRules(root) {
+    const dir = join(root, ".oma", "rules");
+    let files;
+    try {
+        files = readdirSync(dir)
+            .filter((f) => f.endsWith(".md"))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+    const rules = [];
+    for (const file of files) {
+        try {
+            const content = readFileSync(join(dir, file), "utf8");
+            const frontmatter = content.match(/^---\n([\s\S]*?)\n---/)?.[1];
+            const condition = frontmatter?.match(/^condition:\s*(.+)$/m)?.[1]?.trim();
+            if (!condition)
+                continue;
+            const message = content.replace(/^---\n[\s\S]*?\n---\n?/, "").trim();
+            if (!message)
+                continue;
+            rules.push({
+                name: file.replace(/\.md$/, ""),
+                // No flags: global regexes carry lastIndex state across .test()
+                // calls and would silently skip matches.
+                pattern: new RegExp(condition),
+                message,
+            });
+        }
+        catch {
+            /* invalid rule file: skipped */
+        }
+    }
+    return rules;
+}

package/dist/core/runtime/title.d.ts

@@ -0,0 +1,7 @@
+import { type Message } from "@chengchenccc/message";
+import type { PluginRuntime } from "./plugin-runtime.js";
+export declare function isLowSignalTitleInput(message: string): boolean;
+export declare function normalizeGeneratedTitle(raw: string): string | null;
+export declare function buildTitleContext(msgs: Message[], maxTurns?: number): string;
+export declare function generateTitle(rt: PluginRuntime, context: string): Promise<string | null>;
+//# sourceMappingURL=title.d.ts.map

package/dist/core/runtime/title.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"title.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/title.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AA0CzD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAI9D;AA0BD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAelE;AAID,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,QAAQ,SAAI,GAAG,MAAM,CAOvE;AAID,wBAAsB,aAAa,CAAC,EAAE,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmB9F"}

package/dist/core/runtime/title.js

@@ -0,0 +1,114 @@
+import { extractText } from "@chengchenccc/message";
+// ── Low-signal pre-filter (deterministic, no model call) ──────────────────
+// Absorbed: greetings, single words, and
+// pure filler are skipped without wasting a model call.
+const TITLE_WORD = /\p{L}[\p{L}\p{N}_'-]*/gu;
+const FILLER_TOKENS = new Set([
+    "hi",
+    "hey",
+    "hello",
+    "yo",
+    "sup",
+    "ok",
+    "okay",
+    "yes",
+    "no",
+    "yeah",
+    "thanks",
+    "thank",
+    "thx",
+    "bye",
+    "lol",
+    "haha",
+    "wow",
+    "cool",
+    "nice",
+    "great",
+    "sure",
+    "right",
+    "please",
+    "test",
+    "ping",
+    "你好",
+    "在吗",
+    "测试",
+    "好的",
+    "谢谢",
+    "哈喽",
+    "嗨",
+]);
+export function isLowSignalTitleInput(message) {
+    const tokens = message.toLowerCase().match(TITLE_WORD);
+    if (!tokens)
+        return true;
+    return tokens.every((t) => FILLER_TOKENS.has(t) || /^\d+$/.test(t));
+}
+// ── Prompt (XML tag format + few-shot) ───────────────────────
+const TITLE_SYSTEM_PROMPT = `Write a 3-7 word title for the task.
+
+Answer with only the title inside <title> and </title> tags, nothing before or after.
+If there is no concrete task (greeting, small talk, acknowledgment), output exactly: <title>none</title>
+Capitalize only the first word and proper names.
+
+Examples:
+User: the login button is broken on mobile, can you fix?
+<title>Fix login button on mobile</title>
+
+User: refactor error handling in the API client
+<title>Refactor API error handling</title>
+
+User: hey
+<title>none</title>`;
+// ── Normalization (robust extraction) ────────────────────────
+const MAX_TITLE_CHARS = 80;
+const MAX_TITLE_WORDS = 12;
+const NO_TITLE_SENTINELS = new Set(["none", "（无）", "无"]);
+export function normalizeGeneratedTitle(raw) {
+    const firstLine = raw.trim().split(/\r?\n/, 1)[0]?.trim();
+    if (!firstLine)
+        return null;
+    // Strip XML tags if present
+    const title = firstLine
+        .replace(/^<title>/i, "")
+        .replace(/<\/title>$/i, "")
+        .replace(/^["'「『]|["'」』]$/g, "")
+        .replace(/[.!?。！？]$/, "")
+        .trim();
+    if (!title || NO_TITLE_SENTINELS.has(title.toLowerCase()))
+        return null;
+    // Reject overlong output (model answered instead of titling)
+    if (title.length > MAX_TITLE_CHARS)
+        return null;
+    if ((title.match(TITLE_WORD)?.length ?? 0) > MAX_TITLE_WORDS)
+        return null;
+    return title;
+}
+// ── Context builder ───────────────────────────────────────────────────────
+export function buildTitleContext(msgs, maxTurns = 4) {
+    return msgs
+        .filter((m) => m.role === "user" || m.role === "assistant")
+        .slice(-maxTurns * 2)
+        .map((m) => `${m.role === "user" ? "用户" : "助手"}: ${extractText(m)}`)
+        .filter((line) => line.length > 3)
+        .join("\n");
+}
+// ── Title generation (uses runEphemeralTurn) ──────────────────────────────
+export async function generateTitle(rt, context) {
+    if (!context || context.length < 4)
+        return null;
+    if (isLowSignalTitleInput(context))
+        return null;
+    try {
+        const ephemeral = rt.runEphemeralTurn;
+        if (!ephemeral)
+            return null;
+        const raw = await ephemeral(`${TITLE_SYSTEM_PROMPT}\n\n<conversation>\n${context}\n</conversation>`, { signal: rt.signal });
+        return normalizeGeneratedTitle(raw);
+    }
+    catch (err) {
+        // Silent-null used to hide provider failures entirely — surface them so
+        // "auto title stopped working" is diagnosable from the child's stderr.
+        console.warn(`[oma] auto-title generation failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/dist/core/runtime/todo.d.ts

@@ -0,0 +1,16 @@
+import type { SessionStore } from "../persistence/session-store.js";
+export interface TodoItem {
+    readonly id: string;
+    readonly text: string;
+    readonly status: "pending" | "in_progress" | "done" | "cancelled";
+}
+export interface TodoState {
+    readonly items: readonly TodoItem[];
+}
+/** Read the latest todo state from the current branch. */
+export declare function readTodo(store: SessionStore, sessionId: string): Promise<TodoState>;
+/** Append a new todo state entry. */
+export declare function writeTodo(store: SessionStore, sessionId: string, state: TodoState): Promise<void>;
+/** Merge todo updates: apply changes to current state and persist. */
+export declare function updateTodo(store: SessionStore, sessionId: string, updates: readonly Partial<TodoItem>[]): Promise<TodoState>;
+//# sourceMappingURL=todo.d.ts.map

package/dist/core/runtime/todo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/todo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGpE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,MAAM,GAAG,WAAW,CAAC;CACnE;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC;AAED,0DAA0D;AAC1D,wBAAsB,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CASzF;AAED,qCAAqC;AACrC,wBAAsB,SAAS,CAC7B,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,sEAAsE;AACtE,wBAAsB,UAAU,CAC9B,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,OAAO,CAAC,QAAQ,CAAC,EAAE,GACpC,OAAO,CAAC,SAAS,CAAC,CAcpB"}

package/dist/core/runtime/todo.js

@@ -0,0 +1,40 @@
+/** Read the latest todo state from the current branch. */
+export async function readTodo(store, sessionId) {
+    const branch = await store.readBranch(sessionId);
+    for (let i = branch.length - 1; i >= 0; i--) {
+        const entry = branch[i];
+        if (entry?.type === "todo") {
+            return entry.state;
+        }
+    }
+    return { items: [] };
+}
+/** Append a new todo state entry. */
+export async function writeTodo(store, sessionId, state) {
+    await store.appendBatch(sessionId, {
+        entries: [
+            {
+                type: "todo",
+                state: state,
+                createdAt: Date.now(),
+            },
+        ],
+    });
+}
+/** Merge todo updates: apply changes to current state and persist. */
+export async function updateTodo(store, sessionId, updates) {
+    const current = await readTodo(store, sessionId);
+    const items = [...current.items];
+    for (const update of updates) {
+        const idx = items.findIndex((i) => i.id === update.id);
+        if (idx >= 0) {
+            items[idx] = { ...items[idx], ...update };
+        }
+        else if (update.id && update.text) {
+            items.push({ id: update.id, text: update.text, status: update.status ?? "pending" });
+        }
+    }
+    const newState = { items };
+    await writeTodo(store, sessionId, newState);
+    return newState;
+}

package/dist/core/runtime/tool-filter.d.ts

@@ -0,0 +1,12 @@
+/** --tools filter (CLI): comma-separated tool names; plain names form a
+ *  whitelist (ONLY those run), `!name` entries form a blacklist. Applied to
+ *  the FINAL tool table (native + MCP + plugin) at Run assembly. */
+export interface ToolFilter {
+    /** Present = whitelist mode: only these tools run. */
+    readonly allow?: ReadonlySet<string>;
+    /** Blacklist mode (entries given with `!`): all tools except these. */
+    readonly deny?: ReadonlySet<string>;
+}
+export declare function parseToolFilter(spec: string): ToolFilter;
+export declare function toolFilterAllows(filter: ToolFilter, toolName: string): boolean;
+//# sourceMappingURL=tool-filter.d.ts.map

package/dist/core/runtime/tool-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-filter.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/tool-filter.ts"],"names":[],"mappings":"AAAA;;oEAEoE;AAEpE,MAAM,WAAW,UAAU;IACzB,sDAAsD;IACtD,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACrC;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAUxD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAI9E"}

package/dist/core/runtime/tool-filter.js

@@ -0,0 +1,23 @@
+/** --tools filter (CLI): comma-separated tool names; plain names form a
+ *  whitelist (ONLY those run), `!name` entries form a blacklist. Applied to
+ *  the FINAL tool table (native + MCP + plugin) at Run assembly. */
+export function parseToolFilter(spec) {
+    const names = spec
+        .split(",")
+        .map((n) => n.trim())
+        .filter((n) => n.length > 0);
+    const deny = names.filter((n) => n.startsWith("!")).map((n) => n.slice(1));
+    const allow = names.filter((n) => !n.startsWith("!"));
+    if (allow.length > 0)
+        return { allow: new Set(allow) };
+    if (deny.length > 0)
+        return { deny: new Set(deny) };
+    return {};
+}
+export function toolFilterAllows(filter, toolName) {
+    if (filter.allow)
+        return filter.allow.has(toolName);
+    if (filter.deny)
+        return !filter.deny.has(toolName);
+    return true;
+}

package/dist/core/runtime/tool-pruning.d.ts

@@ -0,0 +1,29 @@
+import type { Message } from "@chengchenccc/message";
+/** Configuration for old tool-result pruning. */
+export interface PruneConfig {
+    /** Protect the most recent N tokens of tool results from pruning. Tools
+     *  whose combined output falls within this window are left intact. */
+    readonly protectTokens: number;
+    /** Only prune if total savings meets this threshold (avoids churning small
+     *  prunes that barely reduce context). */
+    readonly minimumSavings: number;
+    /** Tool names whose results are NEVER pruned. Use
+     *  for tools whose output must remain visible: skill reads, plan files,
+     *  config snapshots. */
+    readonly protectedTools: ReadonlySet<string>;
+}
+/** Prune old tool-result content from a message list.
+ *
+ *  Walks backward from the newest message, accumulating tool-result tokens.
+ *  Once the protect window is exceeded, tool results outside the window are
+ *  truncated to a short summary — the pairing stays intact (the tool_use
+ *  block is never touched) but the verbose output is replaced. Protected
+ *  tools (skills, plans, config) are never pruned.
+ *
+ *  This is a READ-SIDE transform: the stored entries are unchanged. The model
+ *  sees truncated results; the UI trace reads the full original from the store. */
+export declare function pruneOldToolResults(messages: readonly Message[], config?: Partial<PruneConfig>): {
+    messages: Message[];
+    savedTokens: number;
+};
+//# sourceMappingURL=tool-pruning.d.ts.map

package/dist/core/runtime/tool-pruning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-pruning.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/tool-pruning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B;0EACsE;IACtE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;8CAC0C;IAC1C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;4BAEwB;IACxB,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC9C;AAoCD;;;;;;;;;mFASmF;AACnF,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAChC;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAiE9C"}

package/dist/core/runtime/tool-pruning.js

@@ -0,0 +1,105 @@
+const DEFAULT_CONFIG = {
+    protectTokens: 8_000,
+    minimumSavings: 500,
+    protectedTools: new Set(),
+};
+const PRUNED_PREFIX = "[pruned:";
+/** Check whether a message's tool_result blocks have already been pruned. */
+function isAlreadyPruned(message) {
+    if (message.role !== "tool" || !message.blocks)
+        return false;
+    return message.blocks.some((b) => b.type === "tool_result" &&
+        typeof b.content === "string" &&
+        b.content.startsWith(PRUNED_PREFIX));
+}
+/** Estimate token count of a message (same proxy as contextBudget: char/4). */
+function estimateTokens(message) {
+    // Blocks are canonical content; text is a display fallback. When blocks
+    // exist, count their content only — avoids double-counting text+blocks.
+    if (message.blocks && message.blocks.length > 0) {
+        let chars = 0;
+        for (const b of message.blocks) {
+            if (b.type === "tool_result" && typeof b.content === "string")
+                chars += b.content.length;
+            else if (b.type === "text")
+                chars += b.text.length;
+        }
+        return Math.ceil(chars / 4);
+    }
+    return Math.ceil((message.text?.length ?? 0) / 4);
+}
+/** Prune old tool-result content from a message list.
+ *
+ *  Walks backward from the newest message, accumulating tool-result tokens.
+ *  Once the protect window is exceeded, tool results outside the window are
+ *  truncated to a short summary — the pairing stays intact (the tool_use
+ *  block is never touched) but the verbose output is replaced. Protected
+ *  tools (skills, plans, config) are never pruned.
+ *
+ *  This is a READ-SIDE transform: the stored entries are unchanged. The model
+ *  sees truncated results; the UI trace reads the full original from the store. */
+export function pruneOldToolResults(messages, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    let protectedTokens = 0;
+    let savedTokens = 0;
+    // Walk backward: accumulate recent tool output into the protect window.
+    const pruned = [...messages];
+    for (let i = pruned.length - 1; i >= 0; i--) {
+        const msg = pruned[i];
+        if (msg.role !== "tool" || !msg.blocks)
+            continue;
+        if (isAlreadyPruned(msg))
+            continue;
+        // Check if this tool result comes from a protected tool — we need to
+        // find the associated tool_use block to get the tool name. Walk forward
+        // from this tool message's position is wrong — the tool_use is in a
+        // PRIOR assistant message. We match by tool_use_id.
+        const toolResultBlock = msg.blocks.find((b) => b.type === "tool_result");
+        if (toolResultBlock?.type !== "tool_result")
+            continue;
+        // Find the associated tool_use to check if the tool is protected.
+        let toolName;
+        for (let j = i - 1; j >= 0; j--) {
+            const prev = pruned[j];
+            if (prev.role !== "assistant" || !prev.blocks)
+                continue;
+            const use = prev.blocks.find((b) => b.type === "tool_use" && b.id === toolResultBlock.tool_use_id);
+            if (use && use.type === "tool_use") {
+                toolName = use.name;
+                break;
+            }
+        }
+        // Protected tools are never pruned.
+        if (toolName && cfg.protectedTools.has(toolName))
+            continue;
+        const msgTokens = estimateTokens(msg);
+        protectedTokens += msgTokens;
+        // Within the protect window — leave intact.
+        if (protectedTokens <= cfg.protectTokens)
+            continue;
+        // Outside the window — truncate the tool_result content.
+        const originalTokens = msgTokens;
+        const summary = truncateContent(typeof msg.text === "string" ? msg.text : "", toolResultBlock.content);
+        pruned[i] = {
+            ...msg,
+            text: summary,
+            blocks: msg.blocks.map((b) => b.type === "tool_result" && b.tool_use_id === toolResultBlock.tool_use_id
+                ? { ...b, content: summary }
+                : b),
+        };
+        const prunedTokens = estimateTokens(pruned[i]);
+        savedTokens += originalTokens - prunedTokens;
+    }
+    if (savedTokens < cfg.minimumSavings) {
+        return { messages: [...messages], savedTokens: 0 };
+    }
+    return { messages: pruned, savedTokens };
+}
+/** Produce a short summary of pruned content: first 200 chars + line count. */
+function truncateContent(text, content) {
+    const source = content || text;
+    if (source.length <= 200)
+        return source;
+    const lines = source.split("\n").length;
+    return `${PRUNED_PREFIX} ${lines} lines, ${source.length} chars] ${source.slice(0, 200)}…`;
+}

package/dist/core/session/input-history.d.ts

@@ -0,0 +1,8 @@
+/** Newest first. Missing/corrupt file yields []. */
+export declare function loadInputHistory(): string[];
+/** Pure insert: newest first, consecutive duplicates skipped, older exact
+ *  duplicates hoisted (removed from their old position), capped at CAP.
+ *  Returns the SAME array reference when nothing changed (skip-write signal). */
+export declare function appendInputHistory(existing: readonly string[], prompt: string): readonly string[];
+export declare function saveInputHistory(entries: readonly string[]): void;
+//# sourceMappingURL=input-history.d.ts.map

package/dist/core/session/input-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-history.d.ts","sourceRoot":"","sources":["../../../src/core/session/input-history.ts"],"names":[],"mappings":"AAgBA,oDAAoD;AACpD,wBAAgB,gBAAgB,IAAI,MAAM,EAAE,CAQ3C;AAED;;iFAEiF;AACjF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAOjG;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAGjE"}

package/dist/core/session/input-history.js

@@ -0,0 +1,41 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { agentDir } from "./session-file.js";
+/** Persistent prompt history (pi's HistoryStorage, lazy form): a plain JSON
+ * array instead of SQLite+FTS — a few hundred short strings do not need an
+ * index, and substring filtering covers the search overlay fine.
+ * ponytail: global across workspaces (pi tracks cwd); scope per-cwd when
+ * cross-workspace noise actually bothers anyone. */
+const CAP = 500;
+function historyPath() {
+    return join(agentDir(), "history.json");
+}
+/** Newest first. Missing/corrupt file yields []. */
+export function loadInputHistory() {
+    try {
+        const raw = JSON.parse(readFileSync(historyPath(), "utf8"));
+        if (!Array.isArray(raw))
+            return [];
+        return raw.filter((v) => typeof v === "string");
+    }
+    catch {
+        return [];
+    }
+}
+/** Pure insert: newest first, consecutive duplicates skipped, older exact
+ *  duplicates hoisted (removed from their old position), capped at CAP.
+ *  Returns the SAME array reference when nothing changed (skip-write signal). */
+export function appendInputHistory(existing, prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed)
+        return existing;
+    if (existing[0] === trimmed)
+        return existing;
+    const rest = existing.filter((p) => p !== trimmed);
+    const next = [trimmed, ...rest];
+    return next.length > CAP ? next.slice(0, CAP) : next;
+}
+export function saveInputHistory(entries) {
+    mkdirSync(agentDir(), { recursive: true });
+    writeFileSync(historyPath(), JSON.stringify(entries), "utf8");
+}

package/dist/core/session/session-file.d.ts

@@ -0,0 +1,84 @@
+/** The oma's own session store (ADR 0003 decision 6): parentId-
+ *  chained JSONL, same shape family as pi/omp. The CLI owns its session;
+ *  the product stores only the session id (branch.cliSessionRef).
+ *
+ *  Typing: the wire contract (agent-backend transport) deliberately models
+ *  messages as `Record<string, unknown>` - the durable file keeps that same
+ *  wire-loose shape. Strict `Message` typing is the runtime's job, applied
+ *  where the loop consumes them, so this module performs no type bypass. */
+/** Oma agent root (pi's getAgentDir): ~/.oma by default, overridable with
+ *  OMA_CODING_AGENT_DIR (pi's PI_CODING_AGENT_DIR). Everything under it —
+ *  sessions today — follows the override. */
+export declare function agentDir(): string;
+/** Sessions root: <agentDir>/sessions. */
+export declare function sessionsRoot(): string;
+/** Session directory for a specific workspace root (pi's per-cwd dir). */
+export declare function sessionDirFor(workspaceRoot: string): string;
+/** Default session store, isolated per workspace (pi's model): sessions
+ *  live under <agentDir>/sessions/--<cwd-encoded>--/ so different
+ *  workspaces never see each other's sessions. OMA_SESSION_DIR overrides
+ *  the WHOLE store as a flat directory (pi's PI_CODING_AGENT_SESSION_DIR). */
+export declare function sessionDir(): string;
+export declare function sessionPath(id: string): string;
+export declare function newSessionId(): string;
+/** Load the transcript messages of a session file (wire-loose shape).
+ *  Missing/corrupt files yield [] (the caller falls back to a fresh
+ *  session). A compaction event REPLACES everything recorded before it:
+ *  the summary becomes one context message, later turns stay live — so a
+ *  resumed session does not re-inflate the context it already compacted. */
+export declare function loadSessionMessages(id: string, dir?: string): Record<string, unknown>[];
+export interface SessionSummary {
+    readonly id: string;
+    readonly modifiedAt: number;
+    /** Auto title from the last completed run's title event, when present. */
+    readonly title?: string;
+    /** First user message text (truncated), fallback when no title exists. */
+    readonly preview: string;
+    /** Workspace root the session was created in (from the file header's
+     *  cwd field); present for cross-workspace listings. */
+    readonly workspace?: string;
+    /** Present when this session was forked from another: the parent id
+     *  (pi's fork dot in the session selector). */
+    readonly forkOf?: string;
+}
+/** Session files of the current workspace, newest first. */
+export declare function listSessions(): SessionSummary[];
+/** Session files across EVERY workspace, newest first. Covers both the
+ *  default layout (<agentDir>/sessions/--<cwd>--/*.jsonl) and an explicit
+ *  flat OMA_SESSION_DIR. Each summary carries the workspace it belongs to
+ *  (pi's session selector "all" scope). */
+export declare function listAllSessions(): SessionSummary[];
+/** Append a title event: the session's display title, auto-generated by the
+ *  loop after each completed run. Last one wins in listings. Also the
+ *  primitive for /rename: appending a new title overrides the display. */
+export declare function appendSessionTitle(id: string, title: string, dir?: string): void;
+/** Delete a session file. Returns false when it did not exist. */
+export declare function deleteSession(id: string, dir?: string): boolean;
+/** Rename a session's display title (last-wins title event). Returns false
+ *  when the session file does not exist. */
+export declare function renameSession(id: string, title: string, dir?: string): boolean;
+/** Append a compaction event: records that the run compacted everything
+ *  recorded so far in this file into `summary`. Must be called AFTER the
+ *  turn's messages are appended. */
+export declare function appendSessionCompaction(id: string, summary: string, dir?: string): void;
+export interface SessionBranchNode {
+    readonly id: string;
+    readonly parentId: string | null;
+    readonly role: string;
+    readonly text: string;
+    readonly depth: number;
+    /** 1-based user-message ordinal when this node is a user message (fork anchor). */
+    readonly ordinal?: number;
+}
+/** Read the durable event tree of one session as parentId-chained message
+ *  nodes (used by the TUI branch-tree fork overlay). Only message events
+ *  carry an id; corrupt lines are skipped. */
+export declare function loadSessionBranchNodes(id: string, dir?: string): SessionBranchNode[];
+/** Fork a session at the Nth user message (1-based) — the existing /fork
+ *  semantics. */
+export declare function forkSession(id: string, ordinal: number, dir?: string): string | null;
+/** Fork a session through a specific branch node (message event id). The new
+ *  session contains every event up to and INCLUDING that node. */
+export declare function forkSessionAtEvent(id: string, eventId: string, dir?: string): string | null;
+export declare function appendSessionMessages(id: string, cwd: string, messages: readonly unknown[], dir?: string): void;
+//# sourceMappingURL=session-file.d.ts.map