@oh-my-pi/pi-coding-agent 15.5.15 → 15.6.0

package/dist/types/modes/ultrathink.d.ts

@@ -4,7 +4,7 @@ export declare const ULTRATHINK_NOTICE: string;
 export declare function containsUltrathink(text: string): boolean;
 /**
  * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
- * Adds only zero-width SGR escapes — the visible width is unchanged — and returns
- * the input untouched when the keyword is absent.
+ * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
+ * gradient resolves smoothly regardless of casing or match length.
  */
-export declare function highlightUltrathink(text: string): string;
+export declare const highlightUltrathink: (text: string) => string;

package/dist/types/modes/utils/keybinding-matchers.d.ts

@@ -6,5 +6,10 @@
  * keybindings registered. In that case, fall back to raw Escape matching.
  */
 export declare function matchesAppInterrupt(data: string): boolean;
+/** Match the generic selector cancel keybinding. */
 export declare function matchesSelectCancel(data: string): boolean;
+/** Match the generic selector up-navigation keybinding. */
+export declare function matchesSelectUp(data: string): boolean;
+/** Match the generic selector down-navigation keybinding. */
+export declare function matchesSelectDown(data: string): boolean;
 export declare function matchesAppExternalEditor(data: string): boolean;

package/dist/types/sdk.d.ts

@@ -13,6 +13,7 @@ import { type FileSlashCommand } from "./extensibility/slash-commands";
 import type { HindsightSessionState } from "./hindsight/state";
 import { type LocalProtocolOptions } from "./internal-urls";
 import { MCPManager, type MCPToolsLoadResult } from "./mcp";
+import { type MnemosyneSessionState } from "./mnemosyne/state";
 import { AgentRegistry } from "./registry/agent-registry";
 import { AgentSession } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";
@@ -97,6 +98,8 @@ export interface CreateAgentSessionOptions {
     taskDepth?: number;
     /** Parent Hindsight state to alias for subagent memory tools. */
     parentHindsightSessionState?: HindsightSessionState;
+    /** Parent Mnemosyne state to alias for subagent memory tools. */
+    parentMnemosyneSessionState?: MnemosyneSessionState;
     /** Pre-allocated agent identity for IRC routing. Default: "0-Main" for top-level, parentTaskPrefix-derived for sub. */
     agentId?: string;
     /** Display name for the agent in IRC. Default: "main" or "sub". */

package/dist/types/session/agent-session.d.ts

@@ -35,6 +35,7 @@ import { type FileSlashCommand } from "../extensibility/slash-commands";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
+import { type MnemosyneSessionState } from "../mnemosyne/state";
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry } from "../registry/agent-registry";
 import { type SecretObfuscator } from "../secrets/obfuscator";
@@ -243,6 +244,20 @@ export interface RoleModelCycleResult {
     thinkingLevel: ThinkingLevel | undefined;
     role: string;
 }
+/** A configured role resolved to a concrete model, used by role cycling and
+ *  the plan-approval model slider. */
+export interface ResolvedRoleModel {
+    role: string;
+    model: Model;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel: boolean;
+}
+/** The set of resolvable role models plus the index of the currently active
+ *  one within {@link ResolvedRoleModel.role} order. */
+export interface RoleModelCycle {
+    models: ResolvedRoleModel[];
+    currentIndex: number;
+}
 /** Session statistics for /session command */
 export interface SessionStats {
     sessionFile: string | undefined;
@@ -294,6 +309,7 @@ export declare class AgentSession {
     get providerSessionState(): Map<string, ProviderSessionState>;
     getHindsightSessionState(): HindsightSessionState | undefined;
     setHindsightSessionState(state: HindsightSessionState | undefined): HindsightSessionState | undefined;
+    getMnemosyneSessionState(): MnemosyneSessionState | undefined;
     /** TTSR manager for time-traveling stream rules */
     get ttsrManager(): TtsrManager | undefined;
     /** Whether a TTSR abort is pending (stream was aborted to inject rules) */
@@ -607,6 +623,23 @@ export declare class AgentSession {
      * @returns The new model info, or undefined if only one model available
      */
     cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
+    /**
+     * Resolve the configured role models in the given order plus the index of
+     * the currently active one. Roles that have no configured model, or whose
+     * configured model is not currently available, are skipped. The `default`
+     * role falls back to the active model when no explicit assignment exists.
+     *
+     * Returns `undefined` only when there is no current model or no available
+     * models at all; an empty `models` array is never returned (callers should
+     * still guard on `models.length`).
+     */
+    getRoleModelCycle(roleOrder: readonly string[]): RoleModelCycle | undefined;
+    /**
+     * Apply a resolved role model as the active model, persisting the choice to
+     * settings under its role. Mirrors the non-temporary branch of
+     * {@link cycleRoleModels} and is shared with the plan-approval model slider.
+     */
+    applyRoleModel(entry: ResolvedRoleModel): Promise<void>;
     /**
      * Cycle through configured role models in a fixed order.
      * Skips missing roles.

package/dist/types/system-prompt.d.ts

@@ -82,6 +82,8 @@ export interface BuildSystemPromptOptions {
     secretsEnabled?: boolean;
     /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
     workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
+    /** Whether the local memory://root summary is active. */
+    memoryRootEnabled?: boolean;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {

package/dist/types/task/executor.d.ts

@@ -11,6 +11,7 @@ import { type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
 import type { MCPManager } from "../mcp/manager";
+import type { MnemosyneSessionState } from "../mnemosyne/state";
 import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
 import type { ContextFileEntry } from "../tools";
@@ -64,6 +65,7 @@ export interface ExecutorOptions {
      */
     parentArtifactManager?: ArtifactManager;
     parentHindsightSessionState?: HindsightSessionState;
+    parentMnemosyneSessionState?: MnemosyneSessionState;
     /** Parent agent's eval executor session id. Subagents reuse it so eval state is shared. */
     parentEvalSessionId?: string;
     /**

package/dist/types/task/render.d.ts

@@ -5,7 +5,11 @@ import type { TaskParams, TaskToolDetails } from "./types";
 /**
  * Render the tool call arguments.
  */
-export declare function renderCall(args: TaskParams, _options: RenderResultOptions, theme: Theme): Component;
+export declare function renderCall(args: TaskParams, options: RenderResultOptions & {
+    renderContext?: {
+        hasResult?: boolean;
+    };
+}, theme: Theme): Component;
 /**
  * Render the tool result.
  */

package/dist/types/tiny/models.d.ts

@@ -0,0 +1,185 @@
+/** Default session-title model: the online pi/smol path (no local download / CPU inference). */
+export declare const ONLINE_TINY_TITLE_MODEL_KEY = "online";
+/** Local model the `tiny-models` CLI downloads when none is named. Not the session-title default — that is {@link ONLINE_TINY_TITLE_MODEL_KEY}. */
+export declare const DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY = "lfm2-700m";
+export interface TinyTitleLocalModelSpec {
+    key: string;
+    repo: string;
+    dtype: "q4";
+    label: string;
+    description: string;
+    contextNote: string;
+}
+export declare const TINY_TITLE_LOCAL_MODELS: readonly [{
+    readonly key: "lfm2-350m";
+    readonly repo: "onnx-community/LFM2-350M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 350M";
+    readonly description: "Recommended local model; best speed/quality balance, about 212 MB cached.";
+    readonly contextNote: "Best local default from the CPU title-generation spike.";
+}, {
+    readonly key: "qwen3-0.6b";
+    readonly repo: "onnx-community/Qwen3-0.6B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 0.6B";
+    readonly description: "Most robust local option; slower first load, about 500 MB cached.";
+    readonly contextNote: "Use when title quality matters more than local startup cost.";
+}, {
+    readonly key: "gemma-270m";
+    readonly repo: "onnx-community/gemma-3-270m-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 270M";
+    readonly description: "Smallest viable local option; lower quality, lowest cache footprint.";
+    readonly contextNote: "Use on constrained machines that still need local titles.";
+}, {
+    readonly key: "qwen2.5-0.5b";
+    readonly repo: "onnx-community/Qwen2.5-0.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 0.5B";
+    readonly description: "Balanced local fallback; moderate quality and cache footprint.";
+    readonly contextNote: "Useful when Qwen3 is too heavy but Gemma quality is insufficient.";
+}, {
+    readonly key: "lfm2-700m";
+    readonly repo: "onnx-community/LFM2-700M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 700M";
+    readonly description: "Highest-quality local option; larger and slower than LFM2 350M.";
+    readonly contextNote: "Use when local title quality is preferred over startup cost.";
+}];
+export declare const TINY_TITLE_MODEL_VALUES: readonly ["online", "lfm2-350m", "qwen3-0.6b", "gemma-270m", "qwen2.5-0.5b", "lfm2-700m"];
+export type TinyTitleModelKey = (typeof TINY_TITLE_MODEL_VALUES)[number];
+export type TinyTitleLocalModelKey = (typeof TINY_TITLE_LOCAL_MODELS)[number]["key"];
+export declare const TINY_TITLE_MODEL_OPTIONS: ({
+    value: "online";
+    label: string;
+    description: string;
+} | {
+    value: "gemma-270m" | "lfm2-350m" | "lfm2-700m" | "qwen2.5-0.5b" | "qwen3-0.6b";
+    label: "Gemma 270M" | "LFM2 350M" | "LFM2 700M" | "Qwen2.5 0.5B" | "Qwen3 0.6B";
+    description: "Balanced local fallback; moderate quality and cache footprint." | "Highest-quality local option; larger and slower than LFM2 350M." | "Most robust local option; slower first load, about 500 MB cached." | "Recommended local model; best speed/quality balance, about 212 MB cached." | "Smallest viable local option; lower quality, lowest cache footprint.";
+})[];
+export declare function isTinyTitleLocalModelKey(value: string): value is TinyTitleLocalModelKey;
+export declare function getTinyTitleModelSpec(key: TinyTitleLocalModelKey): (typeof TINY_TITLE_LOCAL_MODELS)[number];
+/** Default memory model: the online path (the configured smol / remote LLM; no local download). */
+export declare const ONLINE_MEMORY_MODEL_KEY = "online";
+/** Recommended local model for memory tasks when none is named. */
+export declare const DEFAULT_MEMORY_LOCAL_MODEL_KEY = "qwen3-1.7b";
+/**
+ * Local models for Mnemosyne memory tasks (fact extraction + consolidation).
+ * These are larger (1B-1.7B) than the title models: structured extraction and
+ * faithful summarization need more capacity than 3-6 word titles. All q4, CPU.
+ * Ranking/recipe rationale lives in docs/local-models.md.
+ */
+export declare const TINY_MEMORY_LOCAL_MODELS: readonly [{
+    readonly key: "qwen3-1.7b";
+    readonly repo: "onnx-community/Qwen3-1.7B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 1.7B";
+    readonly description: "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+    readonly contextNote: "Best single-model pick for memory from the CPU experiment.";
+}, {
+    readonly key: "gemma-3-1b";
+    readonly repo: "onnx-community/gemma-3-1b-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 3 1B";
+    readonly description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction.";
+    readonly contextNote: "Use when consolidation quality and size matter most.";
+}, {
+    readonly key: "qwen2.5-1.5b";
+    readonly repo: "onnx-community/Qwen2.5-1.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 1.5B";
+    readonly description: "Best extraction granularity (atomic facts); weaker consolidation.";
+    readonly contextNote: "Use when fine-grained, deduplicatable facts matter more than summaries.";
+}, {
+    readonly key: "lfm2-1.2b";
+    readonly repo: "onnx-community/LFM2-1.2B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 1.2B";
+    readonly description: "Fastest load; solid all-rounder, slightly noisier extraction labels.";
+    readonly contextNote: "Use when local startup cost is the priority.";
+}];
+export declare const TINY_MEMORY_MODEL_VALUES: readonly ["online", "qwen3-1.7b", "gemma-3-1b", "qwen2.5-1.5b", "lfm2-1.2b"];
+export type TinyMemoryModelKey = (typeof TINY_MEMORY_MODEL_VALUES)[number];
+export type TinyMemoryLocalModelKey = (typeof TINY_MEMORY_LOCAL_MODELS)[number]["key"];
+export declare const TINY_MEMORY_MODEL_OPTIONS: ({
+    value: "online";
+    label: string;
+    description: string;
+} | {
+    value: "gemma-3-1b" | "lfm2-1.2b" | "qwen2.5-1.5b" | "qwen3-1.7b";
+    label: "Gemma 3 1B" | "LFM2 1.2B" | "Qwen2.5 1.5B" | "Qwen3 1.7B";
+    description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction." | "Best extraction granularity (atomic facts); weaker consolidation." | "Fastest load; solid all-rounder, slightly noisier extraction labels." | "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+})[];
+export declare function isTinyMemoryLocalModelKey(value: string): value is TinyMemoryLocalModelKey;
+export declare function getTinyMemoryModelSpec(key: TinyMemoryLocalModelKey): (typeof TINY_MEMORY_LOCAL_MODELS)[number];
+/** Any local model key (title or memory), used by the shared inference worker. */
+export type TinyLocalModelKey = TinyTitleLocalModelKey | TinyMemoryLocalModelKey;
+/** Resolve a local model spec by key across both the title and memory registries. */
+export declare function getTinyLocalModelSpec(key: string): TinyTitleLocalModelSpec | undefined;
+export declare function isTinyLocalModelKey(value: string): value is TinyLocalModelKey;
+/** Combined local model registry (title + memory) for the shared tiny-models CLI. */
+export declare const TINY_LOCAL_MODELS: readonly [{
+    readonly key: "lfm2-350m";
+    readonly repo: "onnx-community/LFM2-350M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 350M";
+    readonly description: "Recommended local model; best speed/quality balance, about 212 MB cached.";
+    readonly contextNote: "Best local default from the CPU title-generation spike.";
+}, {
+    readonly key: "qwen3-0.6b";
+    readonly repo: "onnx-community/Qwen3-0.6B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 0.6B";
+    readonly description: "Most robust local option; slower first load, about 500 MB cached.";
+    readonly contextNote: "Use when title quality matters more than local startup cost.";
+}, {
+    readonly key: "gemma-270m";
+    readonly repo: "onnx-community/gemma-3-270m-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 270M";
+    readonly description: "Smallest viable local option; lower quality, lowest cache footprint.";
+    readonly contextNote: "Use on constrained machines that still need local titles.";
+}, {
+    readonly key: "qwen2.5-0.5b";
+    readonly repo: "onnx-community/Qwen2.5-0.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 0.5B";
+    readonly description: "Balanced local fallback; moderate quality and cache footprint.";
+    readonly contextNote: "Useful when Qwen3 is too heavy but Gemma quality is insufficient.";
+}, {
+    readonly key: "lfm2-700m";
+    readonly repo: "onnx-community/LFM2-700M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 700M";
+    readonly description: "Highest-quality local option; larger and slower than LFM2 350M.";
+    readonly contextNote: "Use when local title quality is preferred over startup cost.";
+}, {
+    readonly key: "qwen3-1.7b";
+    readonly repo: "onnx-community/Qwen3-1.7B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 1.7B";
+    readonly description: "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+    readonly contextNote: "Best single-model pick for memory from the CPU experiment.";
+}, {
+    readonly key: "gemma-3-1b";
+    readonly repo: "onnx-community/gemma-3-1b-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 3 1B";
+    readonly description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction.";
+    readonly contextNote: "Use when consolidation quality and size matter most.";
+}, {
+    readonly key: "qwen2.5-1.5b";
+    readonly repo: "onnx-community/Qwen2.5-1.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 1.5B";
+    readonly description: "Best extraction granularity (atomic facts); weaker consolidation.";
+    readonly contextNote: "Use when fine-grained, deduplicatable facts matter more than summaries.";
+}, {
+    readonly key: "lfm2-1.2b";
+    readonly repo: "onnx-community/LFM2-1.2B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 1.2B";
+    readonly description: "Fastest load; solid all-rounder, slightly noisier extraction labels.";
+    readonly contextNote: "Use when local startup cost is the priority.";
+}];

package/dist/types/tiny/text.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_TITLE_INPUT_CHARS = 2000;
+export declare function truncateTitleInput(message: string): string;
+export declare function formatTitleUserMessage(message: string): string;
+export declare function normalizeGeneratedTitle(value: string | null | undefined): string | null;

package/dist/types/tiny/title-client.d.ts

@@ -0,0 +1,24 @@
+import type { TinyTitleProgressEvent } from "./title-protocol";
+export interface TinyTitleDownloadOptions {
+    signal?: AbortSignal;
+    onProgress?: (event: TinyTitleProgressEvent) => void;
+}
+export declare function createTinyTitleWorker(): Worker;
+export declare class TinyTitleClient {
+    #private;
+    onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
+    generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
+    complete(modelKey: string, prompt: string, options?: {
+        maxTokens?: number;
+        signal?: AbortSignal;
+    }): Promise<string | null>;
+    downloadModel(modelKey: string, options?: TinyTitleDownloadOptions): Promise<boolean>;
+    terminate(): Promise<void>;
+}
+export declare const tinyTitleClient: TinyTitleClient;
+/** Alias for the shared tiny-model worker client (titles + memory completions). */
+export declare const tinyModelClient: TinyTitleClient;
+export declare function shutdownTinyTitleClient(): Promise<void>;
+export declare function smokeTestTinyTitleWorker({ timeoutMs, }?: {
+    timeoutMs?: number;
+}): Promise<void>;

package/dist/types/tiny/title-protocol.d.ts

@@ -0,0 +1,74 @@
+import type { TinyLocalModelKey, TinyTitleLocalModelKey } from "./models";
+export type TinyTitleProgressStatus = "initiate" | "download" | "progress" | "progress_total" | "done" | "ready" | "error";
+export interface TinyTitleProgressFileState {
+    loaded: number;
+    total: number;
+}
+export interface TinyTitleProgressEvent {
+    modelKey: TinyLocalModelKey;
+    status: TinyTitleProgressStatus;
+    name?: string;
+    file?: string;
+    progress?: number;
+    loaded?: number;
+    total?: number;
+    files?: Record<string, TinyTitleProgressFileState>;
+    task?: string;
+    model?: string;
+}
+export type TinyTitleWorkerInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "generate";
+    id: string;
+    modelKey: TinyTitleLocalModelKey;
+    message: string;
+} | {
+    type: "complete";
+    id: string;
+    modelKey: TinyLocalModelKey;
+    prompt: string;
+    maxTokens?: number;
+} | {
+    type: "download";
+    id: string;
+    modelKey: TinyLocalModelKey;
+} | {
+    type: "close";
+};
+export type TinyTitleWorkerOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "title";
+    id: string;
+    title: string | null;
+} | {
+    type: "completion";
+    id: string;
+    text: string | null;
+} | {
+    type: "downloaded";
+    id: string;
+} | {
+    type: "error";
+    id: string;
+    error: string;
+} | {
+    type: "progress";
+    id: string;
+    event: TinyTitleProgressEvent;
+} | {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+} | {
+    type: "closed";
+};
+export interface TinyTitleTransport {
+    send(message: TinyTitleWorkerOutbound): void;
+    onMessage(handler: (message: TinyTitleWorkerInbound) => void): () => void;
+    close(): void;
+}

package/dist/types/tiny/worker.d.ts

@@ -0,0 +1,2 @@
+import type { TinyTitleTransport } from "./title-protocol";
+export declare function startTinyTitleWorker(transport: TinyTitleTransport): void;

package/dist/types/tools/bash.d.ts

@@ -43,6 +43,8 @@ export interface BashToolDetails {
     timeoutSeconds?: number;
     requestedTimeoutSeconds?: number;
     wallTimeMs?: number;
+    /** Exit code of a command that ran to completion but failed (non-zero). */
+    exitCode?: number;
     terminalId?: string;
     async?: {
         state: "running" | "completed" | "failed";
@@ -70,7 +72,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
     readonly concurrency = "exclusive";
     readonly strict = true;
     constructor(session: ToolSession);
-    execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
+    execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
 }
 export interface BashRenderArgs {
     command?: string;

package/dist/types/tools/index.d.ts

@@ -6,6 +6,7 @@ import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
 import type { HindsightSessionState } from "../hindsight/state";
+import type { MnemosyneSessionState } from "../mnemosyne/state";
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry } from "../registry/agent-registry";
 import type { ArtifactManager } from "../session/artifacts";
@@ -36,13 +37,14 @@ export * from "./debug";
 export * from "./eval";
 export * from "./find";
 export * from "./gh";
-export * from "./hindsight-recall";
-export * from "./hindsight-reflect";
-export * from "./hindsight-retain";
 export * from "./image-gen";
 export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
+export * from "./memory-edit";
+export * from "./memory-recall";
+export * from "./memory-reflect";
+export * from "./memory-retain";
 export * from "./read";
 export * from "./recipe";
 export * from "./render-mermaid";
@@ -106,6 +108,8 @@ export interface ToolSession {
     getSessionId?: () => string | null;
     /** Get Hindsight runtime state for this agent session. */
     getHindsightSessionState?: () => HindsightSessionState | undefined;
+    /** Get Mnemosyne runtime state for this agent session. */
+    getMnemosyneSessionState?: () => MnemosyneSessionState | undefined;
     /** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
     getAgentId?: () => string | null;
     /** Look up a registered tool by name (used by the eval js backend's tool bridge). */

package/dist/types/tools/memory-edit.d.ts

@@ -0,0 +1,40 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const memoryEditSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        forget: "forget";
+        invalidate: "invalidate";
+        update: "update";
+    }>;
+    id: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    importance: z.ZodOptional<z.ZodNumber>;
+    replacement_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MemoryEditParams = z.infer<typeof memoryEditSchema>;
+export declare class MemoryEditTool implements AgentTool<typeof memoryEditSchema> {
+    private readonly session;
+    readonly name = "memory_edit";
+    readonly approval: "read";
+    readonly label = "Memory Edit";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        op: z.ZodEnum<{
+            forget: "forget";
+            invalidate: "invalidate";
+            update: "update";
+        }>;
+        id: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        importance: z.ZodOptional<z.ZodNumber>;
+        replacement_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Update, forget, or invalidate Mnemosyne memories";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): MemoryEditTool | null;
+    execute(_id: string, params: MemoryEditParams): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/{hindsight-recall.d.ts → memory-recall.d.ts}

@@ -1,11 +1,11 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import * as z from "zod/v4";
 import type { ToolSession } from ".";
-declare const hindsightRecallSchema: z.ZodObject<{
+declare const memoryRecallSchema: z.ZodObject<{
     query: z.ZodString;
 }, z.core.$strip>;
-export type HindsightRecallParams = z.infer<typeof hindsightRecallSchema>;
-export declare class HindsightRecallTool implements AgentTool<typeof hindsightRecallSchema> {
+export type MemoryRecallParams = z.infer<typeof memoryRecallSchema>;
+export declare class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
     private readonly session;
     readonly name = "recall";
     readonly approval: "read";
@@ -16,9 +16,9 @@ export declare class HindsightRecallTool implements AgentTool<typeof hindsightRe
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";
-    readonly summary = "Search hindsight memory for relevant prior context";
+    readonly summary = "Search memory for relevant prior context";
     constructor(session: ToolSession);
-    static createIf(session: ToolSession): HindsightRecallTool | null;
-    execute(_id: string, params: HindsightRecallParams, signal?: AbortSignal): Promise<AgentToolResult>;
+    static createIf(session: ToolSession): MemoryRecallTool | null;
+    execute(_id: string, params: MemoryRecallParams, signal?: AbortSignal): Promise<AgentToolResult>;
 }
 export {};

package/dist/types/tools/{hindsight-reflect.d.ts → memory-reflect.d.ts}

@@ -1,12 +1,12 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import * as z from "zod/v4";
 import type { ToolSession } from ".";
-declare const hindsightReflectSchema: z.ZodObject<{
+declare const memoryReflectSchema: z.ZodObject<{
     query: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type HindsightReflectParams = z.infer<typeof hindsightReflectSchema>;
-export declare class HindsightReflectTool implements AgentTool<typeof hindsightReflectSchema> {
+export type MemoryReflectParams = z.infer<typeof memoryReflectSchema>;
+export declare class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema> {
     private readonly session;
     readonly name = "reflect";
     readonly approval: "read";
@@ -18,9 +18,9 @@ export declare class HindsightReflectTool implements AgentTool<typeof hindsightR
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";
-    readonly summary = "Reflect on recent work and write hindsight memory";
+    readonly summary = "Synthesize an answer from long-term memory";
     constructor(session: ToolSession);
-    static createIf(session: ToolSession): HindsightReflectTool | null;
-    execute(_id: string, params: HindsightReflectParams, signal?: AbortSignal): Promise<AgentToolResult>;
+    static createIf(session: ToolSession): MemoryReflectTool | null;
+    execute(_id: string, params: MemoryReflectParams, signal?: AbortSignal): Promise<AgentToolResult>;
 }
 export {};

package/dist/types/tools/memory-render.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Inline TUI renderers for the long-term memory tools (`retain`, `recall`,
+ * `reflect`).
+ *
+ * These keep the transcript terse — one status line plus, for `retain`, one
+ * `Remember: …` line per stored item — instead of the generic JSON arg tree,
+ * which exploded multi-line memory blobs into an unreadable wall.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+interface RetainRenderArgs {
+    items?: Array<{
+        content?: string;
+        context?: string;
+    }>;
+}
+interface QueryRenderArgs {
+    query?: string;
+}
+export declare const retainToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: RetainRenderArgs, options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: {
+            count?: number;
+        };
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: RetainRenderArgs): Component;
+};
+export declare const recallToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+export declare const reflectToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+export {};