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

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

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 /**
  * Handler for agent:// URLs.
  *
@@ -9,4 +9,5 @@ export declare class AgentProtocolHandler implements ProtocolHandler {
     readonly scheme = "agent";
     readonly immutable = true;
     resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
 }

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

@@ -1,6 +1,7 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 export declare class ArtifactProtocolHandler implements ProtocolHandler {
     readonly scheme = "artifact";
     readonly immutable = true;
     resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
 }

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

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 export interface LocalProtocolOptions {
     getArtifactsDir?: () => string | null;
     getSessionId?: () => string | null;
@@ -36,4 +36,5 @@ export declare class LocalProtocolHandler implements ProtocolHandler {
      */
     static resolveOptions(): LocalProtocolOptions | undefined;
     resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
 }

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

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 /**
  * Snapshot of memory roots for every registered session, deduped.
  * Each session has its own cwd (possibly a worktree), so subagents and main
@@ -20,4 +20,5 @@ export declare class MemoryProtocolHandler implements ProtocolHandler {
     readonly scheme = "memory";
     readonly immutable = true;
     resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
 }

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

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 /**
  * Handler for omp:// URLs.
  *
@@ -9,4 +9,5 @@ export declare class OmpProtocolHandler implements ProtocolHandler {
     readonly scheme = "omp";
     readonly immutable = true;
     resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
 }

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

@@ -1,4 +1,4 @@
-import type { InternalResource, ProtocolHandler, ResolveContext } from "./types";
+import type { InternalResource, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 export declare class InternalUrlRouter {
     #private;
     constructor();
@@ -10,5 +10,12 @@ export declare class InternalUrlRouter {
     unregister(scheme: string): boolean;
     getHandler(scheme: string): ProtocolHandler | undefined;
     canHandle(input: string): boolean;
+    /** Schemes whose handler supports host/path autocomplete. */
+    completionSchemes(): string[];
+    /**
+     * Candidate completions for the host/path portion of `scheme://<query>`.
+     * Returns `null` when the scheme is unknown or does not support completion.
+     */
+    complete(scheme: string, query: string): Promise<UrlCompletion[] | null>;
     resolve(input: string, context?: ResolveContext): Promise<InternalResource>;
 }

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

@@ -1,6 +1,7 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 export declare class RuleProtocolHandler implements ProtocolHandler {
     readonly scheme = "rule";
     readonly immutable = true;
     resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
 }

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

@@ -1,4 +1,4 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 /**
  * Validate that a path is safe (no traversal, no absolute paths).
  */
@@ -10,4 +10,5 @@ export declare class SkillProtocolHandler implements ProtocolHandler {
     readonly scheme = "skill";
     readonly immutable = true;
     resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
 }

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

@@ -30,6 +30,21 @@ export interface InternalResource {
      */
     immutable?: boolean;
 }
+/**
+ * A single autocomplete candidate for the host/path portion of a `scheme://`
+ * URL, produced by {@link ProtocolHandler.complete}.
+ */
+export interface UrlCompletion {
+    /**
+     * The text that follows `scheme://` for this candidate (e.g. `humanizer`,
+     * `subdir/data.json`, `root`). The caller renders it as `scheme://<value>`.
+     */
+    value: string;
+    /** Human-facing label for the dropdown. Defaults to {@link value}. */
+    label?: string;
+    /** Optional one-line description shown beside the candidate. */
+    description?: string;
+}
 /**
  * Parsed internal URL with preserved host casing.
  */
@@ -102,4 +117,15 @@ export interface ProtocolHandler {
      * surfaces a clear "not writable" error when invoked against them.
      */
     write?(url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
+    /**
+     * Optional autocomplete hook. Returns candidate completions for the
+     * host/path portion of a `scheme://` URL while the user composes a prompt.
+     *
+     * Implementations **MUST** be fast and local — this runs on every keystroke.
+     * Schemes backed by network or external CLIs (issue://, pr://, vault://,
+     * mcp://) omit it. The caller fuzzy-filters the returned set against the
+     * partially typed `query`, so handlers return their full (bounded) candidate
+     * list; `query` is provided only so handlers can scope expensive enumeration.
+     */
+    complete?(query: string): Promise<UrlCompletion[]>;
 }

package/dist/types/main.d.ts

@@ -44,6 +44,7 @@ interface RunRootCommandDependencies {
     discoverAuthStorage?: typeof discoverAuthStorage;
     runAcpMode?: typeof runAcpMode;
     settings?: Settings;
+    forceSetupWizard?: boolean;
 }
 export declare function runRootCommand(parsed: Args, rawArgs: string[], deps?: RunRootCommandDependencies): Promise<void>;
 export declare function main(args: string[]): Promise<void>;

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

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

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

@@ -6,7 +6,8 @@ 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 === "local"`      → local pipeline
+ *   - `memory.backend === "mnemosyne"`  → local Mnemosyne SQLite memory
+ *   - `memory.backend === "local"`      → local rollout summary pipeline
  *   - everything else                   → no-op
  *
  * `memories.enabled` remains accepted only as a legacy migration input. Once

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

@@ -9,8 +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 { AgentSession } from "../session/agent-session";
-export type MemoryBackendId = "off" | "local" | "hindsight";
+export type MemoryBackendId = "off" | "local" | "hindsight" | "mnemosyne";
 export interface MemoryBackendStartOptions {
     session: AgentSession;
     settings: Settings;
@@ -18,6 +19,7 @@ export interface MemoryBackendStartOptions {
     agentDir: string;
     taskDepth: number;
     parentHindsightSessionState?: HindsightSessionState;
+    parentMnemosyneSessionState?: MnemosyneSessionState;
 }
 export interface MemoryBackend {
     readonly id: MemoryBackendId;
@@ -38,6 +40,10 @@ export interface MemoryBackend {
     clear(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
     /** Force consolidation/retain to happen now (slash `/memory enqueue`). */
     enqueue(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
+    /** Render backend-specific memory statistics as markdown (`/memory stats`). */
+    stats?(agentDir: string, cwd: string, session?: AgentSession): Promise<string | undefined>;
+    /** Render backend-specific memory diagnostics as markdown (`/memory diagnose`). */
+    diagnose?(agentDir: string, cwd: string, session?: AgentSession): Promise<string | undefined>;
     /**
      * Optional hook to inject a backend-specific block into the current turn's
      * system prompt before the agent starts generating.

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

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

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

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

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

@@ -0,0 +1,3 @@
+export * from "./backend";
+export * from "./config";
+export * from "./state";

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

@@ -0,0 +1,72 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { Mnemosyne, type RecallResult } from "@oh-my-pi/pi-mnemosyne";
+import type { AgentSession } from "../session/agent-session";
+import type { MnemosyneBackendConfig } from "./config";
+interface MnemosyneScopedMemory {
+    bank: string;
+    memory: Mnemosyne;
+}
+type MnemosyneRememberInput = Parameters<Mnemosyne["remember"]>[0];
+type MnemosyneRememberOptions = Parameters<Mnemosyne["remember"]>[1];
+export type MnemosyneMemoryEditOperation = "update" | "forget" | "invalidate";
+export interface MnemosyneMemoryEditOptions {
+    content?: string;
+    importance?: number;
+    replacementId?: string;
+}
+export interface MnemosyneMemoryEditResult {
+    status: "updated" | "deleted" | "invalidated" | "not_found";
+    bank?: string;
+    store?: "working" | "episodic";
+}
+export declare function getMnemosyneSessionState(session: AgentSession | undefined): MnemosyneSessionState | undefined;
+export declare function setMnemosyneSessionState(session: AgentSession, state: MnemosyneSessionState | undefined): MnemosyneSessionState | undefined;
+export interface MnemosyneSessionStateOptions {
+    sessionId: string;
+    config: MnemosyneBackendConfig;
+    session: AgentSession;
+    aliasOf?: MnemosyneSessionState;
+    lastRetainedTurn?: number;
+    hasRecalledForFirstTurn?: boolean;
+}
+export declare class MnemosyneSessionState {
+    sessionId: string;
+    readonly config: MnemosyneBackendConfig;
+    readonly session: AgentSession;
+    readonly memory: Mnemosyne;
+    readonly globalMemory?: Mnemosyne;
+    readonly aliasOf?: MnemosyneSessionState;
+    private readonly scoped;
+    lastRetainedTurn: number;
+    hasRecalledForFirstTurn: boolean;
+    lastRecallSnippet?: string;
+    unsubscribe?: () => void;
+    constructor(options: MnemosyneSessionStateOptions);
+    setSessionId(sessionId: string): void;
+    resetConversationTracking(): void;
+    getScopedRecallTargets(): readonly MnemosyneScopedMemory[];
+    getScopedRetainTarget(): MnemosyneScopedMemory;
+    editScopedMemory(op: MnemosyneMemoryEditOperation, id: string, options?: MnemosyneMemoryEditOptions): MnemosyneMemoryEditResult;
+    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: MnemosyneRememberInput, options?: MnemosyneRememberOptions): string | undefined;
+    rememberScoped(memory: MnemosyneRememberInput, options?: MnemosyneRememberOptions): 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 getMnemosyneScopedDbPaths(config: MnemosyneBackendConfig): readonly string[];
+export declare function getMnemosyneScopedBanks(config: MnemosyneBackendConfig): readonly string[];
+export {};

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

@@ -1,14 +1,13 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
-import { highlightUltrathink } from "../ultrathink";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
 export declare class CustomEditor extends Editor {
     #private;
-    /** Rainbow-highlight the "ultrathink" keyword as the user types it. */
-    decorateText: typeof highlightUltrathink;
+    /** Gradient-highlight the "ultrathink" / "orchestrate" keywords as the user types them. */
+    decorateText: (text: string) => string;
     onEscape?: () => void;
     shouldBypassAutocompleteOnEscape?: () => boolean;
     onClear?: () => void;

package/dist/types/modes/components/hook-selector.d.ts

@@ -3,6 +3,32 @@
  * Displays a list of string options with keyboard navigation.
  */
 import { Container, type TUI } from "@oh-my-pi/pi-tui";
+import { type ThemeColor } from "../../modes/theme/theme";
+/** One segment of a {@link HookSelectorSlider} — a label, its accent color, and
+ *  an optional detail line (e.g. the resolved model name) shown beneath the
+ *  track while the segment is active. */
+export interface HookSelectorSliderSegment {
+    label: string;
+    /** Theme color for the segment label; defaults to `accent`. */
+    color?: ThemeColor;
+    /** Secondary line rendered under the track when this segment is selected. */
+    detail?: string;
+}
+/**
+ * A horizontal left/right selector rendered above the option list. Unlike the
+ * up/down option cursor, the slider is moved with the left/right arrows from
+ * any list position, letting the caller capture an orthogonal choice (e.g. the
+ * model tier to continue execution with) alongside the selected option.
+ */
+export interface HookSelectorSlider {
+    /** Dim caption rendered before the slider track (e.g. "continue with"). */
+    caption?: string;
+    segments: HookSelectorSliderSegment[];
+    /** Initially highlighted segment index. */
+    index: number;
+    /** Invoked with the new index whenever the slider moves. */
+    onChange?: (index: number) => void;
+}
 export interface HookSelectorOptions {
     tui?: TUI;
     timeout?: number;
@@ -14,6 +40,7 @@ export interface HookSelectorOptions {
     onRight?: () => void;
     onExternalEditor?: () => void;
     helpText?: string;
+    slider?: HookSelectorSlider;
 }
 export declare class HookSelectorComponent extends Container {
     #private;

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

@@ -19,12 +19,14 @@ export * from "./model-selector";
 export * from "./oauth-selector";
 export * from "./queue-mode-selector";
 export * from "./read-tool-group";
+export * from "./segment-track";
 export * from "./session-selector";
 export * from "./settings-selector";
 export * from "./show-images-selector";
 export * from "./status-line";
 export * from "./theme-selector";
 export * from "./thinking-selector";
+export * from "./tiny-title-download-progress";
 export * from "./todo-reminder";
 export * from "./tool-execution";
 export * from "./tree-selector";

package/dist/types/modes/components/segment-track.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared renderer for a horizontal row of colored "segments" styled after the
+ * status line: each segment shows in its own accent, the active one is filled
+ * as a powerline chip (its accent as the background, a luminance-matched label,
+ * flanked by triangle caps) and the rest are plain colored labels joined by a
+ * thin separator.
+ *
+ * Used by the plan-mode model-tier slider ({@link HookSelectorComponent}) and
+ * the ctrl+p role-cycle status so both surfaces read identically.
+ */
+import { type ThemeColor } from "../theme/theme";
+export interface TrackSegment {
+    label: string;
+    /** Theme color for the segment; defaults to `accent`. */
+    color?: ThemeColor;
+}
+/**
+ * Render `segments` as a colored chip track with `activeIndex` filled. Returns
+ * a single line of styled text with no surrounding caption or arrows — callers
+ * frame it as they need.
+ */
+export declare function renderSegmentTrack(segments: TrackSegment[], activeIndex: number): string;

package/dist/types/modes/components/status-line/context-thresholds.d.ts

@@ -1,4 +1,10 @@
 import type { ThemeColor } from "../../../modes/theme/theme";
 export type ContextUsageLevel = "normal" | "warning" | "purple" | "error";
 export declare function getContextUsageLevel(contextPercent: number, contextWindow: number): ContextUsageLevel;
+/**
+ * Format context usage as `<percent>%/<window>` (e.g. `5.1%/1M`), matching the
+ * status line's context gauge so subagent and footer renderers stay in sync.
+ * A `null`/`undefined` percent (unknown, e.g. right after compaction) renders as `?`.
+ */
+export declare function formatContextUsage(contextPercent: number | null | undefined, contextWindow: number): string;
 export declare function getContextUsageThemeColor(level: ContextUsageLevel): ThemeColor;

package/dist/types/modes/components/tiny-title-download-progress.d.ts

@@ -0,0 +1,11 @@
+import { type Component } from "@oh-my-pi/pi-tui";
+import { type TinyTitleLocalModelKey } from "../../tiny/models";
+import type { TinyTitleProgressEvent } from "../../tiny/title-protocol";
+export declare class TinyTitleDownloadProgressComponent implements Component {
+    #private;
+    constructor(modelKey: TinyTitleLocalModelKey);
+    update(event: TinyTitleProgressEvent): void;
+    isComplete(): boolean;
+    invalidate(): void;
+    render(width: number): string[];
+}

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

@@ -1,4 +1,5 @@
 import { type Component } from "@oh-my-pi/pi-tui";
+export declare function renderWelcomeTip(tip: string, boxWidth: number): string[];
 export interface RecentSession {
     name: string;
     timeAgo: string;
@@ -31,3 +32,24 @@ export declare class WelcomeComponent implements Component {
     setLspServers(servers: LspServerInfo[]): void;
     render(termWidth: number): string[];
 }
+export declare const PI_LOGO: string[];
+export interface ShineConfig {
+    /** Overall opacity of the shine overlay, in [0, 1]. */
+    strength: number;
+    /** Center of the shine band along the diagonal, in [0, 1]. */
+    pos: number;
+}
+/**
+ * Resolve the gradient SGR foreground escape for a normalized position `t`
+ * (0..1) along the diagonal, compositing the optional sliding shine highlight.
+ * Shared by {@link gradientLogo} and the setup splash so both stay
+ * color-identical (truecolor when available, 256-color ramp otherwise).
+ */
+export declare function gradientEscape(t: number, shine?: ShineConfig): string;
+/**
+ * Apply a multi-stop diagonal gradient (bottom-left → top-right) plus an
+ * optional sliding shine band across multi-line art. `phase` (0..1) shifts the
+ * gradient along the diagonal, wrapping at 1. When `shine` is provided, a soft
+ * white highlight is composited on top, centered at `shine.pos`.
+ */
+export declare function gradientLogo(lines: readonly string[], phase?: number, shine?: ShineConfig): string[];

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -1,6 +1,7 @@
 import type { Component, TUI } from "@oh-my-pi/pi-tui";
 import { KeybindingsManager } from "../../config/keybindings";
 import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions";
+import { type HookSelectorSlider } from "../../modes/components/hook-selector";
 import { type Theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
 export declare class ExtensionUiController {
@@ -29,7 +30,9 @@ export declare class ExtensionUiController {
     /**
      * Show a selector for hooks.
      */
-    showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions, extra?: {
+        slider?: HookSelectorSlider;
+    }): Promise<string | undefined>;
     /**
      * Hide the hook selector.
      */

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

@@ -0,0 +1,23 @@
+/** 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. */
+    probe: RegExp;
+    /** Global, word-bounded match regex walked by `.replace`. */
+    highlight: RegExp;
+    /** Number of color stops swept across the gradient. */
+    stops: number;
+    /** Maps a normalized position `t` in [0, 1) to an HSL hue in degrees. */
+    hue: (t: number) => number;
+    /** HSL saturation percentage. Default 90. */
+    saturation?: number;
+    /** HSL lightness percentage. Default 62. */
+    lightness?: number;
+}
+/**
+ * Build a stateless highlighter that paints each standalone match of `highlight`
+ * with a smooth HSL gradient for editor display. The returned function adds only
+ * zero-width SGR escapes — the visible width is unchanged — and returns the input
+ * 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;

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

@@ -19,13 +19,13 @@ import { CustomEditor } from "./components/custom-editor";
 import type { EvalExecutionComponent } from "./components/eval-execution";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
-import type { HookSelectorComponent } from "./components/hook-selector";
+import type { HookSelectorComponent, HookSelectorSlider } from "./components/hook-selector";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { type LoopLimitRuntime } from "./loop-limit";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
-import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+import type { CompactionQueuedMessage, InteractiveModeContext, InteractiveModeInitOptions, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
 /** Options for creating an InteractiveMode instance (for future API use) */
 export interface InteractiveModeOptions {
     /** Providers that were migrated during startup */
@@ -106,7 +106,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     readonly lspServers: LspStartupServerInfo[] | undefined;
     mcpManager?: import("../mcp").MCPManager;
     constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../mcp").MCPManager, eventBus?: EventBus);
-    init(): Promise<void>;
+    playWelcomeIntro(): void;
+    init(options?: InteractiveModeInitOptions): Promise<void>;
     /** Reload slash commands and autocomplete for the provided working directory. */
     refreshSlashCommandState(cwd?: string): Promise<void>;
     getUserInput(): Promise<SubmittedUserInput>;
@@ -248,7 +249,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
     setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
     setHookStatus(key: string, text: string | undefined): void;
-    showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions, extra?: {
+        slider?: HookSelectorSlider;
+    }): Promise<string | undefined>;
     hideHookSelector(): void;
     showHookInput(title: string, placeholder?: string): Promise<string | undefined>;
     hideHookInput(): void;

package/dist/types/modes/internal-url-autocomplete.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Autocomplete for internal-url schemes (skill://, rule://, omp://, local://,
+ * memory://, agent://, artifact://) while composing a prompt.
+ *
+ * Detection here MUST stay in sync with the generic URL-scheme trigger in the
+ * TUI editor (`packages/tui/src/components/editor.ts`); the editor fires the
+ * popup, this module decides whether there are candidates to show.
+ */
+import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
+export interface InternalUrlContext {
+    /** Lowercased scheme (e.g. `local`). */
+    scheme: string;
+    /** Text typed after the slashes so far (host + path); may be empty. */
+    query: string;
+    /** Exact buffer token from its boundary to the cursor (the completion prefix). */
+    token: string;
+}
+/**
+ * Detect a completable internal-url token immediately before the cursor.
+ * Returns `null` when the text is not a `scheme://` token whose scheme is
+ * registered with a completion-capable handler.
+ */
+export declare function extractInternalUrlContext(textBeforeCursor: string): InternalUrlContext | null;
+/**
+ * Suggestions for the internal-url token ending at the cursor, or `null` when
+ * the text is not such a token or no candidate matches the typed query.
+ */
+export declare function getInternalUrlSuggestions(textBeforeCursor: string): Promise<{
+    items: AutocompleteItem[];
+    prefix: string;
+} | null>;
+/** Whether `prefix` (the token a completion was offered for) is an internal-url token. */
+export declare function isInternalUrlPrefix(prefix: string): boolean;
+/**
+ * Replace the internal-url token with the selected candidate, appending a
+ * trailing space (matching `@` file-reference behavior) so the user can keep
+ * typing.
+ */
+export declare function applyInternalUrlCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+};

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

@@ -0,0 +1,10 @@
+/** 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). */
+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;

package/dist/types/modes/setup-wizard/index.d.ts

@@ -0,0 +1,16 @@
+import type { Settings } from "../../config/settings";
+import type { InteractiveModeContext } from "../types";
+import type { SetupScene } from "./scenes/types";
+export type { SetupScene, SetupSceneController, SetupSceneHost, SetupSceneResult } from "./scenes/types";
+export declare const ALL_SCENES: readonly [SetupScene, SetupScene, SetupScene];
+export declare const CURRENT_SETUP_VERSION: number;
+export interface SetupSceneSelectionOptions {
+    resuming?: boolean;
+    isTTY?: boolean;
+    skipEnv?: string;
+    setupWizardEnabled?: boolean;
+    force?: boolean;
+}
+export declare function selectSetupScenes(storedVersion: number, scenes: readonly SetupScene[], ctx?: InteractiveModeContext, options?: SetupSceneSelectionOptions): Promise<SetupScene[]>;
+export declare function markSetupWizardComplete(settings: Settings, version?: number): Promise<void>;
+export declare function runSetupWizard(ctx: InteractiveModeContext, scenes?: readonly SetupScene[]): Promise<void>;

package/dist/types/modes/setup-wizard/scenes/glyph.d.ts

@@ -0,0 +1,2 @@
+import type { SetupScene } from "./types";
+export declare const glyphSetupScene: SetupScene;

package/dist/types/modes/setup-wizard/scenes/outro.d.ts

@@ -0,0 +1,2 @@
+export declare const SETUP_OUTRO_MS = 1200;
+export declare function renderSetupOutro(width: number, height: number, elapsedMs: number): string[];

package/dist/types/modes/setup-wizard/scenes/providers.d.ts

@@ -0,0 +1,2 @@
+import type { SetupScene } from "./types";
+export declare const providersSetupScene: SetupScene;