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

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

@@ -34,6 +34,7 @@ export interface StatusLinePreviewSettings {
     separator?: StatusLineSeparatorStyle;
     sessionAccent?: boolean;
     transparent?: boolean;
+    compactThinkingLevel?: boolean;
 }
 export interface SettingsCallbacks {
     /** Called when any setting value changes */

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

@@ -14,9 +14,43 @@ export declare class StatusLineComponent implements Component {
     getEffectiveSettingsForTest(): EffectiveStatusLineSettings;
     setAutoCompactEnabled(enabled: boolean): void;
     setSubagentCount(count: number): void;
+    /**
+     * Compatibility shim for callers predating the simplified subagent badge.
+     * The status line now intentionally shows only the active count.
+     */
+    setSubagentHubHint(_hint: string | undefined): void;
     /** Active subagent count as currently displayed (collab state mirroring). */
     get subagentCount(): number;
-    setSessionStartTime(time: number): void;
+    /**
+     * Reset the currently-attached session's active-time accumulators so
+     * the `time_spent` segment starts from zero. Called from `/clear`,
+     * fresh-session, and joined-collab paths; both the completed
+     * accumulator and any in-flight window are dropped, so a reset
+     * mid-turn ignores the running window (the matching `markActivityEnd`
+     * will see an idle meter and no-op).
+     */
+    resetActiveTime(): void;
+    /**
+     * Mark the currently-attached session as having started a unit of
+     * active processing. Idempotent: a second start while a window is
+     * already open is a no-op, so reentrant `agent_start` events (e.g.
+     * nested auto-compaction loops, focus-controller mid-turn attach onto
+     * an already-running window) do not double-count.
+     */
+    markActivityStart(): void;
+    /**
+     * Close the currently-attached session's open active-processing
+     * window, folding its elapsed time into the accumulator. Idempotent
+     * when the meter is already idle so callers can fire it on every
+     * `agent_end` without guarding.
+     */
+    markActivityEnd(): void;
+    /**
+     * Snapshot of total active-processing time for the currently-attached
+     * session, including any in-flight window. Exposed for the segment
+     * context builder; tests assert against this too.
+     */
+    getActiveMs(): number;
     setPlanModeStatus(status: {
         enabled: boolean;
         paused: boolean;

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

@@ -41,6 +41,9 @@ export interface StatusLineSettings {
     /** Drop the theme's `statusLineBg` fill and powerline caps so the bar
      *  inherits the terminal's default background. */
     transparent?: boolean;
+    /** Replace the model-segment icon with the thinking-level glyph and drop the
+     *  " · <level>" suffix, so the thinking level reads as a single compact icon. */
+    compactThinkingLevel?: boolean;
 }
 export type EffectiveStatusLineSettings = Required<Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">> & StatusLineSettings;
 export type RGB = readonly [number, number, number];
@@ -51,6 +54,8 @@ export interface SegmentContext {
     activeRepo: ActiveRepoContext | null;
     width: number;
     options: StatusLineSegmentOptions;
+    /** Render the model segment's thinking level as a compact leading glyph. */
+    compactThinkingLevel: boolean;
     planMode: {
         enabled: boolean;
         paused: boolean;
@@ -78,7 +83,14 @@ export interface SegmentContext {
     contextWindow: number;
     autoCompactEnabled: boolean;
     subagentCount: number;
-    sessionStartTime: number;
+    /**
+     * Active processing time accumulated this session, in ms — the union of
+     * every `agent_start`→`agent_end` window plus the currently-streaming
+     * window if the agent is running. Idle wall-clock never contributes, so
+     * this is what {@link StatusLineSegmentId.time_spent} renders instead of
+     * `Date.now() - sessionStart`.
+     */
+    activeMs: number;
     git: {
         branch: string | null;
         status: {

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

@@ -30,13 +30,13 @@ export declare class CommandController {
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     /**
-     * `/move` — switch to a fresh empty session in a different directory.
+     * `/move` — relocate the current session to a different directory.
      *
      * With no `targetPath` (TUI only), opens an autocomplete overlay so the user
      * can pick or type a directory. With a `targetPath`, resolves it directly.
      * If the target directory does not exist, the user is asked whether to create
-     * it. A brand-new empty session is then started in the target directory and
-     * the current session is left behind (resumable via `/resume`).
+     * it. The active session file and artifacts are moved into the target
+     * directory's session bucket so `/resume` from that directory can find it.
      */
     handleMoveCommand(targetPath?: string): Promise<void>;
     handleRenameCommand(title: string): Promise<void>;

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

@@ -25,6 +25,7 @@ export declare class SelectorController {
         focus: Component;
     }): void;
     showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
     showHistorySearch(): void;
     /**
      * Show the Extension Control Center dashboard.

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

@@ -83,6 +83,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
+    todoReminderContainer: Container;
     todoContainer: Container;
     subagentContainer: Container;
     btwContainer: Container;
@@ -109,11 +110,16 @@ export declare class InteractiveMode implements InteractiveModeContext {
     loopLimit: LoopLimitRuntime | undefined;
     todoPhases: TodoPhase[];
     hideThinkingBlock: boolean;
+    /** Whether the visible session has produced thinking content the user can reveal. */
+    get hasDisplayableThinkingContent(): boolean;
+    /** Record received reasoning content so Ctrl+T can reveal it even when model metadata says thinking is off. */
+    noteDisplayableThinkingContent(message: AgentMessage): boolean;
     /**
-     * Effective thinking-block visibility: hidden when the user's setting is on
-     * OR the session thinking level is "off". Some providers (MiniMax, GLM,
-     * DeepSeek) return thinking blocks even with reasoning disabled; this
-     * respects the user's intent when they set thinking to "off" (#626).
+     * Effective thinking-block visibility: hidden when the user's setting is on,
+     * or while thinking is "off" before the session has actually produced
+     * displayable thinking content. Some providers return thinking blocks without
+     * advertising reasoning support, so observed content unlocks the visibility
+     * toggle.
      */
     get effectiveHideThinkingBlock(): boolean;
     proseOnlyThinking: boolean;
@@ -319,6 +325,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
     openInBrowser(urlOrPath: string): void;
     showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
     showHistorySearch(): void;
     showExtensionsDashboard(): void;
     showAgentsDashboard(): void;

package/dist/types/modes/skill-command.d.ts

@@ -0,0 +1,32 @@
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import { type CustomMessage, SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../session/messages";
+import type { InteractiveModeContext } from "./types";
+type SkillCommandHost = Pick<InteractiveModeContext, "skillCommands" | "session" | "showError">;
+type SkillPromptMessage = Pick<CustomMessage<SkillPromptDetails>, "customType" | "content" | "display" | "details" | "attribution"> & {
+    customType: typeof SKILL_PROMPT_MESSAGE_TYPE;
+    content: string | (TextContent | ImageContent)[];
+    display: true;
+    details: SkillPromptDetails;
+    attribution: "user";
+};
+type SkillPromptOptions = {
+    streamingBehavior: "steer" | "followUp";
+    queueChipText: string;
+};
+interface InvokeSkillCommandOptions {
+    propagateErrors?: boolean;
+    queueOnly?: boolean;
+    images?: ImageContent[];
+}
+/** Built custom-message payload and delivery options for a `/skill:` command. */
+export interface BuiltSkillCommandPrompt {
+    message: SkillPromptMessage;
+    options: SkillPromptOptions;
+}
+/** Return true when `text` names a registered `/skill:<name>` command. */
+export declare function isKnownSkillCommand(ctx: SkillCommandHost, text: string): boolean;
+/** Build the user-attributed custom message for a registered `/skill:<name>` command. */
+export declare function buildSkillCommandPrompt(ctx: SkillCommandHost, text: string, streamingBehavior: "steer" | "followUp", images?: ImageContent[]): Promise<BuiltSkillCommandPrompt | undefined>;
+/** Invoke a registered `/skill:<name>` command as a user-attributed custom message. */
+export declare function invokeSkillCommandFromText(ctx: SkillCommandHost, text: string, streamingBehavior: "steer" | "followUp", options?: InvokeSkillCommandOptions): Promise<boolean>;
+export {};

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

@@ -81,6 +81,7 @@ export interface InteractiveModeContext {
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
+    todoReminderContainer: Container;
     todoContainer: Container;
     subagentContainer: Container;
     btwContainer: Container;
@@ -104,7 +105,7 @@ export interface InteractiveModeContext {
     focusParentSession(): Promise<void>;
     /** Return the view to the main session (delegates to SessionFocusController.unfocus). */
     unfocusSession(): Promise<void>;
-    /** Clear loader, status/pending containers, streaming state, and pending tools. */
+    /** Clear loader, transient HUD/pending containers, streaming state, and pending tools. */
     clearTransientSessionUi(): void;
     settings: Settings;
     keybindings: KeybindingsManager;
@@ -142,10 +143,14 @@ export interface InteractiveModeContext {
     hideThinkingBlock: boolean;
     /**
      * Effective thinking-block visibility: true when hidden by user setting OR
-     * thinking level is "off". Read this in render paths instead of
-     * {@link hideThinkingBlock} so blocks are auto-hidden when thinking is off.
+     * thinking level is "off" before the session has produced displayable
+     * thinking content.
      */
     readonly effectiveHideThinkingBlock: boolean;
+    /** Whether this visible session has produced thinking content the user can reveal. */
+    readonly hasDisplayableThinkingContent: boolean;
+    /** Record a message whose thinking content makes Ctrl+T meaningful even at thinking level "off"; returns true on first observation. */
+    noteDisplayableThinkingContent(message: AgentMessage): boolean;
     proseOnlyThinking: boolean;
     compactionQueuedMessages: CompactionQueuedMessage[];
     pendingTools: Map<string, ToolExecutionHandle>;
@@ -316,6 +321,7 @@ export interface InteractiveModeContext {
     refreshSlashCommandState(cwd?: string): Promise<void>;
     applyCwdChange(newCwd: string): Promise<void>;
     showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
     showHistorySearch(): void;
     showExtensionsDashboard(): void;
     showAgentsDashboard(): void;

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

@@ -17,6 +17,7 @@ import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentT
 import { type CompactionResult, type ShakeConfig } from "@oh-my-pi/pi-agent-core/compaction";
 import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
+import { type AdvisorConfig } from "../advisor";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
 import type { ModelRegistry } from "../config/model-registry";
@@ -247,20 +248,29 @@ export interface AgentSessionConfig {
      */
     providerSessionId?: string;
     /**
-     * Hard-isolated read-only tools (read/search/find) for the advisor agent,
-     * pre-built in `createAgentSession` against a distinct `ToolSession` so the
-     * advisor's reads never share the primary's snapshot/seen-lines/conflict
-     * caches. Undefined when the advisor is disabled.
+     * Full advisor toolset, pre-built in `createAgentSession` against a distinct,
+     * advisor-scoped `ToolSession` (its own `-advisor` session/agent id) so the
+     * advisor's tool state stays isolated from the primary. The advisor is a full
+     * agent; its config `tools` selects a subset (default read/grep/glob). Undefined
+     * when the advisor is disabled.
      */
-    advisorReadOnlyTools?: AgentTool[];
+    advisorTools?: AgentTool[];
     /** Preloaded watchdog prompt content for the advisor. */
     advisorWatchdogPrompt?: string;
+    /** Preloaded YAML top-level `instructions` shared baseline, kept separate from
+     *  `advisorWatchdogPrompt` so `/advisor configure` can swap it live. */
+    advisorSharedInstructions?: string;
     /**
      * Preloaded project context files (AGENTS.md, etc.) rendered as a system-prompt
      * block for the advisor — the same standing instructions the primary agent
      * receives, so the reviewer holds the agent to them.
      */
     advisorContextPrompt?: string;
+    /**
+     * Advisors discovered from `WATCHDOG.yml`. Empty/undefined runs a single
+     * legacy advisor on the `advisor` role (byte-for-byte the pre-config path).
+     */
+    advisorConfigs?: AdvisorConfig[];
     /**
      * Strip tool descriptions from provider-bound tool specs on side requests
      * (handoff). Must match the session-start value used to build the system
@@ -356,6 +366,7 @@ export interface SessionStats {
     tokens: {
         input: number;
         output: number;
+        reasoning: number;
         cacheRead: number;
         cacheWrite: number;
         total: number;
@@ -373,6 +384,7 @@ export interface AdvisorStats {
     tokens: {
         input: number;
         output: number;
+        reasoning: number;
         cacheRead: number;
         cacheWrite: number;
         total: number;
@@ -383,6 +395,18 @@ export interface AdvisorStats {
         assistant: number;
         total: number;
     };
+    /** Per-advisor breakdown; one entry per active advisor (single-advisor sessions have one). */
+    advisors: PerAdvisorStat[];
+}
+/** One advisor's slice of {@link AdvisorStats}, surfaced for the multi-advisor status panel. */
+export interface PerAdvisorStat {
+    name: string;
+    model: Model;
+    contextWindow: number;
+    contextTokens: number;
+    tokens: AdvisorStats["tokens"];
+    cost: number;
+    messages: AdvisorStats["messages"];
 }
 export interface FreshSessionResult {
     previousSessionId: string;
@@ -394,6 +418,7 @@ export type RestoredQueuedMessage = {
     text: string;
     images?: ImageContent[];
 };
+type SessionNameTrigger = "replan";
 export declare class AgentSession {
     #private;
     readonly agent: Agent;
@@ -698,6 +723,7 @@ export declare class AgentSession {
     prompt(text: string, options?: PromptOptions): Promise<boolean>;
     promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice"> & {
         queueChipText?: string;
+        queueOnly?: boolean;
     }): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
@@ -797,7 +823,7 @@ export declare class AgentSession {
     /**
      * Set a display name for the current session.
      */
-    setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
+    setSessionName(name: string, source?: "auto" | "user", trigger?: SessionNameTrigger): Promise<boolean>;
     /**
      * Fork the current session, creating a new session file with the exact same state.
      * Copies all entries and artifacts to the new session.
@@ -808,16 +834,22 @@ export declare class AgentSession {
     /**
      * Set model directly.
      * Validates that a credential source is configured (synchronously, without
-     * refreshing OAuth or running command-backed key programs) and saves to the
-     * active session. Persists settings only when requested. The concrete key is
-     * resolved lazily per request, so switching never blocks the event loop.
+     * refreshing OAuth or running command-backed key programs). The active
+     * session switches by default; when `currentContextTokens` is provided and
+     * exceeds the refreshed candidate's context window, the live switch is
+     * skipped while role persistence still runs. Returns whether the active
+     * model actually switched, computed against the refreshed metadata so
+     * dynamic providers (e.g. llama.cpp) honor their post-load contextWindow.
      * @throws Error if no API key available for the model
      */
     setModel(model: Model, role?: string, options?: {
         selector?: string;
         thinkingLevel?: ThinkingLevel;
         persist?: boolean;
-    }): Promise<void>;
+        currentContextTokens?: number;
+    }): Promise<{
+        switched: boolean;
+    }>;
     /**
      * Set model temporarily (for this session only).
      * Validates that a credential source is configured (synchronously, without
@@ -1258,6 +1290,15 @@ export declare class AgentSession {
      * @returns true when the advisor is actively running after the call.
      */
     toggleAdvisorEnabled(): boolean;
+    /**
+     * Replace the live advisor roster from an edited `WATCHDOG.yml` (the `/advisor
+     * configure` save path). Swaps the configs + shared baseline, then rebuilds the
+     * runtimes in place so the change applies without a restart. When the advisor is
+     * disabled the new configs are simply stored for the next enable.
+     *
+     * @returns the number of advisors active after the rebuild.
+     */
+    applyAdvisorConfigs(advisors: AdvisorConfig[], sharedInstructions: string | undefined): number;
     /**
      * Whether the advisor setting is enabled for this session.
      */
@@ -1269,6 +1310,13 @@ export declare class AgentSession {
      * not merely the setting. Drives the status-line badge and `/dump advisor`.
      */
     isAdvisorActive(): boolean;
+    /**
+     * The names of the tools available to advisors this session (the pool a
+     * `/advisor configure` editor lists). The advisor is a full agent, so this is the
+     * full built tool set; a tool whose optional factory returns null (e.g. lsp with
+     * no servers) is absent.
+     */
+    getAdvisorAvailableToolNames(): string[];
     /**
      * The live advisor `Agent`, or `undefined` when no advisor runtime is
      * attached. Surfaced for diagnostics (`/dump advisor` already serializes

package/dist/types/session/indexed-session-storage.d.ts

@@ -1,16 +1,21 @@
 import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+import { type SessionTitleUpdate } from "./session-title-slot";
 export interface SessionStorageIndexEntry {
     path: string;
     size: number;
     mtimeMs: number;
+    title?: string;
+    titleSource?: SessionTitleUpdate["source"];
+    titleUpdatedAt?: string;
 }
 export interface SessionStorageBackend {
     init(): Promise<void>;
     loadIndex(): Promise<Iterable<SessionStorageIndexEntry>>;
     readFull(path: string): Promise<string | null>;
     readSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
-    writeFull(path: string, content: string, mtimeMs: number): Promise<void>;
+    writeFull(path: string, content: string, mtimeMs: number, title?: SessionTitleUpdate): Promise<void>;
     append(path: string, line: string, mtimeMs: number): Promise<void>;
+    updateSessionTitle(path: string, title: SessionTitleUpdate, mtimeMs: number): Promise<void>;
     truncate(path: string, mtimeMs: number): Promise<void>;
     remove(paths: string[]): Promise<void>;
     move(src: string, dst: string, mtimeMs: number): Promise<void>;
@@ -24,6 +29,7 @@ export declare class IndexedSessionStorage implements SessionStorage {
     ensureDirSync(_dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
+    updateSessionTitle(path: string, title: SessionTitleUpdate): Promise<void>;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;

package/dist/types/session/messages.d.ts

@@ -12,6 +12,32 @@ import type { OutputMeta } from "../tools/output-meta";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 export declare const BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE = "background-tan-dispatch";
+/** Custom message type for hidden interrupted-thinking continuity context. */
+export declare const INTERRUPTED_THINKING_MESSAGE_TYPE = "interrupted-thinking";
+/** Metadata persisted with a hidden interrupted-thinking continuity message. */
+export interface InterruptedThinkingDetails {
+    interruptedAt: number;
+    provider: AssistantMessage["provider"];
+    model: string;
+    blockCount: number;
+}
+/** Pure helper result for persisting interrupted thinking outside the assistant turn. */
+export interface DemotedInterruptedThinking {
+    reasoning: string;
+    strippedContent: AssistantMessage["content"];
+    blockCount: number;
+}
+/**
+ * Demote a trailing run of *incomplete* interrupted-thinking from an assistant
+ * message — reasoning that was still streaming when the user aborted.
+ *
+ * A block joins the run only when it is a non-empty `thinking` block with no
+ * `thinkingSignature`. A signed/complete thinking block (Anthropic signature,
+ * OpenAI reasoning item id) is safely replayable, so it ends the run and stays
+ * in place — as do `redactedThinking` encrypted blobs, text, tool calls,
+ * empty-thinking blocks, and trailing empty text placeholders.
+ */
+export declare function demoteInterruptedThinking(message: Pick<AssistantMessage, "content">): DemotedInterruptedThinking | undefined;
 /** Details persisted on a `/tan` background-dispatch breadcrumb. */
 export interface BackgroundTanDispatchDetails {
     jobId: string;

package/dist/types/session/messages.test.d.ts

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

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

@@ -1,13 +1,26 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, MessageAttribution, ServiceTier, TextContent } from "@oh-my-pi/pi-ai";
 export declare const CURRENT_SESSION_VERSION = 3;
+export declare const SESSION_TITLE_SLOT_BYTES = 256;
+export declare const SESSION_TITLE_SLOT_ENTRY_TYPE = "title";
+export declare const TITLE_CHANGE_ENTRY_TYPE = "title_change";
+export type SessionTitleSource = "auto" | "user";
+/** Fixed-width first-line slot carrying the mutable current session title. */
+export interface SessionTitleSlotEntry {
+    type: typeof SESSION_TITLE_SLOT_ENTRY_TYPE;
+    v: 1;
+    title: string;
+    source?: SessionTitleSource;
+    updatedAt: string;
+    pad: string;
+}
 export declare const EPHEMERAL_MODEL_CHANGE_ROLE = "fallback";
 export interface SessionHeader {
     type: "session";
     version?: number;
     id: string;
     title?: string;
-    titleSource?: "auto" | "user";
+    titleSource?: SessionTitleSource;
     timestamp: string;
     cwd: string;
     parentSession?: string;
@@ -91,6 +104,19 @@ export interface LabelEntry extends SessionEntryBase {
     targetId: string;
     label: string | undefined;
 }
+/** Append-only audit entry recording a session title change. */
+export interface TitleChangeEntry extends SessionEntryBase {
+    type: typeof TITLE_CHANGE_ENTRY_TYPE;
+    title: string;
+    previousTitle?: string;
+    source: SessionTitleSource;
+    trigger?: string;
+}
+declare module "@oh-my-pi/pi-agent-core/compaction/entries" {
+    interface CustomCompactionSessionEntries {
+        titleChange: TitleChangeEntry;
+    }
+}
 /** TTSR injection entry - tracks which time-traveling rules have been injected this session. */
 export interface TtsrInjectionEntry extends SessionEntryBase {
     type: "ttsr_injection";
@@ -149,9 +175,11 @@ export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
     attribution?: MessageAttribution;
 }
 /** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
-export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry;
-/** Raw file entry (includes header) */
+export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TitleChangeEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry;
+/** Raw logical file entry after loaders strip any fixed-width title slot. */
 export type FileEntry = SessionHeader | SessionEntry;
+/** Physical JSONL entry before slot-aware loaders fold the title slot. */
+export type RawFileEntry = SessionTitleSlotEntry | FileEntry;
 /** Tree node for getTree() - defensive copy of session structure */
 export interface SessionTreeNode {
     entry: SessionEntry;

package/dist/types/session/session-history-format.d.ts

@@ -18,6 +18,12 @@ export interface HistoryFormatOptions {
      * still collapse to a one-liner.
      */
     expandPrimaryContext?: boolean;
+    /**
+     * Append the full unified diff (from a tool result's `details.diff`) below
+     * edit/apply_patch tool lines, instead of just the path. The advisor sets
+     * this so it sees what changed without re-reading the file.
+     */
+    expandEditDiffs?: boolean;
 }
 /**
  * Hidden custom messages that inject the primary agent's operative *constraints*

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

@@ -1,7 +1,15 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { BlobStore } from "./blob-store";
-import type { FileEntry } from "./session-entries";
+import { type FileEntry, type SessionTitleSlotEntry } from "./session-entries";
 import { type SessionStorage } from "./session-storage";
+import { type SessionTitleUpdate } from "./session-title-slot";
+/** Parse session JSONL while stripping and folding the optional fixed title slot. */
+export declare function parseSessionContent(content: string): {
+    entries: FileEntry[];
+    titleSlot: SessionTitleUpdate | undefined;
+};
+/** Read only the fixed-size head window to detect a physical title slot. */
+export declare function readTitleSlotFromFile(filePath: string, storage?: SessionStorage): Promise<SessionTitleSlotEntry | undefined>;
 /** Exported for compaction.test.ts */
 export declare function parseSessionEntries(content: string): FileEntry[];
 /** Exported for testing */

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

@@ -3,7 +3,7 @@ import { ArtifactManager } from "./artifacts";
 import { type BlobPutOptions, type BlobPutResult } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
 import { type BuildSessionContextOptions, type SessionContext } from "./session-context";
-import { type NewSessionOptions, type SessionEntry, type SessionHeader, type SessionTreeNode, type UsageStatistics } from "./session-entries";
+import { type NewSessionOptions, type SessionEntry, type SessionHeader, type SessionTitleSource, type SessionTreeNode, type UsageStatistics } from "./session-entries";
 import { type SessionInfo } from "./session-listing";
 import { type SessionStorage } from "./session-storage";
 export type ReadonlySessionManager = Pick<SessionManager, "getCwd" | "getSessionDir" | "getSessionId" | "getSessionFile" | "getSessionName" | "getArtifactsDir" | "getArtifactManager" | "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "getLeafId" | "getLeafEntry" | "getEntry" | "getLabel" | "getBranch" | "getHeader" | "getEntries" | "getTree" | "getUsageStatistics" | "putBlob" | "putBlobSync">;
@@ -12,8 +12,10 @@ interface SessionManagerStateSnapshot {
     sessionDir: string;
     sessionId: string;
     sessionName: string | undefined;
-    titleSource: "auto" | "user" | undefined;
+    titleSource: SessionTitleSource | undefined;
     sessionFile: string | undefined;
+    titleUpdatedAt: string;
+    hasTitleSlot: boolean;
     onDisk: boolean;
     needsRewrite: boolean;
     header: SessionHeader;
@@ -109,7 +111,7 @@ export declare class SessionManager {
     saveDraft(text: string): Promise<void>;
     consumeDraft(): Promise<string | null>;
     /** The source that set the session name: "user" (manual/RPC) or "auto" (generated title). */
-    get titleSource(): "auto" | "user" | undefined;
+    get titleSource(): SessionTitleSource | undefined;
     getSessionName(): string | undefined;
     onSessionNameChanged(cb: () => void): () => void;
     /**
@@ -117,7 +119,7 @@ export declare class SessionManager {
      * @param source "user" for explicit renames; "auto" for generated titles.
      *   Auto titles are ignored once the user has set a name.
      */
-    setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
+    setSessionName(name: string, source?: SessionTitleSource, trigger?: string): Promise<boolean>;
     /**
      * Append a foreign (host-authored) entry verbatim, preserving its
      * `id`/`parentId`. Used by collab guests to mirror the host session.
@@ -240,9 +242,8 @@ export declare class SessionManager {
     /**
      * Create a fresh empty session file in the default session directory for
      * `cwd`, writing only the session header. The returned path can be passed to
-     * `setSessionFile` / `AgentSession.switchSession` to start a new empty
-     * session in that directory. Used by `/move` to switch projects without
-     * dragging the current conversation along.
+     * `setSessionFile` / `AgentSession.switchSession` when a caller explicitly
+     * needs a brand-new persisted session at a cwd-derived path.
      */
     static createEmptySessionFile(cwd: string, storage?: SessionStorage): string;
     /**

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

@@ -1,3 +1,4 @@
+import { type SessionTitleUpdate } from "./session-title-slot";
 export interface SessionStorageStat {
     size: number;
     mtimeMs: number;
@@ -22,6 +23,14 @@ export interface SessionStorage {
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
+    /**
+     * Update the current session title through the storage backend.
+     *
+     * File-like backends rewrite the fixed-width JSONL title slot; indexed
+     * backends can store the semantic title fields and synthesize the slot when
+     * reading.
+     */
+    updateSessionTitle(path: string, update: SessionTitleUpdate): Promise<void>;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
@@ -43,6 +52,7 @@ export declare class FileSessionStorage implements SessionStorage {
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(fpath: string, content: string): void;
+    updateSessionTitle(fpath: string, update: SessionTitleUpdate): Promise<void>;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
@@ -67,6 +77,7 @@ export declare class MemorySessionStorage implements SessionStorage {
     ensureDirSync(_dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
+    updateSessionTitle(path: string, update: SessionTitleUpdate): Promise<void>;
     /**
      * Internal O(1) append used by {@link MemorySessionStorageWriter}. Lazily
      * creates the entry. External callers should go through `openWriter()`