@oh-my-pi/pi-coding-agent 15.11.7 → 15.12.0

package/dist/types/cli/args.d.ts

@@ -26,6 +26,8 @@ export interface Args {
     sessionDir?: string;
     providerSessionId?: string;
     fork?: string;
+    /** Collab link to join at startup (set by the `join` subcommand; no CLI flag). */
+    join?: string;
     models?: string[];
     tools?: string[];
     noTools?: boolean;

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

@@ -0,0 +1,7 @@
+import type { CollabFrame } from "./protocol";
+export declare function generateRoomKey(): Uint8Array;
+export declare function generateWriteToken(): Uint8Array;
+export declare function importRoomKey(raw: Uint8Array): Promise<CryptoKey>;
+export declare function seal(key: CryptoKey, frame: CollabFrame): Promise<Uint8Array>;
+/** Inverse of {@link seal}. Throws on auth failure or malformed input. */
+export declare function open(key: CryptoKey, data: Uint8Array): Promise<CollabFrame>;

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

@@ -0,0 +1,23 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import type { AgentHubRemote } from "../modes/components/agent-hub";
+import type { InteractiveModeContext } from "../modes/types";
+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>;
+export declare class CollabGuestLink {
+    #private;
+    state: CollabSessionState | null;
+    /** Local mirror of the host's agent ecosystem (refs carry `session: null`). */
+    readonly agentRegistry: AgentRegistry;
+    /** Agent Hub actions routed to the host over the wire. */
+    get hubRemote(): AgentHubRemote;
+    /** True when this guest joined through a read-only (view) link. */
+    get readOnly(): boolean;
+    constructor(ctx: InteractiveModeContext);
+    join(link: string): Promise<void>;
+    /** User-initiated leave (or post-disconnect cleanup): restore the previous session. */
+    leave(_reason: string): Promise<void>;
+    sendPrompt(text: string, images?: ImageContent[]): void;
+    sendAbort(): void;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Host side of a collab live session.
+ *
+ * Taps the host session's event stream and SessionManager append chokepoint,
+ * broadcasting entries/events/state to guests through the relay. Guests prompt
+ * and abort through us; the host machine runs the agent and tools. The host's
+ * subagent ecosystem is mirrored too: task EventBus traffic (observer HUD),
+ * agent-registry snapshots (Agent Hub table), hub chat/kill/revive commands,
+ * and incremental subagent-transcript reads.
+ */
+import type { InteractiveModeContext } from "../modes/types";
+import { type CollabParticipant } from "./protocol";
+/** Display name for this process's user in collab sessions. */
+export declare function collabDisplayName(ctx: InteractiveModeContext): string;
+export declare class CollabHost {
+    #private;
+    constructor(ctx: InteractiveModeContext);
+    get link(): string;
+    /** Browser deep link (`https://<relay>/#<link>`) — the relay serves the web client at `/`. */
+    get webLink(): string;
+    /** Read-only variant of {@link link}: bare room key, no write token. */
+    get viewLink(): string;
+    /** Read-only variant of {@link webLink}. */
+    get webViewLink(): string;
+    get participants(): CollabParticipant[];
+    start(relayUrl: string): Promise<void>;
+    /** Broadcast a goodbye, detach all taps, and close the socket. */
+    stop(reason: string): Promise<void>;
+}

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

@@ -0,0 +1,113 @@
+/**
+ * Collab live-session wire protocol.
+ *
+ * Hub topology: the host is authoritative, guests never peer. All session
+ * payloads (`CollabFrame`) travel AES-256-GCM sealed; the relay only sees the
+ * plaintext envelope (`[4B uint32 BE peerId][sealed payload]`) plus TEXT JSON
+ * control messages that carry no session data.
+ */
+import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
+import type { BusChannel, GuestFrame, ParsedCollabLink, Participant, SessionState, AgentSnapshot as WireAgentSnapshot } from "@oh-my-pi/pi-wire";
+import { DEFAULT_RELAY_URL, ENVELOPE_HEADER_LENGTH, ROOM_ID_BYTES } from "@oh-my-pi/pi-wire";
+import type { ContextUsage } from "../extensibility/extensions/types";
+import type { AgentSessionEvent } from "../session/agent-session";
+import type { SessionEntry, SessionHeader } from "../session/session-manager";
+export type { CollabPromptDetails, ParsedCollabLink, RelayControlMessage, RelayControlToGuest, RelayControlToHost, } from "@oh-my-pi/pi-wire";
+export { COLLAB_PROMPT_MESSAGE_TYPE, COLLAB_PROTO } from "@oh-my-pi/pi-wire";
+export { DEFAULT_RELAY_URL, ENVELOPE_HEADER_LENGTH, ROOM_ID_BYTES };
+export type CollabParticipant = Participant;
+export type AgentSnapshot = WireAgentSnapshot;
+/** Debounced footer snapshot broadcast by the host. */
+export type CollabSessionState = SessionState & {
+    /**
+     * Host model (full catalog object). Guests apply it to their replica
+     * agent state so model display and context-window math are native.
+     */
+    model?: Model;
+    /** Host status-line context numbers (guest system prompt/tools differ, so local estimates drift). */
+    contextUsage?: ContextUsage;
+};
+/**
+ * Encrypted payload frames (inside AES-GCM, JSON). The wire package pins the
+ * JSON skeleton (`WireFrame`); host-side frames carry the rich session types
+ * that serialize into those shapes.
+ */
+export type CollabFrame = Exclude<GuestFrame, {
+    t: "prompt";
+}> | {
+    t: "prompt";
+    text: string;
+    images?: ImageContent[];
+} | {
+    t: "welcome";
+    proto: number;
+    header: SessionHeader;
+    entries: SessionEntry[];
+    state: CollabSessionState;
+    agents: AgentSnapshot[];
+    /** True when this peer joined through a read-only (view) link. */
+    readOnly?: boolean;
+} | {
+    t: "entry";
+    entry: SessionEntry;
+} | {
+    t: "event";
+    event: AgentSessionEvent;
+} | {
+    t: "state";
+    state: CollabSessionState;
+}
+/** Mirrored EventBus traffic (task subagent lifecycle/progress channels only). */
+ | {
+    t: "bus";
+    channel: BusChannel;
+    data: unknown;
+}
+/** Full agent-registry snapshot (debounced on registry change). */
+ | {
+    t: "agents";
+    agents: AgentSnapshot[];
+}
+/** Targeted reply to fetch-transcript; `text` is decoded JSONL from `fromByte`, `newSize` the next offset base. */
+ | {
+    t: "transcript";
+    reqId: number;
+    text: string;
+    newSize: number;
+    error?: string;
+} | {
+    t: "bye";
+    reason: string;
+} | {
+    t: "error";
+    message: string;
+};
+export declare function packEnvelope(peerId: number, sealed: Uint8Array): Uint8Array;
+export declare function unpackEnvelope(data: Uint8Array): {
+    peerId: number;
+    payload: Uint8Array;
+} | null;
+/** Rewrite the peerId in place without copying the payload. */
+export declare function rewriteEnvelopePeer(data: Uint8Array, peerId: number): void;
+export declare function generateRoomId(): string;
+/**
+ * Render the shareable link. Compact forms: the default relay collapses to
+ * `<roomId>#<key>`, other wss relays drop the scheme (`host[:port]/r/…`);
+ * only localhost ws:// links keep their full URL so parsing cannot
+ * mis-infer wss.
+ *
+ * Full links append the write token to the key in the fragment
+ * (`base64url(key ∥ writeToken)`); read-only (view) links carry the bare
+ * 32-byte key, which is also the pre-token link format.
+ */
+export declare function formatCollabLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array): string;
+/**
+ * Render the browser deep link: `http(s)://<relay-host>/#<collab-link>`. The
+ * relay serves the web client at `/`, and the whole collab link (including the
+ * room key) rides in the fragment, so it never appears in any HTTP request.
+ * Terminals auto-link the https form, making it click-to-join.
+ */
+export declare function formatCollabWebLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array): string;
+export declare function parseCollabLink(link: string): ParsedCollabLink | {
+    error: string;
+};

package/dist/types/collab/relay-client.d.ts

@@ -0,0 +1,22 @@
+import type { CollabFrame, RelayControlMessage } from "./protocol";
+export interface CollabSocketOptions {
+    /** wss://host[:port]/r/<roomId> — no query string. */
+    wsUrl: string;
+    role: "host" | "guest";
+    key: CryptoKey;
+}
+export declare class CollabSocket {
+    #private;
+    /** Fires after every successful (re)connect. */
+    onOpen?: () => void;
+    onFrame?: (frame: CollabFrame, fromPeer: number) => void;
+    onControl?: (msg: RelayControlMessage) => void;
+    /** Fires once per terminal close (intentional, fatal code, or bad key). willReconnect=true for transient drops that will retry. */
+    onClose?: (reason: string, willReconnect: boolean) => void;
+    constructor(opts: CollabSocketOptions);
+    get isOpen(): boolean;
+    connect(): void;
+    send(frame: CollabFrame, targetPeer?: number): void;
+    /** Intentional close: clears any retry timer, suppresses reconnect. A later connect() starts fresh. */
+    close(): void;
+}

package/dist/types/commands/join.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "@oh-my-pi/pi-utils/cli";
+export default class Join extends Command {
+    static description: string;
+    static args: {
+        link: import("@oh-my-pi/pi-utils/cli").ArgDescriptor & {
+            description: string;
+            required: true;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -33,7 +33,7 @@ export declare const TAB_METADATA: Record<SettingTab, {
  */
 export declare const TAB_GROUPS: Record<SettingTab, readonly string[]>;
 /** Status line segment identifiers */
-export type StatusLineSegmentId = "pi" | "model" | "mode" | "path" | "git" | "pr" | "subagents" | "token_in" | "token_out" | "token_total" | "token_rate" | "cost" | "context_pct" | "context_total" | "time_spent" | "time" | "session" | "hostname" | "cache_read" | "cache_write" | "cache_hit" | "session_name" | "usage";
+export type StatusLineSegmentId = "pi" | "model" | "mode" | "path" | "git" | "pr" | "subagents" | "token_in" | "token_out" | "token_total" | "token_rate" | "cost" | "context_pct" | "context_total" | "time_spent" | "time" | "session" | "hostname" | "cache_read" | "cache_write" | "cache_hit" | "session_name" | "usage" | "collab";
 /** Submenu choice metadata. */
 export type SubmenuOption<V extends string = string> = {
     value: V;
@@ -1394,6 +1394,46 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Notify when the ask tool is waiting for input";
         };
     };
+    readonly "collab.relayUrl": {
+        readonly type: "string";
+        readonly default: "wss://my.omp.sh";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Relay URL";
+            readonly description: "Relay used by /collab (wss://host[:port]; self-host with the omp-collab-relay service)";
+        };
+    };
+    readonly "collab.displayName": {
+        readonly type: "string";
+        readonly default: "";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Display Name";
+            readonly description: "Name shown to other collab participants (default: OS username)";
+        };
+    };
+    readonly "share.serverUrl": {
+        readonly type: "string";
+        readonly default: "https://my.omp.sh/s";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Share Server";
+            readonly description: "Share viewer/upload base used by /share (encrypted blob upload + viewer; links are <base>/<id>#<key>)";
+        };
+    };
+    readonly "share.redactSecrets": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Share Secret Redaction";
+            readonly description: "Run the secret obfuscator over /share snapshots before upload (uses the secrets.* config)";
+        };
+    };
     readonly "stt.enabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -4189,13 +4229,27 @@ export declare const SETTINGS_SCHEMA: {
         };
     };
     readonly "codexResets.autoRedeem": {
-        readonly type: "boolean";
-        readonly default: false;
+        readonly type: "enum";
+        readonly values: readonly ["unset", "yes", "no"];
+        readonly default: "unset";
         readonly ui: {
             readonly tab: "providers";
             readonly group: "Services";
             readonly label: "Codex Auto-Redeem Saved Resets";
-            readonly description: "When a turn is blocked by the Codex weekly limit on the active account and no other account is available, automatically spend one saved rate-limit reset (ChatGPT 'save rate limit resets'). Conservative: never fires for 5-hour-only or Spark limits, near a natural reset, or twice for the same block. Requires retries enabled.";
+            readonly description: "When a turn is blocked by the Codex weekly limit on the active account and no other account is available, run the conservative saved-reset check. unset asks before spending the first eligible reset, yes spends eligible resets without prompting, and no disables the check entirely. Requires retries enabled.";
+            readonly options: readonly [{
+                readonly value: "unset";
+                readonly label: "Unset";
+                readonly description: "Check eligibility, then ask before spending the first saved reset.";
+            }, {
+                readonly value: "yes";
+                readonly label: "Yes";
+                readonly description: "Spend eligible saved resets without prompting.";
+            }, {
+                readonly value: "no";
+                readonly label: "No";
+                readonly description: "Do not run the saved-reset auto-redeem check.";
+            }];
         };
     };
     readonly "codexResets.minBlockedMinutes": {
@@ -4567,8 +4621,9 @@ export interface ShellMinimizerSettings {
     sourceOutlineLevel: "default" | "aggressive";
     legacyFilters: boolean | undefined;
 }
+export type CodexAutoRedeemMode = "unset" | "yes" | "no";
 export interface CodexResetsSettings {
-    autoRedeem: boolean;
+    autoRedeem: CodexAutoRedeemMode;
     minBlockedMinutes: number;
     keepCredits: number;
 }

package/dist/types/export/custom-share.d.ts

@@ -5,7 +5,7 @@ export interface CustomShareResult {
     message?: string;
 }
 export type CustomShareFn = (htmlPath: string) => Promise<CustomShareResult | string | undefined>;
-interface LoadedCustomShare {
+export interface LoadedCustomShare {
     path: string;
     fn: CustomShareFn;
 }
@@ -17,4 +17,3 @@ export declare function getCustomSharePath(): string | null;
  * Load the custom share script if it exists.
  */
 export declare function loadCustomShare(): Promise<LoadedCustomShare | null>;
-export {};

package/dist/types/export/html/index.d.ts

@@ -1,9 +1,47 @@
 import type { AgentState } from "@oh-my-pi/pi-agent-core";
-import { SessionManager } from "../../session/session-manager";
+import { type SessionEntry, type SessionHeader, SessionManager } from "../../session/session-manager";
+/** Compose the standalone export template: minified CSS, tool renderers, and viewer JS inlined. */
+export declare function getTemplate(): string;
 export interface ExportOptions {
     outputPath?: string;
     themeName?: string;
+    /** Embed subagent session transcripts found next to the session file (default true). */
+    includeSubSessions?: boolean;
 }
+/** Generate CSS custom properties for theme. Exported for the share-viewer build script. */
+export declare function generateThemeVars(themeName?: string): Promise<string>;
+/** Embedded subagent session transcript, keyed by slash-joined agent path in `SessionData.subSessions`. */
+export interface SubSession {
+    /** Bare agent id (session file stem), e.g. "ToolAsk". */
+    agentId: string;
+    /** Key of the parent sub-session, or null when spawned by the main session. */
+    parent: string | null;
+    header: SessionHeader | null;
+    entries: SessionEntry[];
+    leafId: string | null;
+}
+export interface SessionData {
+    header: SessionHeader | null;
+    entries: SessionEntry[];
+    leafId: string | null;
+    systemPrompt?: string;
+    tools?: {
+        name: string;
+        description: string;
+    }[];
+    subSessions?: Record<string, SubSession>;
+}
+/** Snapshot the session (plus optional agent state) into the JSON shape the viewer renders. */
+export declare function buildSessionData(sm: SessionManager, state?: AgentState): SessionData;
+/**
+ * Collect subagent session transcripts stored next to a session file.
+ *
+ * A session at `<dir>/<name>.jsonl` keeps its subagent sessions at `<dir>/<name>/<AgentId>.jsonl`;
+ * each subagent's own children nest the same way under `<dir>/<name>/<AgentId>/`. Keys in the
+ * returned record are slash-joined ids relative to the main session ("ToolAsk", "ToolAsk/Helper").
+ * Corrupt or empty files are skipped silently.
+ */
+export declare function collectSubSessions(sessionFile: string): Promise<Record<string, SubSession>>;
 /** Export session to HTML using SessionManager and AgentState. */
 export declare function exportSessionToHtml(sm: SessionManager, state?: AgentState, options?: ExportOptions | string): Promise<string>;
 /** Export session file to HTML (standalone). */

package/dist/types/export/share.d.ts

@@ -0,0 +1,43 @@
+import type { AgentState } from "@oh-my-pi/pi-agent-core";
+import { DEFAULT_SHARE_URL } from "@oh-my-pi/pi-wire";
+import type { SecretObfuscator } from "../secrets/obfuscator";
+import type { SessionManager } from "../session/session-manager";
+import { type SessionData } from "./html";
+export { DEFAULT_SHARE_URL };
+/** Hard cap for blobs accepted by the share server (mirrors relay shareMaxBytes). */
+export declare const SERVER_MAX_SEALED_BYTES = 1000000;
+export interface ShareSessionOptions {
+    /** Share server/viewer base URL; defaults to {@link DEFAULT_SHARE_URL}. */
+    serverUrl?: string;
+    /** Agent state for system prompt + tool descriptions in the snapshot. */
+    state?: AgentState;
+    /**
+     * Redacts the snapshot before sealing: deep-walks every string (entries,
+     * header, system prompt, tool descriptions) through the obfuscator, so
+     * secrets that landed in persisted entries (tool outputs reading .env,
+     * etc.) never leave the machine. Pass undefined to skip.
+     */
+    obfuscator?: SecretObfuscator;
+}
+export interface ShareSessionResult {
+    /** Viewer link: `<serverUrl>/<id>#<key>`. */
+    url: string;
+    method: "gist" | "server";
+    /** Underlying gist URL (gist method only). */
+    gistUrl?: string;
+    /** True when content was trimmed to fit the upload budget. */
+    truncated: boolean;
+    sealedBytes: number;
+}
+/** Build the snapshot that gets sealed and uploaded, redacted when an obfuscator is provided. */
+export declare function buildShareSnapshot(sm: SessionManager, options?: ShareSessionOptions): SessionData;
+/** Share the session; tries a secret gist first, then the share server. */
+export declare function shareSession(sm: SessionManager, options?: ShareSessionOptions): Promise<ShareSessionResult>;
+/** Strip trailing slashes so `<base>/<id>` composes cleanly. */
+export declare function normalizeShareServerUrl(serverUrl?: string): string;
+interface SealedSession {
+    sealed: Uint8Array<ArrayBuffer>;
+    truncated: boolean;
+}
+/** Seal `data`, trimming content until the sealed blob fits `maxBytes`. Exported for tests. */
+export declare function sealToFit(key: CryptoKey, data: SessionData, maxBytes: number): Promise<SealedSession>;

package/dist/types/extensibility/slash-commands.d.ts

@@ -1,5 +1,3 @@
-import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
-import { type BuiltinSlashCommand } from "../slash-commands/builtin-registry";
 export type SlashCommandSource = "extension" | "prompt" | "skill";
 export type SlashCommandLocation = "user" | "project" | "path";
 export interface SlashCommandInfo {
@@ -9,15 +7,7 @@ export interface SlashCommandInfo {
     location?: SlashCommandLocation;
     path?: string;
 }
-export type { BuiltinSlashCommand, SubcommandDef } from "../slash-commands/builtin-registry";
-/**
- * Materialized builtin slash commands with completion functions derived from
- * declarative subcommand/hint definitions.
- */
-export declare const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand & {
-    getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null;
-    getInlineHint?: (argumentText: string) => string | null;
-}>;
+export type { BuiltinSlashCommand, SubcommandDef } from "../slash-commands/types";
 /**
  * Represents a custom slash command loaded from a file
  */

package/dist/types/main.d.ts

@@ -1,5 +1,6 @@
 import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
+import { type ScopedModel } from "./config/model-resolver";
 import { Settings } from "./config/settings";
 import { InteractiveMode } from "./modes/interactive-mode";
 import type { SubmittedUserInput } from "./modes/types";
@@ -12,6 +13,7 @@ export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
 }
+export declare function buildModelScopeNotification(scopedModelsForDisplay: readonly Pick<ScopedModel, "model" | "thinkingLevel" | "explicitThinkingLevel">[], startupQuiet: boolean): InteractiveModeNotify | null;
 export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
 type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 export interface AcpSessionFactoryOptions {

package/dist/types/modes/components/agent-hub.d.ts

@@ -1,9 +1,22 @@
-import { Container } from "@oh-my-pi/pi-tui";
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Container, type TUI } from "@oh-my-pi/pi-tui";
 import type { KeyId } from "../../config/keybindings";
+import type { MessageRenderer } from "../../extensibility/extensions/types";
 import { IrcBus } from "../../irc/bus";
 import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
 import { AgentRegistry } from "../../registry/agent-registry";
 import type { SessionObserverRegistry } from "../session-observer-registry";
+/** Guest-side proxy for hub actions executed on the collab host. */
+export interface AgentHubRemote {
+    chat(id: string, text: string): void;
+    kill(id: string): void;
+    revive(id: string): void;
+    /** Mirrors readFileIncremental: text from fromByte (complete JSONL lines), newSize = next fromByte base; null = unavailable. */
+    readTranscript(id: string, fromByte: number): Promise<{
+        text: string;
+        newSize: number;
+    } | null>;
+}
 export interface AgentHubDeps {
     /** Progress/status snapshot source (task lifecycle + progress channels). */
     observers: SessionObserverRegistry;
@@ -17,6 +30,24 @@ export interface AgentHubDeps {
     lifecycle?: AgentLifecycleManager;
     /** Injectable for tests; defaults to the process-global bus. */
     irc?: IrcBus;
+    /** TUI handle for transcript components; tests omit it and get a render-only stub. */
+    ui?: TUI;
+    /** Tool lookup for transcript renderers (labels, custom render functions). */
+    getTool?: (name: string) => AgentTool | undefined;
+    /** Extension message renderers for custom messages in the transcript. */
+    getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
+    /** Cwd used by tool renderers for path shortening; defaults to the project dir. */
+    cwd?: string;
+    /** Mirrors the main transcript's thinking-block visibility. */
+    hideThinkingBlock?: () => boolean;
+    /** Keys toggling tool output expansion (app.tools.expand). */
+    expandKeys?: KeyId[];
+    /** Focus the main view on this agent's live session (ctx.focusAgentSession). When absent (collab guest, tests), Enter opens the in-hub chat view instead. */
+    focusAgent?: (id: string) => Promise<void>;
+    /** Current main session file; used to seed parked historical subagents after restart. */
+    sessionFile?: string | null;
+    /** Collab guest: route actions/transcripts to the host instead of local sessions. */
+    remote?: AgentHubRemote;
 }
 export declare class AgentHubOverlayComponent extends Container {
     #private;

package/dist/types/modes/components/collab-prompt-message.d.ts

@@ -0,0 +1,10 @@
+import { Container } from "@oh-my-pi/pi-tui";
+import type { CollabPromptDetails } from "../../collab/protocol";
+import type { CustomMessage } from "../../session/messages";
+/**
+ * Renders a collab guest prompt on every participant's transcript: a
+ * user-message-styled bubble prefixed with the author's name.
+ */
+export declare class CollabPromptMessageComponent extends Container {
+    constructor(message: CustomMessage<CollabPromptDetails>);
+}

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

@@ -3,14 +3,12 @@
  * 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. */
+/** One segment of a {@link HookSelectorSlider} — a label and an optional
+ *  detail line (e.g. the resolved model name) shown beneath the track while
+ *  the segment is active. Segment colors come from the track's theme palette,
+ *  assigned by position. */
 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;
 }

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

@@ -1,9 +1,9 @@
 /**
  * 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.
+ * status line: each segment is colored by its track position from the theme's
+ * own palette, the active one is filled as a powerline chip (its color 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.
@@ -11,9 +11,14 @@
 import { type ThemeColor } from "../theme/theme";
 export interface TrackSegment {
     label: string;
-    /** Theme color for the segment; defaults to `accent`. */
-    color?: ThemeColor;
 }
+/**
+ * Resolve up to `count` theme colors that render distinctly under the active
+ * theme, in candidate preference order. May return fewer than `count` when the
+ * theme has fewer distinct hues (e.g. monochrome themes) — callers wrap with
+ * modulo. Never returns an empty array: `accent` always resolves.
+ */
+export declare function resolveSegmentPalette(count: number): 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

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

@@ -1,14 +1,21 @@
 import { type Component } from "@oh-my-pi/pi-tui";
 import type { AgentSession } from "../../../session/agent-session";
-import type { EffectiveStatusLineSettings, StatusLineSettings } from "./types";
+import type { CollabStatus, EffectiveStatusLineSettings, StatusLineSettings } from "./types";
 export declare class StatusLineComponent implements Component {
     #private;
-    private readonly session;
+    private session;
     constructor(session: AgentSession);
+    /**
+     * Re-point the status line at another session (focus proxy). Invalidate: model/context/usage all derive
+     * from it. `focusedAgentId` is the focused subagent id while the view is proxied, undefined for main.
+     */
+    setSession(session: AgentSession, focusedAgentId?: string): void;
     updateSettings(settings: StatusLineSettings): void;
     getEffectiveSettingsForTest(): EffectiveStatusLineSettings;
     setAutoCompactEnabled(enabled: boolean): void;
     setSubagentCount(count: number): void;
+    /** Active subagent count as currently displayed (collab state mirroring). */
+    get subagentCount(): number;
     setSessionStartTime(time: number): void;
     setPlanModeStatus(status: {
         enabled: boolean;
@@ -21,6 +28,7 @@ export declare class StatusLineComponent implements Component {
         enabled: boolean;
         paused: boolean;
     } | undefined): void;
+    setCollabStatus(status: CollabStatus | null): void;
     setHookStatus(key: string, text: string | undefined): void;
     watchBranch(onBranchChange: () => void): void;
     dispose(): void;

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

@@ -1,6 +1,14 @@
+import type { CollabSessionState } from "../../../collab/protocol";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../../config/settings-schema";
 import type { AgentSession } from "../../../session/agent-session";
 export type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle };
+/** Collab session indicator + (guest-only) host-state override for segments. */
+export interface CollabStatus {
+    role: "host" | "guest";
+    participantCount: number;
+    /** Guest only: host footer snapshot that overrides locally computed values. */
+    stateOverride?: CollabSessionState | null;
+}
 export interface StatusLineSegmentOptions {
     model?: {
         showThinkingLevel?: boolean;
@@ -37,6 +45,8 @@ export type EffectiveStatusLineSettings = Required<Pick<StatusLineSettings, "lef
 export type RGB = readonly [number, number, number];
 export interface SegmentContext {
     session: AgentSession;
+    /** Focused subagent id while the view is proxied at its session, undefined otherwise. */
+    focusedAgentId?: string | undefined;
     width: number;
     options: StatusLineSegmentOptions;
     planMode: {
@@ -50,6 +60,7 @@ export interface SegmentContext {
         enabled: boolean;
         paused: boolean;
     } | null;
+    collab: CollabStatus | null;
     usageStats: {
         input: number;
         output: number;