@oh-my-pi/pi-coding-agent 15.7.2 → 15.7.5

package/dist/types/internal-urls/local-protocol.d.ts

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 export interface LocalProtocolOptions {
     getArtifactsDir?: () => string | null;
     getSessionId?: () => string | null;
@@ -28,13 +28,23 @@ export declare class LocalProtocolHandler implements ProtocolHandler {
      * Returns the active local-protocol options.
      *
      * Resolution order:
-     * 1. Explicit override installed via {@link setOverride} (used by subagents
-     *    that share their parent's root and by SDK consumers with a custom
-     *    artifacts/session id mapping).
-     * 2. The main session in `AgentRegistry.global()`. Its `SessionManager`
-     *    supplies both `getArtifactsDir` and `getSessionId`.
+     * 1. **Caller-supplied** `context.localProtocolOptions` (the actual session
+     *    that initiated the `read`/`find`/`search`/`router.resolve` call). This
+     *    is what keeps `local://` reads pinned to the calling session in
+     *    multi-session hosts (cmux/ACP, embedded SDK consumers) where every
+     *    session registers as `kind: "main"` and "first one wins" would route
+     *    to the wrong artifacts directory.
+     * 2. Explicit process-global override installed via {@link setOverride}
+     *    (used by SDK consumers with a custom artifacts/session-id mapping and
+     *    by code paths that do not have a calling session, e.g. TUI hyperlink
+     *    resolution).
+     * 3. The first `main`-kind session in `AgentRegistry.global()`. Its
+     *    `SessionManager` supplies both `getArtifactsDir` and `getSessionId`.
+     *    Last-resort fallback — every caller that has a session reference
+     *    SHOULD thread it through `context` so this branch is never taken in
+     *    multi-session setups.
      */
-    static resolveOptions(): LocalProtocolOptions | undefined;
-    resolve(url: InternalUrl): Promise<InternalResource>;
-    complete(): Promise<UrlCompletion[]>;
+    static resolveOptions(context?: ResolveContext): LocalProtocolOptions | undefined;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    complete(_query?: string, context?: ResolveContext): Promise<UrlCompletion[]>;
 }

package/dist/types/internal-urls/types.d.ts

@@ -4,6 +4,7 @@
  * Internal URLs (agent://, artifact://, memory://, skill://, rule://, mcp://, omp://, local://) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
+import type { LocalProtocolOptions } from "./local-protocol";
 /**
  * Raw resource payload returned by protocol handlers. The `immutable` flag is
  * applied by the router from {@link ProtocolHandler.immutable}, so handlers do
@@ -73,6 +74,17 @@ export interface ResolveContext {
     settings?: unknown;
     /** Caller's abort signal. */
     signal?: AbortSignal;
+    /**
+     * Calling session's `local://` root mapping. When present, the local-protocol
+     * handler resolves the URL against THIS session's artifacts dir instead of
+     * picking the first `main`-kind session from the global `AgentRegistry`.
+     *
+     * Required for correctness in multi-session hosts (cmux/ACP, embedded SDK
+     * consumers) where multiple sessions are registered as `main` and the
+     * "first one wins" lookup picks the wrong artifacts directory — see
+     * [#1608](https://github.com/can1357/oh-my-pi/issues/1608).
+     */
+    localProtocolOptions?: LocalProtocolOptions;
 }
 /**
  * Caller context for write operations dispatched to host-owned URI handlers.
@@ -84,6 +96,8 @@ export interface WriteContext {
     cwd?: string;
     /** Caller's abort signal. */
     signal?: AbortSignal;
+    /** Calling session's `local://` root mapping — see {@link ResolveContext.localProtocolOptions}. */
+    localProtocolOptions?: LocalProtocolOptions;
 }
 /**
  * Handler for a specific internal URL scheme (e.g., agent://, memory://, skill://, mcp://).

package/dist/types/lsp/client.d.ts

@@ -39,6 +39,9 @@ export declare function notifySaved(client: LspClient, filePath: string, signal?
  * Increments version, sends didChange and didSave notifications.
  */
 export declare function refreshFile(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void>;
+/**
+ * Shutdown a specific client by key.
+ */
 export declare function shutdownClient(key: string): Promise<void>;
 /**
  * Send an LSP request and wait for response.

package/dist/types/mcp/manager.d.ts

@@ -130,12 +130,21 @@ export declare class MCPManager {
     disconnectAll(): Promise<void>;
     /**
      * Reconnect to a server after a connection failure.
+     *
      * Tears down the stale connection, re-resolves auth, establishes a new
-     * connection, reloads tools, and notifies consumers.
-     * Concurrent calls for the same server share one reconnection attempt.
-     * Returns the new connection, or null if reconnection failed.
-     */
-    reconnectServer(name: string): Promise<MCPServerConnection | null>;
+     * connection, reloads tools, and notifies consumers. Concurrent calls for
+     * the same server share one reconnection attempt. Returns the new
+     * connection, or `null` if reconnection failed or the per-server crash
+     * burst limit (see {@link RECONNECT_BURST_LIMIT}) is exceeded.
+     *
+     * @param options.manual - When `true`, resets the crash-burst window so a
+     *   user-driven retry (e.g. `/mcp reconnect`) is never blocked by an
+     *   earlier storm. Defaults to `false`; the transport `onClose` callback
+     *   and the per-tool-call retry path in `tool-bridge` MUST NOT set it.
+     */
+    reconnectServer(name: string, options?: {
+        manual?: boolean;
+    }): Promise<MCPServerConnection | null>;
     /**
      * Refresh tools from a specific server.
      */

package/dist/types/memory-backend/index.d.ts

@@ -1,4 +1,4 @@
-export * from "../mnemosyne";
+export * from "../mnemopi";
 export * from "./local-backend";
 export * from "./off-backend";
 export * from "./resolve";

package/dist/types/memory-backend/resolve.d.ts

@@ -6,7 +6,7 @@ import type { MemoryBackend } from "./types";
  * Selection rules (single source of truth — every memory consumer routes
  * through this):
  *   - `memory.backend === "hindsight"`  → Hindsight remote memory
- *   - `memory.backend === "mnemosyne"`  → local Mnemosyne SQLite memory
+ *   - `memory.backend === "mnemopi"`  → local Mnemopi SQLite memory
  *   - `memory.backend === "local"`      → local rollout summary pipeline
  *   - everything else                   → no-op
  *

package/dist/types/memory-backend/types.d.ts

@@ -9,9 +9,9 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
 import type { HindsightSessionState } from "../hindsight/state";
-import type { MnemosyneSessionState } from "../mnemosyne/state";
+import type { MnemopiSessionState } from "../mnemopi/state";
 import type { AgentSession } from "../session/agent-session";
-export type MemoryBackendId = "off" | "local" | "hindsight" | "mnemosyne";
+export type MemoryBackendId = "off" | "local" | "hindsight" | "mnemopi";
 export interface MemoryBackendStartOptions {
     session: AgentSession;
     settings: Settings;
@@ -19,7 +19,7 @@ export interface MemoryBackendStartOptions {
     agentDir: string;
     taskDepth: number;
     parentHindsightSessionState?: HindsightSessionState;
-    parentMnemosyneSessionState?: MnemosyneSessionState;
+    parentMnemopiSessionState?: MnemopiSessionState;
 }
 export interface MemoryBackend {
     readonly id: MemoryBackendId;

package/dist/types/mnemopi/backend.d.ts

@@ -0,0 +1,4 @@
+import type { MemoryBackend } from "../memory-backend/types";
+import type { AgentSession } from "../session/agent-session";
+export declare const mnemopiBackend: MemoryBackend;
+export declare function getMnemopiDbDirForTests(session: AgentSession): string | undefined;

package/dist/types/mnemopi/config.d.ts

@@ -0,0 +1,29 @@
+import type { MnemopiOptions } from "@oh-my-pi/pi-mnemopi";
+import type { Settings } from "../config/settings";
+export type MnemopiLlmMode = "none" | "smol" | "remote";
+export type MnemopiScoping = "global" | "per-project" | "per-project-tagged";
+export type MnemopiProviderOptions = Pick<MnemopiOptions, "noEmbeddings" | "embeddingModel" | "embeddingApiUrl" | "embeddingApiKey" | "llm">;
+export interface MnemopiBackendConfig {
+    dbPath: string;
+    baseBank?: string;
+    bank: string;
+    globalBank?: string;
+    retainBank?: string;
+    recallBanks?: readonly string[];
+    scoping?: MnemopiScoping;
+    autoRecall: boolean;
+    autoRetain: boolean;
+    retainEveryNTurns: number;
+    recallLimit: number;
+    recallContextTurns: number;
+    recallMaxQueryChars: number;
+    injectionTokenLimit: number;
+    debug: boolean;
+    providerOptions: MnemopiProviderOptions;
+    llmMode: MnemopiLlmMode;
+    llmBaseUrl?: string;
+    llmApiKey?: string;
+    llmModel?: string;
+}
+export declare function loadMnemopiConfig(settings: Settings, agentDir: string): MnemopiBackendConfig;
+export declare function truncateApproxTokens(text: string, tokenLimit: number): string;

package/dist/types/mnemopi/state.d.ts

@@ -0,0 +1,72 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { Mnemopi, type RecallResult } from "@oh-my-pi/pi-mnemopi";
+import type { AgentSession } from "../session/agent-session";
+import type { MnemopiBackendConfig } from "./config";
+interface MnemopiScopedMemory {
+    bank: string;
+    memory: Mnemopi;
+}
+type MnemopiRememberInput = Parameters<Mnemopi["remember"]>[0];
+type MnemopiRememberOptions = Parameters<Mnemopi["remember"]>[1];
+export type MnemopiMemoryEditOperation = "update" | "forget" | "invalidate";
+export interface MnemopiMemoryEditOptions {
+    content?: string;
+    importance?: number;
+    replacementId?: string;
+}
+export interface MnemopiMemoryEditResult {
+    status: "updated" | "deleted" | "invalidated" | "not_found";
+    bank?: string;
+    store?: "working" | "episodic";
+}
+export declare function getMnemopiSessionState(session: AgentSession | undefined): MnemopiSessionState | undefined;
+export declare function setMnemopiSessionState(session: AgentSession, state: MnemopiSessionState | undefined): MnemopiSessionState | undefined;
+export interface MnemopiSessionStateOptions {
+    sessionId: string;
+    config: MnemopiBackendConfig;
+    session: AgentSession;
+    aliasOf?: MnemopiSessionState;
+    lastRetainedTurn?: number;
+    hasRecalledForFirstTurn?: boolean;
+}
+export declare class MnemopiSessionState {
+    sessionId: string;
+    readonly config: MnemopiBackendConfig;
+    readonly session: AgentSession;
+    readonly memory: Mnemopi;
+    readonly globalMemory?: Mnemopi;
+    readonly aliasOf?: MnemopiSessionState;
+    private readonly scoped;
+    lastRetainedTurn: number;
+    hasRecalledForFirstTurn: boolean;
+    lastRecallSnippet?: string;
+    unsubscribe?: () => void;
+    constructor(options: MnemopiSessionStateOptions);
+    setSessionId(sessionId: string): void;
+    resetConversationTracking(): void;
+    getScopedRecallTargets(): readonly MnemopiScopedMemory[];
+    getScopedRetainTarget(): MnemopiScopedMemory;
+    editScopedMemory(op: MnemopiMemoryEditOperation, id: string, options?: MnemopiMemoryEditOptions): MnemopiMemoryEditResult;
+    formatScopedRecallWithIds(results: readonly RecallResult[]): string;
+    collectScopedRecallResults(query: string): RecallResult[];
+    recallResultsScoped(query: string): RecallResult[];
+    formatScopedRecallContext(results: readonly RecallResult[], format?: "bullet" | "json"): string | undefined;
+    formatContextScoped(results: readonly RecallResult[], format?: "bullet" | "json"): string;
+    rememberInScope(memory: MnemopiRememberInput, options?: MnemopiRememberOptions): string | undefined;
+    rememberScoped(memory: MnemopiRememberInput, options?: MnemopiRememberOptions): string | undefined;
+    recallForContext(query: string): Promise<string | undefined>;
+    beforeAgentStartPrompt(promptText: string): Promise<string | undefined>;
+    recallForCompaction(messages: AgentMessage[]): Promise<string | undefined>;
+    maybeRetainOnAgentEnd(_messages: AgentMessage[]): Promise<void>;
+    forceRetainCurrentSession(): Promise<void>;
+    retainMessages(messages: Array<{
+        role: string;
+        content: string;
+    }>, sourceId: string): Promise<void>;
+    attachSessionListeners(): void;
+    maybeRecallOnAgentStart(): Promise<void>;
+    dispose(): void;
+}
+export declare function getMnemopiScopedDbPaths(config: MnemopiBackendConfig): readonly string[];
+export declare function getMnemopiScopedBanks(config: MnemopiBackendConfig): readonly string[];
+export {};

package/dist/types/modes/components/custom-editor.d.ts

@@ -6,7 +6,8 @@ type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.cl
  */
 export declare class CustomEditor extends Editor {
     #private;
-    /** Gradient-highlight the "ultrathink" / "orchestrate" keywords as the user types them. */
+    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflow" keywords as the user types
+     *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. */
     decorateText: (text: string) => string;
     onEscape?: () => void;
     shouldBypassAutocompleteOnEscape?: () => boolean;
@@ -21,7 +22,6 @@ export declare class CustomEditor extends Editor {
     onExternalEditor?: () => void;
     onHistorySearch?: () => void;
     onSuspend?: () => void;
-    onShowHotkeys?: () => void;
     onSelectModelTemporary?: () => void;
     /** Called when the configured copy-prompt shortcut is pressed. */
     onCopyPrompt?: () => void;

package/dist/types/modes/components/omfg-panel.d.ts

@@ -0,0 +1,19 @@
+import { Container, type TUI } from "@oh-my-pi/pi-tui";
+export type OmfgPanelState = "generating" | "validating" | "confirming" | "saving" | "saved" | "rejected" | "aborted" | "error";
+interface OmfgPanelComponentOptions {
+    complaint: string;
+    tui: TUI;
+}
+export declare class OmfgPanelComponent extends Container {
+    #private;
+    constructor(options: OmfgPanelComponentOptions);
+    appendDraft(delta: string): void;
+    setRule(text: string): void;
+    setStatus(state: OmfgPanelState, status: string): void;
+    markSaved(path: string): void;
+    markRejected(): void;
+    markAborted(): void;
+    markError(message: string): void;
+    close(): void;
+}
+export {};

package/dist/types/modes/controllers/command-controller.d.ts

@@ -3,6 +3,7 @@ import { type ProviderDetails, type UsageReport } from "@oh-my-pi/pi-ai";
 import type { CompactOptions } from "../../extensibility/extensions/types";
 import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
+import { type ShakeMode } from "../../session/shake-types";
 export declare class CommandController {
     #private;
     private readonly ctx;
@@ -29,6 +30,11 @@ export declare class CommandController {
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
     handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
+    /**
+     * TUI handler for `/shake`. `elide` drops heavy structural content and
+     * `images` strips image blocks. Rebuilds the chat and reports counts.
+     */
+    handleShakeCommand(mode: ShakeMode): Promise<void>;
     handleSkillCommand(skillPath: string, args: string): Promise<void>;
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;

package/dist/types/modes/controllers/input-controller.d.ts

@@ -24,9 +24,7 @@ export declare class InputController {
     /** Copy current prompt text to system clipboard. */
     handleCopyPrompt(): void;
     cycleThinkingLevel(): void;
-    cycleRoleModel(options?: {
-        temporary?: boolean;
-    }): Promise<void>;
+    cycleRoleModel(direction?: "forward" | "backward"): Promise<void>;
     toggleToolOutputExpansion(): void;
     setToolsExpanded(expanded: boolean): void;
     toggleThinkingBlockVisibility(): void;

package/dist/types/modes/controllers/omfg-controller.d.ts

@@ -0,0 +1,10 @@
+import type { InteractiveModeContext } from "../types";
+export declare class OmfgController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: InteractiveModeContext);
+    hasActiveRequest(): boolean;
+    handleEscape(): boolean;
+    dispose(): void;
+    start(complaint: string): Promise<void>;
+}

package/dist/types/modes/controllers/omfg-rule.d.ts

@@ -0,0 +1,26 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { Rule } from "../../capability/rule";
+export interface ParsedGeneratedRule {
+    rule: Rule;
+    fileContent: string;
+}
+export type GeneratedRuleParseResult = ParsedGeneratedRule | {
+    error: string;
+};
+export interface RuleHistoryValidation {
+    matched: boolean;
+    feedback?: string;
+}
+export interface ParsedRuleHistoryValidation {
+    candidate: ParsedGeneratedRule;
+    validation: RuleHistoryValidation;
+    repairedCondition: boolean;
+}
+export type OmfgRuleSourceLevel = "project" | "user";
+export declare function extractGeneratedRuleJson(text: string): string | null;
+export declare function sanitizeRuleName(rawName: string): string;
+export declare function buildOmfgRuleForPath(ruleName: string, fileContent: string, filePath: string, level: OmfgRuleSourceLevel): Rule;
+export declare function parseGeneratedRule(text: string): GeneratedRuleParseResult;
+export declare function validateRuleAgainstAssistantHistory(rule: Rule, messages: readonly AgentMessage[]): RuleHistoryValidation;
+export declare function validateParsedRuleAgainstAssistantHistory(candidate: ParsedGeneratedRule, messages: readonly AgentMessage[]): ParsedRuleHistoryValidation;
+export declare function ruleMatchesAssistantHistory(rule: Rule, messages: readonly AgentMessage[]): boolean;

package/dist/types/modes/gradient-highlight.d.ts

@@ -1,3 +1,7 @@
+/** A gradient keyword highlighter. `resetTo` is the SGR foreground sequence
+ *  re-emitted after each painted keyword so surrounding text keeps its color;
+ *  it defaults to a plain foreground reset (editor / default-colored text). */
+export type KeywordHighlighter = (text: string, resetTo?: string) => string;
 /** Declarative spec for {@link createGradientHighlighter}. */
 export interface GradientHighlightSpec {
     /** Cheap, stateless presence probe used to skip the boundary regex on most lines. Must be non-global. */
@@ -20,4 +24,4 @@ export interface GradientHighlightSpec {
  * untouched when `probe` does not match. The palette is compiled lazily and
  * memoized per active color mode.
  */
-export declare function createGradientHighlighter(spec: GradientHighlightSpec): (text: string) => string;
+export declare function createGradientHighlighter(spec: GradientHighlightSpec): KeywordHighlighter;

package/dist/types/modes/interactive-mode.d.ts

@@ -11,6 +11,7 @@ import { type PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { ShakeMode } from "../session/shake-types";
 import type { LspStartupServerInfo } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { AssistantMessageComponent } from "./components/assistant-message";
@@ -53,6 +54,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     statusContainer: Container;
     todoContainer: Container;
     btwContainer: Container;
+    omfgContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
@@ -207,6 +209,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleSSHCommand(text: string): Promise<void>;
     handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
+    handleShakeCommand(mode: ShakeMode): Promise<void>;
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
     openInBrowser(urlOrPath: string): void;
     showSettingsSelector(): void;
@@ -233,10 +236,11 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleBtwCommand(question: string): Promise<void>;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
+    handleOmfgCommand(complaint: string): Promise<void>;
+    hasActiveOmfg(): boolean;
+    handleOmfgEscape(): boolean;
     cycleThinkingLevel(): void;
-    cycleRoleModel(options?: {
-        temporary?: boolean;
-    }): Promise<void>;
+    cycleRoleModel(direction?: "forward" | "backward"): Promise<void>;
     toggleToolOutputExpansion(): void;
     setToolsExpanded(expanded: boolean): void;
     toggleThinkingBlockVisibility(): void;

package/dist/types/modes/magic-keywords.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gradient-highlight every magic keyword ("ultrathink", "orchestrate",
+ * "workflow") that appears as standalone prose, skipping any occurrence inside a
+ * code block, inline code span, or XML/HTML section. Each highlighter paints its
+ * own keyword with its own gradient, so chaining is order-independent — the
+ * earlier passes only inject zero-width SGR escapes (no backticks or angle
+ * brackets), which never confuse the later passes' markdown masking.
+ *
+ * `resetTo` is the SGR foreground sequence restored after each painted keyword;
+ * pass the surrounding text color when decorating already-colored content (e.g.
+ * a themed message bubble) so the gradient does not bleed into the rest of the
+ * line. Defaults to a plain foreground reset for default-colored editor text.
+ */
+export declare function highlightMagicKeywords(text: string, resetTo?: string): string;

package/dist/types/modes/markdown-prose.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Markdown structure awareness for the magic-keyword affordances
+ * ("ultrathink"/"orchestrate"/"workflow").
+ *
+ * Keyword detection and editor/transcript highlighting must fire only on prose
+ * the user is actually addressing to the model — never on a word that happens to
+ * live inside a fenced code block, an inline code span, or an HTML/XML section.
+ * {@link maskNonProse} returns a length-preserving copy of the text where every
+ * such region is blanked to spaces, so a word-bounded match run against the mask
+ * never lands inside code/markup while its indices still address the original
+ * text for painting.
+ */
+/**
+ * Return a copy of `text` with identical length (indices map 1:1) where every
+ * character inside a non-prose region is replaced by a space. Non-prose regions
+ * are markdown fenced code blocks, inline code spans, and HTML/XML tags together
+ * with the content they enclose. Newlines are preserved. Text with no construct
+ * that could open such a region is returned unchanged.
+ */
+export declare function maskNonProse(text: string): string;
+/**
+ * Whether `text` contains a standalone keyword match (per the non-global,
+ * word-bounded `word` regex) that lives in prose rather than inside a code
+ * block, inline code span, or HTML/XML section. `word` MUST be non-global so
+ * `.test` stays stateless.
+ */
+export declare function keywordInProse(text: string, word: RegExp): boolean;

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

@@ -1,10 +1,15 @@
+import { type KeywordHighlighter } from "./gradient-highlight";
 /** Hidden system notice appended after a user message that mentions "orchestrate". */
 export declare const ORCHESTRATE_NOTICE: string;
-/** Whether `text` contains the standalone keyword "orchestrate" (any case). */
+/**
+ * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
+ * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
 export declare function containsOrchestrate(text: string): boolean;
 /**
  * Highlight every standalone "orchestrate" in `text` for editor display with a
  * cool teal→violet gradient (hue 150..280), visually distinct from ultrathink's
  * full-spectrum rainbow.
  */
-export declare const highlightOrchestrate: (text: string) => string;
+export declare const highlightOrchestrate: KeywordHighlighter;

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

@@ -1,5 +1,5 @@
 import type { TabBarTheme } from "@oh-my-pi/pi-tui";
-/** Sanitize text for display in a single-line status. Strips ANSI escape sequences, C0/C1 control characters, collapses whitespace, trims. */
+/** Sanitize text for display in a single-line status. Strips ANSI/VT escape sequences, maps remaining C0/C1 control characters to spaces, collapses whitespace, trims. */
 export declare function sanitizeStatusText(text: string): string;
 /** Shared tab bar theme used by model-selector and settings-selector. */
 export declare function getTabBarTheme(): TabBarTheme;

package/dist/types/modes/turn-budget.d.ts

@@ -0,0 +1,18 @@
+/**
+ * "+Nk" turn token-budget directive.
+ *
+ * A standalone `+<number>[k|m]` token in the user's message sets a per-turn
+ * output-token budget surfaced by the `eval` `budget` helper. By default it is
+ * ADVISORY — the model self-limits via `budget.remaining()`. Append `!`
+ * (`+500k!`) to make it a HARD ceiling: eval `agent()` refuses to spawn once the
+ * turn's spend reaches it. Matching is anchored to token boundaries so it does
+ * not fire on prices or version strings embedded in prose.
+ */
+export interface TurnBudget {
+    /** Output-token ceiling for the turn. */
+    total: number;
+    /** Whether the ceiling is enforced (eval `agent()` throws past it) vs advisory. */
+    hard: boolean;
+}
+/** Parse a `+Nk`/`+N`/`+Nm`(`!`) turn-budget directive from `text`, or null when absent. */
+export declare function parseTurnBudget(text: string): TurnBudget | null;

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

@@ -11,6 +11,7 @@ import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { ShakeMode } from "../session/shake-types";
 import type { LspStartupServerInfo } from "../tools";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -57,6 +58,7 @@ export interface InteractiveModeContext {
     statusContainer: Container;
     todoContainer: Container;
     btwContainer: Container;
+    omfgContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
@@ -207,6 +209,7 @@ export interface InteractiveModeContext {
     handleSSHCommand(text: string): Promise<void>;
     handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
+    handleShakeCommand(mode: ShakeMode): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
     handleRenameCommand(title: string): Promise<void>;
     handleMemoryCommand(text: string): Promise<void>;
@@ -241,10 +244,11 @@ export interface InteractiveModeContext {
     handleBtwCommand(question: string): Promise<void>;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
+    handleOmfgCommand(complaint: string): Promise<void>;
+    hasActiveOmfg(): boolean;
+    handleOmfgEscape(): boolean;
     cycleThinkingLevel(): void;
-    cycleRoleModel(options?: {
-        temporary?: boolean;
-    }): Promise<void>;
+    cycleRoleModel(direction?: "forward" | "backward"): Promise<void>;
     toggleToolOutputExpansion(): void;
     setToolsExpanded(expanded: boolean): void;
     toggleThinkingBlockVisibility(): void;

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

@@ -1,10 +1,15 @@
+import { type KeywordHighlighter } from "./gradient-highlight";
 /** Hidden system notice appended after a user message that mentions "ultrathink". */
 export declare const ULTRATHINK_NOTICE: string;
-/** Whether `text` contains the standalone keyword "ultrathink" (any case). */
+/**
+ * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
+ * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
 export declare function containsUltrathink(text: string): boolean;
 /**
  * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
  * 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 const highlightUltrathink: (text: string) => string;
+export declare const highlightUltrathink: KeywordHighlighter;

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

@@ -0,0 +1,15 @@
+import { type KeywordHighlighter } from "./gradient-highlight";
+/** Hidden system notice appended after a user message that mentions "workflow". */
+export declare const WORKFLOW_NOTICE: string;
+/**
+ * Whether `text` contains the standalone keyword "workflow"/"workflows"
+ * (lowercase, whitespace-delimited) in prose — never inside a code block, inline
+ * code span, or XML/HTML section.
+ */
+export declare function containsWorkflow(text: string): boolean;
+/**
+ * Highlight every standalone "workflow"/"workflows" in `text` for editor display
+ * with a warm amber→green gradient (hue 30..150), visually distinct from
+ * ultrathink's rainbow and orchestrate's teal→violet.
+ */
+export declare const highlightWorkflow: KeywordHighlighter;

package/dist/types/sdk.d.ts

@@ -13,7 +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 { type MnemopiSessionState } from "./mnemopi/state";
 import { AgentRegistry } from "./registry/agent-registry";
 import { AgentSession } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";
@@ -99,8 +99,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;
+    /** Parent Mnemopi state to alias for subagent memory tools. */
+    parentMnemopiSessionState?: MnemopiSessionState;
     /** 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". */
@@ -176,6 +176,16 @@ export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStor
  * Discover extensions from cwd.
  */
 export declare function discoverExtensions(cwd?: string): Promise<LoadExtensionsResult>;
+/**
+ * Load the discovered/configured extensions for a session — everything {@link
+ * createAgentSession} would load except the inline factory extensions it appends
+ * itself. Extracted so the CLI can resolve extension-registered flags (and thus
+ * classify `@file` arguments extension-aware) *before* a session — and its
+ * terminal breadcrumb — is created, then hand the result back through
+ * {@link CreateAgentSessionOptions.preloadedExtensions} so the work is not
+ * repeated. Keep this the single source of the discovery branch logic.
+ */
+export declare function loadSessionExtensions(options: Pick<CreateAgentSessionOptions, "disableExtensionDiscovery" | "additionalExtensionPaths">, cwd: string, settings: Settings, eventBus: EventBus): Promise<LoadExtensionsResult>;
 /**
  * Discover skills from cwd and agentDir.
  */