@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.4

package/dist/types/advisor/__tests__/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/advisor/advise-tool.d.ts

@@ -8,11 +8,15 @@ export type AdvisorSeverity = "nit" | "concern" | "blocker";
 export interface AdviseDetails {
     note: string;
     severity?: AdvisorSeverity;
+    /** Which configured advisor produced this note (omitted for the default advisor). */
+    advisor?: string;
 }
 /** One queued advice note. */
 export interface AdvisorNote {
     note: string;
     severity?: AdvisorSeverity;
+    /** Which configured advisor produced this note (omitted for the default advisor). */
+    advisor?: string;
 }
 /** Details payload on the batched `advisor` custom message rendered in the transcript. */
 export interface AdvisorMessageDetails {
@@ -78,11 +82,11 @@ export declare function resolveAdvisorDeliveryChannel(opts: {
  */
 export declare function deriveAdvisorTelemetry(primaryTelemetry: AgentTelemetryConfig | undefined, identity: AgentIdentity): AgentTelemetryConfig | undefined;
 /**
- * Side-effect-free investigation tools handed to the advisor agent so it can
- * inspect the workspace before weighing in. Names match the primary session's
- * tool instances, which the advisor reuses.
+ * The tools an advisor receives by default when its config omits `tools` — the
+ * read-only investigative set. The full available pool is every built tool the
+ * session has (the advisor is a full agent); a config's `tools` selects from it.
  */
-export declare const ADVISOR_READONLY_TOOL_NAMES: ReadonlySet<string>;
+export declare const ADVISOR_DEFAULT_TOOL_NAMES: ReadonlySet<string>;
 export declare class AdviseTool implements AgentTool<typeof adviseSchema, AdviseDetails> {
     #private;
     private readonly onAdvice;

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

@@ -0,0 +1,88 @@
+/**
+ * One advisor declared in a `WATCHDOG.yml` file. `model` is a model selector
+ * with an optional `:level` thinking suffix (e.g. `x-ai/grok-code-fast:high`),
+ * resolved exactly like any other model override; `tools` is a subset of the
+ * read-only investigative tool names (default: all). `instructions` is the
+ * advisor's specialization, appended to the shared baseline.
+ */
+export interface AdvisorConfig {
+    name: string;
+    model?: string;
+    tools?: string[];
+    instructions?: string;
+}
+/**
+ * The result of walking the `WATCHDOG.yml`/`WATCHDOG.yaml` search path: the
+ * deduped advisor roster plus the concatenated top-level `instructions` baseline
+ * that is prepended (alongside `WATCHDOG.md`) to every advisor.
+ */
+export interface DiscoveredAdvisors {
+    advisors: AdvisorConfig[];
+    sharedInstructions: string | undefined;
+}
+/**
+ * Normalize an advisor name into a filesystem-/id-safe slug used for its
+ * transcript filename and session id: lowercase, non-alphanumerics collapsed to
+ * `-`, leading/trailing `-` trimmed. Falls back to `"advisor"` when nothing
+ * survives; callers dedupe collisions.
+ */
+export declare function slugifyAdvisorName(name: string): string;
+/**
+ * Discover advisor configs from `WATCHDOG.yml`/`WATCHDOG.yaml` files on the same
+ * user + project search path as `WATCHDOG.md`. Advisors are keyed by slug; a
+ * more-specific file (project leaf > project ancestor > user) replaces an earlier
+ * entry with the same slug. Top-level `instructions` across all files concatenate
+ * into the shared baseline. A malformed file is logged and skipped — never
+ * thrown — so a bad project config can't kill the session.
+ */
+export declare function discoverAdvisorConfigs(cwd: string, agentDir?: string): Promise<DiscoveredAdvisors>;
+/** Which level a `WATCHDOG.yml` lives at: the project root or the user agent dir. */
+export type AdvisorConfigScope = "project" | "user";
+/**
+ * The editable contents of a single `WATCHDOG.yml` file: the shared top-level
+ * `instructions` plus the advisor roster. Unlike {@link DiscoveredAdvisors}, this
+ * is one file's raw view (no cross-level merge, no `@import` expansion) so the
+ * config editor round-trips exactly what the user wrote.
+ */
+export interface WatchdogConfigDoc {
+    instructions?: string;
+    advisors: AdvisorConfig[];
+}
+/**
+ * Resolve the `WATCHDOG.yml` path for a scope: `project` → `<projectDir>/WATCHDOG.yml`
+ * (discovered by the project-level walk), `user` → `<agentDir>/WATCHDOG.yml` (the
+ * user-level candidate).
+ */
+export declare function advisorConfigFilePath(scope: AdvisorConfigScope, dirs: {
+    projectDir: string;
+    agentDir: string;
+}): string;
+/**
+ * Resolve which `WATCHDOG.{yml,yaml}` to edit for a scope: prefer the canonical
+ * `.yml`, but when only a `.yaml` exists for that scope, edit it in place so an
+ * existing `.yaml` user isn't shown a blank editor and left with two files at the
+ * same precedence. Falls back to `.yml` when neither exists.
+ */
+export declare function resolveAdvisorConfigEditPath(scope: AdvisorConfigScope, dirs: {
+    projectDir: string;
+    agentDir: string;
+}): Promise<string>;
+/**
+ * Load one `WATCHDOG.yml` file for editing — raw, un-merged, un-expanded. Missing,
+ * unparseable, or schema-invalid files yield an empty doc (never throws) so the
+ * editor opens cleanly on a fresh or broken file.
+ */
+export declare function loadWatchdogConfigFile(filePath: string): Promise<WatchdogConfigDoc>;
+/**
+ * Serialize an editable doc back to block-style `WATCHDOG.yml` text via Bun's
+ * `YAML.stringify` (the same API the repo uses for other hand-editable config),
+ * omitting empty fields. Round-trips through {@link loadWatchdogConfigFile}.
+ * Returns `""` for an empty doc.
+ */
+export declare function serializeWatchdogConfig(doc: WatchdogConfigDoc): string;
+/**
+ * Write an editable doc to `WATCHDOG.yml`. An empty doc removes the file so
+ * discovery falls back to the legacy single-advisor path rather than leaving an
+ * empty config behind.
+ */
+export declare function saveWatchdogConfigFile(filePath: string, doc: WatchdogConfigDoc): Promise<void>;

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

@@ -1,4 +1,5 @@
 export * from "./advise-tool";
+export * from "./config";
 export * from "./emission-guard";
 export * from "./runtime";
 export * from "./transcript-recorder";

package/dist/types/advisor/transcript-recorder.d.ts

@@ -6,6 +6,14 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
  */
 export declare const ADVISOR_TRANSCRIPT_STEM = "__advisor";
 export declare const ADVISOR_TRANSCRIPT_FILENAME = "__advisor.jsonl";
+/**
+ * Transcript filename for an advisor: `__advisor.jsonl` for the legacy/default
+ * advisor (empty slug), `__advisor.<slug>.jsonl` for a named advisor. The `.`
+ * separator keeps named files out of the output manager's `-<n>` bump namespace.
+ */
+export declare function advisorTranscriptFilename(slug: string): string;
+/** Whether a filename is any advisor transcript (`__advisor.jsonl` or `__advisor.<slug>.jsonl`). */
+export declare function isAdvisorTranscriptName(name: string): boolean;
 /**
  * Append-only persister for an advisor agent's transcript.
  *
@@ -32,11 +40,14 @@ export declare class AdvisorTranscriptRecorder {
     private readonly resolveSessionFile;
     private readonly resolveCwd;
     /**
+     * @param filename Transcript filename within the session dir. Defaults to
+     *   `__advisor.jsonl`; named advisors pass `__advisor.<slug>.jsonl` via
+     *   {@link advisorTranscriptFilename}.
      * @param after Optional barrier the queue starts behind — used on the advisor
      *   on→off→on toggle so a fresh recorder's first `open` waits for the prior
-     *   recorder's `close` and the two never hold the same `__advisor.jsonl` at once.
+     *   recorder's `close` and the two never hold the same file at once.
      */
-    constructor(resolveSessionFile: () => string | undefined, resolveCwd: () => string, after?: Promise<unknown>);
+    constructor(resolveSessionFile: () => string | undefined, resolveCwd: () => string, filename?: string, after?: Promise<unknown>);
     /**
      * Persist one finalized advisor message. Assistant turns carry the usage the
      * stats parser reads; tool results round out the Hub transcript; user deltas

package/dist/types/advisor/watchdog.d.ts

@@ -11,6 +11,26 @@ export declare function formatAdvisorContextPrompt(contextFiles: ReadonlyArray<{
     path: string;
     content: string;
 }>): string | undefined;
+/**
+ * A readable config candidate discovered on the watchdog/advisor search path,
+ * with raw (un-expanded) content and its position metadata.
+ */
+export interface ConfigCandidate {
+    path: string;
+    content: string;
+    level: "user" | "project";
+    depth: number;
+}
+/**
+ * Walk the watchdog/advisor config search path — the user agent dir plus every
+ * directory from `cwd` up to the repo root (or home), probing both `<F>` and
+ * `.omp/<F>` for each given filename — and return the readable candidates with
+ * their raw content, sorted user-first then project ancestor→leaf (depth
+ * descending, so the leaf directory is most specific/last). Shared by
+ * {@link discoverWatchdogFiles} and `discoverAdvisorConfigs`. Content is returned
+ * verbatim (no `@import` expansion); callers expand what they need.
+ */
+export declare function collectConfigCandidates(cwd: string, agentDir: string | undefined, filenames: string[]): Promise<ConfigCandidate[]>;
 /**
  * Discover and load WATCHDOG.md files walking up from cwd, project .omp folder, and user agent dir.
  * Returns formatted watchdog file blocks ready to be appended to the advisor system prompt.

package/dist/types/cli/update-cli.d.ts

@@ -27,6 +27,21 @@ interface UpdateMethodResolutionOptions {
     miseDataDir?: string;
 }
 export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
+interface BunInstallCachePruneResult {
+    scannedPackages: number;
+    removedEntries: number;
+}
+/**
+ * Prune Bun's package cache so each package keeps only its newest cached version.
+ *
+ * Bun stores package cache entries as both a package marker directory
+ * (`react/19.2.6@@@1`) and a materialized package directory
+ * (`react@19.2.6@@@1`). Global `omp` updates can leave one full copy per
+ * release. The marker and materialized entries are removed together so the
+ * cache stays internally consistent.
+ */
+export declare function pruneBunInstallCache(cacheDir: string, packageNames?: Set<string>): Promise<BunInstallCachePruneResult>;
+export declare function resolveBunGlobalNodeModulesDirFromLocations(globalBinDir: string | undefined, cacheDir: string | undefined): string | undefined;
 /**
  * Best-effort removal of binary-update backups left by earlier runs.
  *

package/dist/types/collab/guest.d.ts

@@ -5,6 +5,35 @@ import { AgentRegistry } from "../registry/agent-registry";
 import { type CollabSessionState } from "./protocol";
 /** Commands a guest may run locally; everything else is host-only. */
 export declare const COLLAB_GUEST_ALLOWED_COMMANDS: Record<string, true>;
+/** Minimal context surface the idle-state reconciler mutates. */
+export interface GuestIdleReconcilerCtx {
+    statusLine: {
+        markActivityEnd: () => void;
+    };
+    loadingAnimation: {
+        stop: () => void;
+    } | undefined;
+}
+/**
+ * Close the guest UI state held open by an earlier `agent_start` whose
+ * matching `agent_end` never reached us — most often because a reconnect
+ * dropped the event mid-stream. Triggered from {@link CollabGuestLink}'s
+ * `state` reconciler when the host reports `isStreaming === false`:
+ * folds the in-flight active-time window into the per-session meter (so
+ * `time_spent` stops ticking) and stops the `Working…` loader if one is
+ * still animating. No-op when the host is still streaming.
+ *
+ * Exported for direct unit testing; mutates the loader field on `ctx` so
+ * the same loader is not stopped twice on subsequent reconciliations.
+ */
+export declare function reconcileGuestIdleHostState(ctx: GuestIdleReconcilerCtx, isStreaming: boolean): void;
+/** Reconcile a welcome/resync snapshot's host activity state into the guest meter. */
+export interface GuestSnapshotActivityReconcilerCtx extends GuestIdleReconcilerCtx {
+    statusLine: GuestIdleReconcilerCtx["statusLine"] & {
+        markActivityStart: () => void;
+    };
+}
+export declare function reconcileGuestSnapshotHostState(ctx: GuestSnapshotActivityReconcilerCtx, isStreaming: boolean): void;
 export declare class CollabGuestLink {
     #private;
     state: CollabSessionState | null;

package/dist/types/collab/replication-shrink.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Hard-cap helper for host→guest collab frames.
+ *
+ * The host wraps every {@link CollabFrame} in an AES-GCM envelope and ships it
+ * through the relay's WebSocket. WebSocket servers enforce a per-frame
+ * `maxPayloadLength` (Bun's default is 16 MB; many proxies cap lower). A
+ * single oversized payload — typically a `read`/`bash`/`search` tool result
+ * captured as one multi-megabyte string, or a tool result whose `content`
+ * array holds thousands of small blocks — would otherwise ship as its own
+ * oversized frame and trip that limit, killing the host's WebSocket with
+ * `1006 Received too big message`. `CollabSocket` treats 1006 as transient
+ * and reconnects, the next guest hello triggers the same oversized send, and
+ * the loop never breaks (issue #3739).
+ *
+ * This helper bounds any JSON-serializable payload below
+ * {@link MAX_REPLICATED_PAYLOAD_BYTES}. Already-small payloads pass through
+ * untouched; oversized ones are returned as a deep-cloned shadow where long
+ * strings are head-truncated AND long arrays are head-clipped, with
+ * `[…N chars elided for collab session]` / `[…N items elided for collab
+ * session]` markers. Both axes are needed: string truncation alone leaves
+ * the cap unenforced for a payload built of many short strings, where no
+ * field exceeds the per-string floor.
+ */
+/**
+ * Per-payload ceiling for host→guest frames. Bun's default WebSocket
+ * `maxPayloadLength` is 16 MB; we leave a generous margin so the AES-GCM
+ * envelope (+ IV + tag), the 4-byte peer header, and the outer wire wrapper
+ * fit comfortably under that on every reasonable relay.
+ */
+export declare const MAX_REPLICATED_PAYLOAD_BYTES: number;
+/**
+ * Return `value` unchanged when its JSON serialization already fits
+ * {@link MAX_REPLICATED_PAYLOAD_BYTES}; otherwise return a deep-cloned
+ * shadow shrunk along both string and array axes until the payload fits.
+ * The function is generic over `T` because the wire shape is preserved:
+ * only string leaves and array tails change; discriminator fields, ids, and
+ * other small metadata pass through untouched.
+ */
+export declare function shrinkForReplication<T>(value: T): T;

package/dist/types/config/provider-globals.d.ts

@@ -0,0 +1,7 @@
+interface ProviderGlobalSettings {
+    get(path: "providers.webSearchExclude"): unknown;
+    get(path: "providers.webSearch"): unknown;
+    get(path: "providers.image"): unknown;
+}
+export declare function applyProviderGlobalsFromSettings(settings: ProviderGlobalSettings): void;
+export {};

package/dist/types/config/settings-schema.d.ts

@@ -443,6 +443,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Use the terminal's default background for the status line instead of the theme's `statusLineBg`. Powerline end caps are dropped because they need a contrasting fill to bridge into the surrounding terminal.";
         };
     };
+    readonly "statusLine.compactThinkingLevel": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "appearance";
+            readonly group: "Status Line";
+            readonly label: "Compact Thinking Level";
+            readonly description: "Show the thinking level as a single icon on the model name instead of a separate ` · <level>` suffix.";
+        };
+    };
     readonly "tools.artifactSpillThreshold": {
         readonly type: "number";
         readonly default: 50;
@@ -1667,6 +1677,42 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Notify when the ask tool is waiting for input";
         };
     };
+    readonly "recap.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Notifications";
+            readonly label: "Idle Recap";
+            readonly description: "Generate a brief LLM recap of where things stand after the terminal has been idle";
+        };
+    };
+    readonly "recap.idleSeconds": {
+        readonly type: "number";
+        readonly default: 240;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Notifications";
+            readonly label: "Idle Recap Delay";
+            readonly description: "Seconds to wait while idle before showing the recap";
+            readonly options: readonly [{
+                readonly value: "60";
+                readonly label: "1 minute";
+            }, {
+                readonly value: "120";
+                readonly label: "2 minutes";
+            }, {
+                readonly value: "240";
+                readonly label: "4 minutes";
+            }, {
+                readonly value: "300";
+                readonly label: "5 minutes";
+            }, {
+                readonly value: "600";
+                readonly label: "10 minutes";
+            }];
+        };
+    };
     readonly "collab.relayUrl": {
         readonly type: "string";
         readonly default: "wss://my.omp.sh";
@@ -1955,6 +2001,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Use remote compaction endpoints when available instead of local summarization";
         };
     };
+    readonly "compaction.remoteStreamingV2Enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "context";
+            readonly group: "Compaction";
+            readonly label: "Remote Compaction V2";
+            readonly description: "Use Responses streaming compaction for compatible remote compaction models";
+        };
+    };
     readonly "compaction.reserveTokens": {
         readonly type: "number";
         readonly default: 16384;
@@ -1971,6 +2027,10 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly default: undefined;
     };
+    readonly "compaction.v2RetainedMessageBudget": {
+        readonly type: "number";
+        readonly default: 64000;
+    };
     readonly "compaction.idleEnabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -3907,6 +3967,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Run modes where active goals may auto-continue between turns";
         };
     };
+    readonly "title.refreshOnReplan": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly group: "Modes";
+            readonly label: "Refresh Title on Replan";
+            readonly description: "Refresh generated session titles after todo init replans unless the title was set by the user";
+        };
+    };
     readonly "task.isolation.mode": {
         readonly type: "enum";
         readonly values: readonly ["none", "auto", "apfs", "btrfs", "zfs", "reflink", "overlayfs", "projfs", "block-clone", "rcopy"];
@@ -5272,12 +5342,21 @@ export interface CompactionSettings {
     autoContinue: boolean;
     remoteEnabled: boolean;
     remoteEndpoint: string | undefined;
+    remoteStreamingV2Enabled: boolean;
+    v2RetainedMessageBudget: number;
     idleEnabled: boolean;
     idleThresholdTokens: number;
     idleTimeoutSeconds: number;
     supersedeReads: boolean;
     dropUseless: boolean;
 }
+export interface RecapSettings {
+    enabled: boolean;
+    idleSeconds: number;
+}
+export interface TitleSettings {
+    refreshOnReplan: boolean;
+}
 export interface ContextPromotionSettings {
     enabled: boolean;
 }
@@ -5408,6 +5487,8 @@ export interface GcSettings {
 /** Map group prefix -> typed settings interface */
 export interface GroupTypeMap {
     compaction: CompactionSettings;
+    recap: RecapSettings;
+    title: TitleSettings;
     contextPromotion: ContextPromotionSettings;
     retry: RetrySettings;
     memories: MemoriesSettings;

package/dist/types/debug/log-viewer.d.ts

@@ -35,6 +35,7 @@ export declare class DebugLogViewerModel {
     setFilterQuery(query: string): void;
     toggleProcessFilter(): void;
     moveCursor(delta: number, extendSelection: boolean): void;
+    moveCursorToRow(rowIndex: number, extendSelection: boolean): boolean;
     getSelectedLogIndices(): number[];
     getSelectedCount(): number;
     isSelected(logIndex: number): boolean;

package/dist/types/debug/raw-sse.d.ts

@@ -12,6 +12,7 @@ export interface RawSseViewerOptions {
 export declare class RawSseViewerComponent implements Component {
     #private;
     constructor(options: RawSseViewerOptions);
+    dispose(): void;
     handleInput(keyData: string): void;
     invalidate(): void;
     render(width: number): readonly string[];

package/dist/types/edit/hashline/diff.d.ts

@@ -1,14 +1,3 @@
-/**
- * Read-only hashline diff preview helpers used by the streaming edit
- * renderer. Reads the target file, parses + applies the section's edits in
- * memory (no FS write, no LSP writethrough), then hands the before/after
- * pair to {@link generateDiffString} so the renderer can show the diff
- * while the tool call is still streaming.
- *
- * Uses the same snapshot-tag semantics as the apply path: a live content-hash
- * match is accepted even when the tag was minted by a source that did not keep
- * history, and stale tags recover through the session snapshot store when possible.
- */
 import { type PatchSection, type SnapshotStore } from "@oh-my-pi/hashline";
 export interface HashlineDiffOptions {
     /**

package/dist/types/extensibility/tool-event-input.d.ts

@@ -1,2 +1,9 @@
+interface ToolEventInputResolver {
+    name: string;
+    resolveEventInput?: (input: string) => string;
+}
+/** Resolves mode-specific textual tool input before extension/hook event normalization. */
+export declare function resolveToolEventInput(tool: ToolEventInputResolver, input: Record<string, unknown>): Record<string, unknown>;
 /** Adds derived compatibility fields to tool event input without changing tool execution parameters. */
 export declare function normalizeToolEventInput(toolName: string, input: Record<string, unknown>): Record<string, unknown>;
+export {};

package/dist/types/extensibility/utils.d.ts

@@ -10,3 +10,15 @@ export declare function resolvePath(filePath: string, cwd: string): string;
  * Create a no-op UI context for headless modes.
  */
 export declare function createNoOpUIContext(): HookUIContext;
+/**
+ * Raised by {@link withExitGuard} when a guarded callback synchronously
+ * attempts to terminate the host process. Callers catch this like any other
+ * load-time failure so the extension/hook is skipped with a logged error
+ * instead of taking the CLI down with it.
+ */
+export declare class ExtensionExitError extends Error {
+    readonly alias: string;
+    readonly code: number | string | undefined;
+    constructor(code: number | string | undefined, alias?: string);
+}
+export declare function withExitGuard<T>(fn: () => Promise<T>): Promise<T>;

package/dist/types/mcp/transports/index.d.ts

@@ -2,4 +2,5 @@
  * MCP transport exports.
  */
 export * from "./http";
+export * from "./sse";
 export * from "./stdio";

package/dist/types/mcp/transports/sse.d.ts

@@ -0,0 +1,20 @@
+import type { MCPRequestOptions, MCPSseServerConfig, MCPTransport } from "../../mcp/types";
+/** Legacy MCP HTTP+SSE transport from protocol revision 2024-11-05. */
+export declare class LegacySseTransport implements MCPTransport {
+    #private;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+    onNotification?: (method: string, params: unknown) => void;
+    onRequest?: (method: string, params: unknown) => Promise<unknown>;
+    /** Called on 401/403 to attempt token refresh. Returns updated headers or null. */
+    onAuthError?: () => Promise<Record<string, string> | null>;
+    constructor(config: MCPSseServerConfig);
+    get connected(): boolean;
+    get url(): string;
+    connect(): Promise<void>;
+    request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    close(): Promise<void>;
+}
+/** Create and connect a legacy HTTP+SSE transport. */
+export declare function createSseTransport(config: MCPSseServerConfig): Promise<LegacySseTransport>;

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

@@ -14,10 +14,28 @@ export declare function startMemoryStartupTask(options: {
     agentDir: string;
     taskDepth: number;
 }): void;
+interface MemoryInstructionSession {
+    sessionManager: Pick<AgentSession["sessionManager"], "getSessionFile">;
+}
+/**
+ * Drop the per-session memory instruction snapshot after explicit memory state
+ * changes that must affect the active conversation immediately, such as
+ * `/memory clear`.
+ */
+export declare function clearMemoryToolDeveloperInstructionsCache(session: MemoryInstructionSession | undefined): void;
+/**
+ * Refresh the active session's consolidated-memory snapshot after startup maintenance.
+ *
+ * Startup may finish after the first prompt build and write `memory_summary.md`;
+ * the active session should see that summary. It must not reread `learned.md`,
+ * because a `learn` call racing with startup belongs to the next session's
+ * memory prompt, not the active prompt-cache prefix.
+ */
+export declare function refreshMemoryToolDeveloperInstructionsCacheAfterStartup(session: MemoryInstructionSession, agentDir: string, settings: Settings): Promise<void>;
 /**
  * Build memory usage instructions for prompt injection.
  */
-export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings): Promise<string | undefined>;
+export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings, session?: MemoryInstructionSession): Promise<string | undefined>;
 /**
  * Clear all persisted memory state and generated artifacts.
  */
@@ -33,3 +51,4 @@ export declare function getMemoryRoot(agentDir: string, cwd: string): string;
  * tool when `memory.backend` is `local`.
  */
 export declare function saveLearnedLesson(agentDir: string, cwd: string, input: MemoryBackendSaveInput): Promise<MemoryBackendSaveResult>;
+export {};

package/dist/types/modes/components/advisor-config.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Fullscreen `/advisor configure` overlay: a mouse- and keyboard-driven editor
+ * for the `WATCHDOG.yml` advisor roster at project or user level.
+ *
+ * It paints the entire alternate screen from row 0 (so SGR mouse rows index
+ * directly into the rendered frame) using the shared {@link ./overlay-box} chrome.
+ * The list screen is a two-pane split (the `/extensions` idiom): a clickable
+ * advisor/action sidebar on the left, and a scrollable preview of the highlighted
+ * advisor's model / tools / instructions on the right, filling the free space.
+ *
+ * Each screen is backed by a proven primitive — {@link SelectList} (list / detail
+ * / tools / thinking), {@link Input} (name), {@link ModelSelectorComponent} (the
+ * same rich `/model` picker, in direct-select mode), and {@link HookEditorComponent}
+ * (multiline instructions; Ctrl+G opens `$EDITOR`). The overlay edits an in-memory
+ * {@link WatchdogConfigDoc} and only touches disk + the live advisors via the host
+ * `save` callback.
+ */
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import { type Component, type TUI } from "@oh-my-pi/pi-tui";
+import { type AdvisorConfigScope, type WatchdogConfigDoc } from "../../advisor";
+import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
+/** Host callbacks: all disk + live-runtime effects flow through these. */
+export interface AdvisorConfigCallbacks {
+    /** Load a scope's `WATCHDOG.yml` into an editable doc (empty when absent). */
+    loadDoc: (scope: AdvisorConfigScope) => Promise<WatchdogConfigDoc>;
+    /** Persist the doc to the scope's file and rebuild the live advisors. */
+    save: (scope: AdvisorConfigScope, doc: WatchdogConfigDoc) => Promise<void>;
+    /** Tear down the overlay and restore the editor. */
+    close: () => void;
+    requestRender: () => void;
+    /** Surface a transient status/warning line to the user. */
+    notify: (message: string) => void;
+}
+export interface AdvisorConfigDeps {
+    modelRegistry: ModelRegistry;
+    settings: Settings;
+    scopedModels: ReadonlyArray<{
+        model: Model;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    availableToolNames: string[];
+    /** Formatted advisor-role model shown on the seeded default row (e.g. "anthropic/claude-..."). */
+    defaultModelLabel?: string;
+}
+/**
+ * Fullscreen advisor-configuration overlay. Implements {@link Component} directly
+ * (rather than extending Container) so it owns the whole frame and the mouse
+ * geometry needed to make every row clickable.
+ */
+export declare class AdvisorConfigOverlayComponent implements Component {
+    #private;
+    constructor(tui: TUI, deps: AdvisorConfigDeps, scope: AdvisorConfigScope, doc: WatchdogConfigDoc, callbacks: AdvisorConfigCallbacks);
+    render(width: number): readonly string[];
+    handleInput(data: string): void;
+    /** Forward enhanced-paste transports into a multiline instructions editor. */
+    pasteText(text: string): void;
+}

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

@@ -1,3 +1,4 @@
+export * from "./advisor-config";
 export * from "./assistant-message";
 export * from "./bash-execution";
 export * from "./bordered-loader";

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

@@ -1,5 +1,5 @@
 import type { Model } from "@oh-my-pi/pi-ai";
-import { Container, Input, type TUI } from "@oh-my-pi/pi-tui";
+import { Container, Input, type SgrMouseEvent, type TUI } from "@oh-my-pi/pi-tui";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { Settings } from "../../config/settings";
 import { type ConfiguredThinkingLevel } from "../../thinking";
@@ -19,9 +19,17 @@ export declare class ModelSelectorComponent extends Container {
     #private;
     constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
         temporaryOnly?: boolean;
+        directSelect?: boolean;
+        pickerHint?: string;
         initialSearchInput?: string;
         currentContextTokens?: number;
     });
+    /**
+     * Concatenate children like Container.render, recording where the model list
+     * lands so routed mouse events can be hit-tested against it.
+     */
+    render(width: number): readonly string[];
+    routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
     handleInput(keyData: string): void;
     getSearchInput(): Input;
 }