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

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,12 @@ 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`/`images` are instant structural drops;
+     * `summary` runs the local on-device compressor behind a cancelable loader
+     * (Esc aborts via `abortCompaction`). 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.
  */