@oh-my-pi/pi-coding-agent 16.0.9 → 16.0.11

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

@@ -1,3 +1,4 @@
 export * from "./advise-tool";
 export * from "./runtime";
+export * from "./transcript-recorder";
 export * from "./watchdog";

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

@@ -0,0 +1,52 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+/**
+ * Reserved transcript stem for advisor session files. Chosen so it cannot
+ * collide with a task subagent's `<id>.jsonl` (task ids are reserved against
+ * this exact stem in {@link AgentOutputManager}).
+ */
+export declare const ADVISOR_TRANSCRIPT_STEM = "__advisor";
+export declare const ADVISOR_TRANSCRIPT_FILENAME = "__advisor.jsonl";
+/**
+ * Append-only persister for an advisor agent's transcript.
+ *
+ * The advisor is a passive reviewer with its own model usage, so — like a task
+ * subagent — its turns are written to a JSONL inside the owning session's
+ * artifacts dir (`<session>/__advisor.jsonl`, `<session>/<SubId>/__advisor.jsonl`
+ * for subagent advisors). That single file gives the advisor model proper usage
+ * attribution in `omp stats` (the stats parser scans the session dir
+ * recursively) and a read-only transcript in the Agent Hub, without making the
+ * advisor a registered, messageable peer.
+ *
+ * The target is derived from the *session file* (`getSessionFile()`), never
+ * `getArtifactsDir()` — subagents adopt the parent's artifact manager, so the
+ * artifacts dir points at the parent root and every subagent advisor would
+ * collide. The file path is resolved synchronously when a message finalizes and
+ * captured for the queued write, so a `/new`, resume, or session switch in
+ * flight can never misattribute an old advisor turn into the new session's file.
+ * On such a switch the previous writer is closed and the new file opened on the
+ * next recorded turn. The recorder never truncates: the advisor's in-memory
+ * context resets/compacts independently, but every billed turn is appended here.
+ */
+export declare class AdvisorTranscriptRecorder {
+    #private;
+    private readonly resolveSessionFile;
+    private readonly resolveCwd;
+    /**
+     * @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.
+     */
+    constructor(resolveSessionFile: () => string | undefined, resolveCwd: () => 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
+     * (the advisor's "session update" prompts) are persisted but flagged
+     * `synthetic`/agent-attributed so they never inflate user-message metrics.
+     * Non-conversational message kinds are skipped.
+     */
+    record(message: AgentMessage): void;
+    /** Flush pending writes (best-effort). */
+    flush(): Promise<void>;
+    /** Flush and close the writer, releasing the session file. */
+    close(): Promise<void>;
+}

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

@@ -16,14 +16,14 @@ export declare class CollabHost {
     #private;
     constructor(ctx: InteractiveModeContext);
     get link(): string;
-    /** Browser deep link (`https://<relay>/#<link>`) — the relay serves the web client at `/`. */
+    /** Browser deep link for the configured collab web UI. */
     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>;
+    start(relayUrl: string, webUrl?: 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

@@ -108,12 +108,11 @@ export declare function generateRoomId(): string;
  */
 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.
+ * Render the browser deep link. The browser UI may be hosted separately from
+ * the relay; the fragment always carries the relay-specific collab link, so
+ * room secrets stay out of HTTP path and query bytes.
  */
-export declare function formatCollabWebLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array): string;
+export declare function formatCollabWebLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array, webUrl?: string): string;
 export declare function parseCollabLink(link: string): ParsedCollabLink | {
     error: string;
 };

package/dist/types/commit/agentic/agent.d.ts

@@ -1,4 +1,4 @@
-import { type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { Settings } from "../../config/settings";

package/dist/types/config/model-resolver.d.ts

@@ -32,11 +32,17 @@ export interface ScopedModel {
     thinkingLevel?: ThinkingLevel;
     explicitThinkingLevel: boolean;
 }
+interface ThinkingSuffixOptions {
+    allowMaxAlias?: boolean;
+}
+interface ModelStringParseOptions extends ThinkingSuffixOptions {
+    isLiteralModelId?: (provider: string, id: string) => boolean;
+}
 /**
  * Parse a model string in "provider/modelId" format.
  * Returns undefined if the format is invalid.
  */
-export declare function parseModelString(modelStr: string): {
+export declare function parseModelString(modelStr: string, options?: ModelStringParseOptions): {
     provider: string;
     id: string;
     thinkingLevel?: ThinkingLevel;
@@ -115,7 +121,10 @@ export declare function resolveModelRoleValue(roleValue: string | undefined, ava
     matchPreferences?: ModelMatchPreferences;
     modelRegistry?: CanonicalModelRegistry;
 }): ResolvedModelRoleValue;
-export declare function extractExplicitThinkingSelector(value: string | undefined, settings?: Settings): ThinkingLevel | undefined;
+interface ExplicitThinkingSelectorOptions {
+    isLiteralModelId?: (provider: string, id: string) => boolean;
+}
+export declare function extractExplicitThinkingSelector(value: string | undefined, settings?: Settings, options?: ExplicitThinkingSelectorOptions): ThinkingLevel | undefined;
 /**
  * Resolve a model identifier or pattern to a Model instance.
  */

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

@@ -775,10 +775,6 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Remove the 1-character horizontal padding from the left and right of the terminal output";
         };
     };
-    readonly "display.tabWidth": {
-        readonly type: "number";
-        readonly default: 3;
-    };
     readonly "display.shimmer": {
         readonly type: "enum";
         readonly values: readonly ["classic", "kitt", "disabled"];
@@ -835,7 +831,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly defaultThinkingLevel: {
         readonly type: "enum";
-        readonly values: readonly [...import("@oh-my-pi/pi-catalog").Effort[], "auto"];
+        readonly values: readonly [...import("@oh-my-pi/pi-catalog").Effort[], "auto", "max"];
         readonly default: "high";
         readonly ui: {
             readonly tab: "model";
@@ -1579,6 +1575,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Relay used by /collab (wss://host[:port])";
         };
     };
+    readonly "collab.webUrl": {
+        readonly type: "string";
+        readonly default: "";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Web UI URL";
+            readonly description: "Browser UI used by /collab links; empty derives from collab.relayUrl; explicit http:// is localhost-only";
+        };
+    };
     readonly "collab.displayName": {
         readonly type: "string";
         readonly default: "";
@@ -2012,7 +2018,7 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "pi";
                 readonly label: "Pi";
-                readonly description: "Use the Pi owned dialect.";
+                readonly description: "Use the Pi owned dialect (compact sigil-delimited tool calls).";
             }, {
                 readonly value: "qwen3";
                 readonly label: "Qwen3";

package/dist/types/edit/file-snapshot-store.d.ts

@@ -48,7 +48,7 @@ export declare function recordFileSnapshot(session: FileSnapshotStoreOwner, abso
 /**
  * The 1-indexed file lines a hashline-formatted body actually displayed.
  * Single `NN:` rows contribute that line; a collapsed summary `NN-MM:` row
- * (a `{ .. }` brace pair) contributes only its boundary lines `NN` and `MM` —
+ * (a `{ … }` brace pair) contributes only its boundary lines `NN` and `MM` —
  * the elided interior was never shown, so editing inside it must be rejected.
  */
 export declare function parseSeenLinesFromHashlineBody(body: string): number[];

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

@@ -25,6 +25,7 @@ import type * as PiCodingAgent from "../../index";
 import type { MemoryRuntimeContext } from "../../memory-backend";
 import type { CustomEditor } from "../../modes/components/custom-editor";
 import type { Theme } from "../../modes/theme/theme";
+import type { CompactMode } from "../../session/compact-modes";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
 import type { BashToolDetails, BashToolInput, FindToolDetails, FindToolInput, ReadToolDetails, ReadToolInput, SearchToolDetails, SearchToolInput, WriteToolInput } from "../../tools";
@@ -171,6 +172,12 @@ export interface ContextUsage {
 export interface CompactOptions {
     onComplete?: (result: CompactionResult) => void;
     onError?: (error: Error) => void;
+    /**
+     * Force a one-off compaction mode for this invocation, overriding the
+     * configured `compaction.strategy` / `remoteEnabled` (the `/compact`
+     * subcommands: `soft` | `remote` | `snapcompact`). Omitted = configured behavior.
+     */
+    mode?: CompactMode;
 }
 /**
  * Context passed to extension event handlers.

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

@@ -62,6 +62,11 @@ export declare class AgentHubOverlayComponent extends Container {
     dispose(): void;
     render(width: number): readonly string[];
     handleInput(keyData: string): void;
-    /** Open the chat view for an agent id (public for table Enter and tests). */
+    /**
+     * Open the fullscreen transcript viewer for an agent id (public for table Enter
+     * and tests). Mounts {@link AgentTranscriptViewer} as a `fullscreen` overlay so it
+     * owns the alternate screen; the hub table stays mounted underneath and is
+     * restored when the viewer closes. No-op without a real TUI (render-only test stub).
+     */
     openChat(id: string): void;
 }

package/dist/types/modes/components/agent-transcript-viewer.d.ts

@@ -0,0 +1,39 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { type Component, type TUI } from "@oh-my-pi/pi-tui";
+import type { KeyId } from "../../config/keybindings";
+import type { MessageRenderer } from "../../extensibility/extensions/types";
+import type { AgentLifecycleManager } from "../../registry/agent-lifecycle";
+import type { AgentRegistry } from "../../registry/agent-registry";
+import type { SessionObserverRegistry } from "../session-observer-registry";
+import type { AgentHubRemote } from "./agent-hub";
+export interface AgentTranscriptViewerDeps {
+    agentId: string;
+    registry: AgentRegistry;
+    /** Collab guest: read transcript from the host instead of a local file. */
+    remote?: AgentHubRemote;
+    /** Progress/cost snapshot source for the stats line. */
+    observers?: SessionObserverRegistry;
+    /** Revive+prompt path for messageable local agents. Lazy to avoid touching the global. */
+    lifecycle?: () => AgentLifecycleManager;
+    ui: TUI;
+    getTool?: (name: string) => AgentTool | undefined;
+    getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
+    cwd: string;
+    hideThinkingBlock?: () => boolean;
+    expandKeys: KeyId[];
+    /** Keys that toggle the whole hub closed (app.agents.hub + app.session.observe). */
+    hubKeys: KeyId[];
+    requestRender: () => void;
+    /** Close just this viewer (Esc), returning to the hub table. */
+    onClose: () => void;
+    /** Close this viewer AND the hub (hub-toggle keys). */
+    onHubClose: () => void;
+}
+export declare class AgentTranscriptViewer implements Component {
+    #private;
+    private readonly deps;
+    constructor(deps: AgentTranscriptViewerDeps);
+    dispose(): void;
+    handleInput(data: string): void;
+    render(width: number): readonly string[];
+}

package/dist/types/modes/components/chat-transcript-builder.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Builds transcript components from persisted session message entries — the
+ * file/remote-backed counterpart to {@link UiHelpers.addMessageToChat} (which is
+ * bound to the live InteractiveModeContext). Used by the fullscreen transcript
+ * viewer ({@link AgentTranscriptViewer}) to render a parked subagent / advisor /
+ * collab-guest transcript that has no live session.
+ *
+ * Unlike the old incremental hub sync, {@link ChatTranscriptBuilder.rebuild}
+ * always discards prior components and rebuilds the whole transcript from the
+ * supplied entries. Re-rendering a growing transcript is therefore O(n) in the
+ * entry count, but it cannot duplicate or misorder rows the way incremental
+ * component reuse could.
+ */
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { type TUI } from "@oh-my-pi/pi-tui";
+import type { MessageRenderer } from "../../extensibility/extensions/types";
+import type { SessionMessageEntry } from "../../session/session-entries";
+import { TranscriptContainer } from "./transcript-container";
+export interface ChatTranscriptBuilderDeps {
+    ui: TUI;
+    getTool?: (name: string) => AgentTool | undefined;
+    getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
+    cwd: string;
+    hideThinkingBlock?: () => boolean;
+    requestRender: () => void;
+}
+export declare class ChatTranscriptBuilder {
+    #private;
+    private readonly deps;
+    readonly container: TranscriptContainer;
+    constructor(deps: ChatTranscriptBuilderDeps);
+    /** Whether the transcript currently holds any rendered rows. */
+    get isEmpty(): boolean;
+    /** Discard all components and rebuild the whole transcript from `entries`. */
+    rebuild(entries: SessionMessageEntry[]): void;
+    /** Toggle tool-output expansion across every expandable component. */
+    setExpanded(expanded: boolean): void;
+    get expanded(): boolean;
+    /** Tear down components (sealing pending spinners) and clear build state. */
+    reset(): void;
+    dispose(): void;
+}

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

@@ -3,6 +3,7 @@ import { type ProviderDetails, type UsageReport } from "@oh-my-pi/pi-ai";
 import type { CompactOptions } from "../../extensibility/extensions/types";
 import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
+import type { CompactMode } from "../../session/compact-modes";
 import { type ShakeMode } from "../../session/shake-types";
 export declare class CommandController {
     #private;
@@ -31,14 +32,14 @@ export declare class CommandController {
     handleRenameCommand(title: string): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
-    handleCompactCommand(customInstructions?: string, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
+    handleCompactCommand(customInstructions?: string, mode?: CompactMode, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
     /**
      * TUI handler for `/shake`. `elide` drops heavy structural content and
      * `images` strips image blocks. Rebuilds the chat and reports counts.
      */
     handleShakeCommand(mode: ShakeMode): Promise<void>;
     handleSkillCommand(skillPath: string, args: string): Promise<void>;
-    executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
+    executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>, mode?: CompactMode): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
 }
 export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;

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

@@ -12,6 +12,7 @@ import type { CompactOptions } from "../extensibility/extensions/types";
 import type { MCPManager } from "../mcp";
 import { type PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession } from "../session/agent-session";
+import type { CompactMode } from "../session/compact-modes";
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext } from "../session/session-context";
 import type { SessionManager } from "../session/session-manager";
@@ -298,7 +299,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
     handleMCPCommand(text: string): Promise<void>;
     handleSSHCommand(text: string): Promise<void>;
-    handleCompactCommand(customInstructions?: string, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
+    handleCompactCommand(customInstructions?: string, mode?: CompactMode, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
     handleShakeCommand(mode: ShakeMode): Promise<void>;
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;

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

@@ -11,6 +11,7 @@ import type { CompactOptions } from "../extensibility/extensions/types";
 import type { MCPManager } from "../mcp";
 import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession } from "../session/agent-session";
+import type { CompactMode } from "../session/compact-modes";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext } from "../session/session-context";
 import type { SessionManager } from "../session/session-manager";
@@ -273,7 +274,7 @@ export interface InteractiveModeContext {
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
     handleMCPCommand(text: string): Promise<void>;
     handleSSHCommand(text: string): Promise<void>;
-    handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
+    handleCompactCommand(customInstructions?: string, mode?: CompactMode): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
     handleShakeCommand(mode: ShakeMode): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;

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

@@ -18,7 +18,13 @@ export declare const MAIN_AGENT_ID = "Main";
  * - `aborted`: hard-killed, terminal.
  */
 export type AgentStatus = "running" | "idle" | "parked" | "aborted";
-export type AgentKind = "main" | "sub";
+/**
+ * - `main`/`sub`: the user-facing agent tree (driving agent + task subagents).
+ * - `advisor`: a passive review transcript persisted like a subagent for usage
+ *   attribution and Agent Hub observability, but never a peer — hidden from
+ *   agent-facing rosters (`irc`, `history://`) and not messageable/revivable.
+ */
+export type AgentKind = "main" | "sub" | "advisor";
 export interface AgentRef {
     id: string;
     displayName: string;
@@ -81,8 +87,9 @@ export declare class AgentRegistry {
     get(id: string): AgentRef | undefined;
     list(): AgentRef[];
     /**
-     * Returns every alive agent (running | idle) except the caller.
-     * Flat namespace: every agent can see every other agent.
+     * Returns every alive agent (running | idle) except the caller. Advisor refs
+     * are observability-only transcripts, never peers, so they are excluded.
+     * Flat namespace: every other agent is visible.
      */
     listVisibleTo(id: string): AgentRef[];
     onChange(listener: RegistryListener): () => void;

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

@@ -237,6 +237,13 @@ export interface AgentSessionConfig {
     advisorReadOnlyTools?: AgentTool[];
     /** Preloaded watchdog prompt content for the advisor. */
     advisorWatchdogPrompt?: string;
+    /**
+     * Disconnect this session's OWNED MCP manager on dispose. Provided only when
+     * the session created the manager (top-level sessions); subagents reuse a
+     * parent's manager via `options.mcpManager` and omit this so a child's
+     * teardown never tears down the shared servers.
+     */
+    disconnectOwnedMcpManager?: () => Promise<void>;
 }
 /** Options for AgentSession.prompt() */
 export interface PromptOptions {
@@ -552,6 +559,12 @@ export declare class AgentSession {
     get hasPostPromptWork(): boolean;
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
+    /** Latest image attachments addressable by tools as `Image #N` or `attachment://N`. */
+    getImageAttachments(): {
+        label: string;
+        uri: string;
+        image: ImageContent;
+    }[];
     buildDisplaySessionContext(): SessionContext;
     /**
      * Full-history transcript for TUI display: every path entry in

package/dist/types/session/compact-modes.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Manual `/compact` subcommands. Kept in a dependency-free leaf module so the
+ * slash-command registry, the interactive controllers, and `AgentSession`
+ * can all import the mode metadata + parser without pulling in the heavy
+ * `agent-session` module graph (which would form an import cycle through the
+ * slash-command registry) — same rationale as `shake-types.ts`.
+ *
+ * Each mode is a one-off override layered on top of the configured
+ * `compaction.*` settings for a single invocation; it never mutates settings.
+ * Adding a mode is a single entry here: the command surface (autocomplete +
+ * ACP hint), the parser, and the engine override all read this table.
+ */
+/** Subcommand selecting a one-off compaction mode for manual `/compact`. */
+export type CompactMode = "soft" | "remote" | "snapcompact";
+/**
+ * Per-invocation overrides merged over the configured `compaction.*` settings.
+ * Narrowed to the two knobs the modes actually flip; the result stays
+ * assignable to the full `CompactionSettings`.
+ */
+export interface CompactionOverride {
+    strategy?: "context-full" | "snapcompact";
+    remoteEnabled?: boolean;
+}
+export interface CompactModeDef {
+    readonly name: CompactMode;
+    /** One-line description surfaced in autocomplete + help. */
+    readonly description: string;
+    /** Settings overrides applied on top of `compaction.*` for this run. */
+    readonly overrides: CompactionOverride;
+    /**
+     * When true, the mode produces no LLM summary, so trailing focus text is
+     * meaningless and rejected by the parser (snapcompact archives history into
+     * images without a directed summary).
+     */
+    readonly rejectsFocus?: boolean;
+    /**
+     * When true, the mode explicitly demands a remote path; the engine warns and
+     * falls back to a local summary if neither a remote endpoint nor a
+     * provider-native compaction path is available.
+     */
+    readonly requiresRemote?: boolean;
+}
+export declare const COMPACT_MODES: readonly CompactModeDef[];
+/** Resolve a subcommand token (case-insensitive) to its mode definition. */
+export declare function findCompactMode(name: string): CompactModeDef | undefined;
+/** Parsed `/compact` arguments: an optional mode plus optional focus text. */
+export interface ParsedCompactArgs {
+    mode?: CompactMode;
+    instructions?: string;
+}
+/**
+ * Split `/compact` args into a leading mode subcommand + focus instructions.
+ *
+ * Backward compatible: when the first token is not a known mode, the entire
+ * argument string is treated as focus instructions (the historical behavior).
+ * A recognized mode with `rejectsFocus` and trailing text is an error.
+ */
+export declare function parseCompactArgs(args: string): ParsedCompactArgs | {
+    error: string;
+};

package/dist/types/session/streaming-output.d.ts

@@ -163,8 +163,6 @@ export declare function truncateMiddle(content: string, options?: TruncationOpti
 export interface InlineByteCapOptions {
     /** Inline byte budget. Defaults to {@link DEFAULT_MAX_BYTES}. */
     maxBytes?: number;
-    /** What the text is, for the elision marker (e.g. "bash output"). */
-    label: string;
     /**
      * Persist the full text as a session artifact. When an artifact id is
      * returned, a `[raw output: artifact://<id>]` footer is appended so the

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -1,4 +1,4 @@
-import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
+import { type AutocompleteItem } from "@oh-my-pi/pi-tui";
 import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */

package/dist/types/slash-commands/helpers/collab-qrcode.d.ts

@@ -0,0 +1,13 @@
+import { type Component } from "@oh-my-pi/pi-tui";
+/**
+ * One-shot transcript block that prints a collab browser-join URL as a
+ * scannable QR code. The symbol is encoded once at construction (byte mode,
+ * EC level M) and rendered as ANSI half-blocks; on terminals too narrow for
+ * the symbol it degrades to a one-line hint pointing at the printed URL.
+ */
+export declare class CollabQrCodeComponent implements Component {
+    #private;
+    readonly url: string;
+    constructor(url: string);
+    render(width: number): readonly string[];
+}

package/dist/types/tools/__tests__/json-tree.test.d.ts

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

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

@@ -1,6 +1,6 @@
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { FetchImpl, Model, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { FetchImpl, ImageContent, Model, ToolChoice } from "@oh-my-pi/pi-ai";
 import type { AsyncJobManager } from "../async/job-manager";
 import type { Rule } from "../capability/rule";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -71,6 +71,12 @@ export type ContextFileEntry = {
     content: string;
     depth?: number;
 };
+/** Image attachment handle exposed to tools for user-facing labels such as `Image #1`. */
+export type ImageAttachmentEntry = {
+    label: string;
+    uri: string;
+    image: ImageContent;
+};
 export type { DiscoverableTool, DiscoverableToolSearchIndex, DiscoverableToolSearchResult, DiscoverableToolSource, } from "../tool-discovery/tool-index";
 /**
  * A late LSP diagnostics result that arrived after the edit/write tool already
@@ -309,6 +315,8 @@ export interface ToolSession {
     /** Get the active OpenTelemetry config so subagent dispatch can forward
      *  the parent's tracer/hooks with the subagent's own identity stamped. */
     getTelemetry?: () => AgentTelemetryConfig | undefined;
+    /** Return image attachments visible to tools for resolving labels such as `Image #1`. */
+    getImageAttachments?: () => ImageAttachmentEntry[];
 }
 export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 export type BuiltinToolLoadMode = "essential" | "discoverable";

package/dist/types/utils/image-loading.d.ts

@@ -25,6 +25,16 @@ export interface LoadImageInputOptions {
     /** Force non-WebP output (e.g. for Ollama). Leave unset to honor `OMP_NO_WEBP`. */
     excludeWebP?: boolean;
 }
+/** Options for loading an in-memory chat image attachment as a vision-model input. */
+export interface LoadImageAttachmentInputOptions {
+    image: ImageContent;
+    label: string;
+    uri: string;
+    autoResize: boolean;
+    maxBytes?: number;
+    /** Force non-WebP output (e.g. for Ollama). Leave unset to honor `OMP_NO_WEBP`. */
+    excludeWebP?: boolean;
+}
 export interface LoadedImageInput {
     resolvedPath: string;
     mimeType: string;
@@ -53,3 +63,5 @@ export interface NormalizeModelContextImagesOptions {
  */
 export declare function normalizeModelContextImages(images: ImageContent[] | undefined, options?: NormalizeModelContextImagesOptions): Promise<ImageContent[] | undefined>;
 export declare function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null>;
+/** Loads a chat attachment image through the same size and encoder policy as file-backed image inputs. */
+export declare function loadImageAttachmentInput(options: LoadImageAttachmentInputOptions): Promise<LoadedImageInput | null>;

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

@@ -0,0 +1,48 @@
+/**
+ * Self-contained QR Code generator (byte mode, versions 1-40, EC levels
+ * L/M/Q/H) with a half-block ANSI terminal renderer.
+ *
+ * Pure TypeScript, zero dependencies: the collab `/collab qrcode` command uses
+ * it to print scannable browser-join codes without pulling a runtime QR
+ * package into the bundle. The algorithm follows ISO/IEC 18004; the two
+ * error-correction tables below are direct transcriptions of that spec.
+ */
+export type QrEcLevel = "L" | "M" | "Q" | "H";
+export interface QrEncodeOptions {
+    /** Lowest version to consider (default 1). */
+    minVersion?: number;
+    /** Highest version to consider (default 40). */
+    maxVersion?: number;
+    /** Force a mask 0-7; -1 (default) auto-selects the lowest-penalty mask. */
+    mask?: number;
+}
+/**
+ * A finished QR symbol: a square grid of dark/light modules plus the chosen
+ * version, EC level, and mask. `module(x, y)` is the only access path the
+ * renderers need.
+ */
+export declare class QrCode {
+    #private;
+    readonly version: number;
+    readonly ecLevel: QrEcLevel;
+    readonly size: number;
+    /** Selected mask pattern (0-7). */
+    readonly mask: number;
+    private constructor();
+    module(x: number, y: number): boolean;
+    /** Encode a string in byte mode (UTF-8). Throws if it exceeds version 40. */
+    static encodeText(text: string, ecLevel?: QrEcLevel, options?: QrEncodeOptions): QrCode;
+    /** Encode raw bytes in byte mode. Throws if they exceed version 40 at this EC level. */
+    static encodeBytes(data: Uint8Array, ecLevel?: QrEcLevel, options?: QrEncodeOptions): QrCode;
+}
+export interface QrRenderOptions {
+    /** Quiet-zone width in modules on every side (default 4, per spec). */
+    margin?: number;
+}
+/**
+ * Render a QR symbol as ANSI half-block rows: each text row packs two module
+ * rows via `▀`/`▄`/`█`, drawn black-on-white so a phone camera reads dark
+ * modules as data and the quiet zone as the light margin. The leading margin
+ * makes the symbol scannable regardless of the terminal's own background.
+ */
+export declare function renderQrHalfBlocks(qr: QrCode, options?: QrRenderOptions): string[];