@linxiraos/pi-tui 1.3.2 → 1.4.1

package/dist/types/overlays/resume-tree.d.ts

@@ -0,0 +1,353 @@
+/**
+ * ANSI three-level resume tree: project → workspace → conversation.
+ *
+ * Renders the rows produced by the coding-agent resume view model; it never
+ * groups sessions itself. The model arrives through {@link ResumeTreeSource},
+ * which the host builds from `loadResumeDirectory` + `buildResumeView` (pi-tui
+ * cannot depend on the coding-agent package). Scope cycling, collapse state,
+ * search focus, pin actions and the delete confirmation live here; view
+ * construction and persistence live in the host.
+ */
+import * as path from "node:path";
+import { type Component } from "../index.js";
+export type ResumeTreeScope = "workspace" | "project" | "all";
+/** Persisted picker state (v2 file): scope plus local expansion. */
+export interface ResumeTreePickerState {
+    scope: ResumeTreeScope;
+    collapsedProjects?: readonly string[];
+    expandedProjects?: readonly string[];
+    collapsedWorkspaces?: readonly string[];
+    /** Absolute paths in the project/workspace/cwd labels; absent means false. */
+    fullPaths?: boolean;
+}
+export type ResumeTreeStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
+export type ResumeTreeDeleteMode = "trash" | "permanent";
+/** The session fields the tree reads from a conversation row. */
+export interface ResumeTreeSession {
+    path: string;
+    id: string;
+    cwd: string;
+    size?: number;
+    title?: string;
+    modified: Date;
+    firstMessage?: string;
+}
+export interface ResumeTreeConversation {
+    session: ResumeTreeSession;
+    key: string;
+    id: string;
+    path: string;
+    title: string;
+    cwd: string;
+    projectKey: string;
+    workspaceKey: string;
+    created: Date;
+    modified: Date;
+    status?: ResumeTreeStatus;
+    pinned: boolean;
+    current: boolean;
+    fork: boolean;
+    /** Subagent marker from `session_init.agent`; forks never set it. */
+    isSubagent?: boolean;
+    agentName?: string;
+    parentKey?: string;
+    /** Direct subagent children, when the directory attached them. */
+    subagents?: readonly ResumeTreeConversation[];
+    messageCount: number;
+}
+export interface ResumeTreeWorkspace {
+    key: string;
+    path: string;
+    name: string;
+    /** User-configured alias, or null. The directory name never changes. */
+    alias?: string | null;
+    /** Alias when set, otherwise `name`. */
+    displayName?: string;
+    projectKey: string;
+    branch: string | null;
+    pinned: boolean;
+    lastActivity: Date | null;
+    counts: {
+        conversations: number;
+        pinnedConversations: number;
+    };
+}
+export interface ResumeTreeProject {
+    key: string;
+    root: string;
+    name: string;
+    alias: string | null;
+    displayName: string;
+    isDefault: boolean;
+    pinned: boolean;
+    collapsed: boolean;
+    lastActivity: Date | null;
+    counts: {
+        conversations: number;
+        workspaces: number;
+        pinnedConversations: number;
+    };
+}
+export interface ResumeTreeProjectRow {
+    type: "project";
+    key: string;
+    project: ResumeTreeProject;
+    pinned: boolean;
+    collapsed: boolean;
+    conversationCount: number;
+    totalConversationCount: number;
+    workspaceCount: number;
+    totalWorkspaceCount: number;
+}
+export interface ResumeTreeWorkspaceRow {
+    type: "workspace";
+    key: string;
+    workspace: ResumeTreeWorkspace;
+    projectKey: string;
+    pinned: boolean;
+    conversationCount: number;
+    totalConversationCount: number;
+}
+export interface ResumeTreeConversationRow {
+    type: "conversation";
+    key: string;
+    conversation: ResumeTreeConversation;
+    projectKey: string;
+    workspaceKey: string;
+    pinned: boolean;
+    current: boolean;
+    pinnedOnly?: boolean;
+}
+export type ResumeTreeRow = ResumeTreeProjectRow | ResumeTreeWorkspaceRow | ResumeTreeConversationRow;
+export interface ResumeTreeView {
+    scope: {
+        kind: ResumeTreeScope;
+        projectKey?: string;
+        workspaceKey?: string;
+    };
+    query: {
+        raw: string;
+        terms?: readonly string[];
+    };
+    rows: readonly ResumeTreeRow[];
+    conversations?: readonly ResumeTreeConversationRow[];
+    counts: {
+        conversations: number;
+        workspaces?: number;
+        projects?: number;
+        totalConversations: number;
+        totalWorkspaces?: number;
+        totalProjects?: number;
+    };
+    /** Branch of the current session's workspace, when known. */
+    referenceBranch?: string | null;
+    /** Workspace key of the current session, when known. */
+    currentWorkspaceKey?: string;
+}
+/** Names and per-scope conversation totals for the scope header. */
+export interface ResumeTreeScopeSummary {
+    workspaceName: string;
+    projectName: string;
+    counts: Record<ResumeTreeScope, number>;
+}
+/**
+ * Host bridge. `buildView` must be a pure projection of the loaded directory;
+ * `refresh`/`pin*`/`deleteConversation` perform I/O and resolve when the
+ * source's internal state is current again.
+ */
+export interface ResumeTreeSource {
+    readonly initialScope: ResumeTreeScope;
+    buildView(input: {
+        scope: ResumeTreeScope;
+        query: string;
+        currentSessionPath?: string;
+    }): ResumeTreeView | null;
+    scopeSummary(): ResumeTreeScopeSummary;
+    currentSessionPath?(): string | undefined;
+    /** Remember the chosen scope across opens. */
+    persistScope?(scope: ResumeTreeScope): void | Promise<void>;
+    /** Restored v2 picker state (scope + expansion); absent means defaults. */
+    pickerState?(): ResumeTreePickerState;
+    /** Persist scope + expansion together (preferred over `persistScope`). */
+    persistPickerState?(state: ResumeTreePickerState): void | Promise<void>;
+    /** Re-read the directory; resolves once `buildView` reflects the new state. */
+    refresh?(): Promise<void>;
+    /** Partial scan failures (unreadable project folders) while rows are still listed. */
+    scanWarningNames?(): readonly string[];
+    /** A failed load: no rows available at all. */
+    loadError?(): string | undefined;
+    isLoading?(): boolean;
+    pinConversation?(conversation: ResumeTreeConversation, pinned: boolean): Promise<void>;
+    pinProject?(project: ResumeTreeProject, pinned: boolean): Promise<void>;
+    pinWorkspace?(workspace: ResumeTreeWorkspace, pinned: boolean): Promise<void>;
+    /** Set the workspace display alias; resolves the name the picker now shows. */
+    renameWorkspace?(workspace: ResumeTreeWorkspace, alias: string | null): Promise<string | null>;
+    openWorkspace?(workspace: ResumeTreeWorkspace): void | Promise<void>;
+    /** Rename the persisted session title; resolves the stored name or null. */
+    renameConversation?(conversation: ResumeTreeConversation, title: string): Promise<string | null>;
+    /** False hides the conversation rename action (read-only/foreign session). */
+    canRenameConversation?(conversation: ResumeTreeConversation): boolean;
+    /** Scopes without a project header (workspace/project) resolve the project here. */
+    projectByKey?(key: string): ResumeTreeProject | undefined;
+    deleteConversation?(conversation: ResumeTreeConversation): Promise<boolean>;
+    deleteMode: ResumeTreeDeleteMode;
+}
+export interface ResumeTreeOptions {
+    source: ResumeTreeSource;
+    getTerminalRows?: () => number;
+    onSelect: (conversation: ResumeTreeConversation) => void;
+    onCancel: () => void;
+    onExit: () => void;
+    onRequestRender?: () => void;
+    /** Start with the search field focused (the default for a resume picker). */
+    searchFocused?: boolean;
+}
+/** Short relative age, localised through the shared session-picker keys. */
+export declare function formatResumeAge(date: Date, now?: number): string;
+/** Middle-ellipsis truncation for path-like text (`a/b/…/x/y`). */
+export declare function middleEllipsis(text: string, maxWidth: number): string;
+/** Pick the path API from the string's own shape, not the host platform. */
+export declare function resumePathApi(value: string): typeof path.posix;
+/** Full path spelled with its own platform's separators (drive, UNC or POSIX). */
+export declare function absoluteResumePath(value: string): string;
+/** Short parent/name tail or the full absolute path, per the picker toggle. */
+export declare function formatResumePath(value: string, fullPaths: boolean): string;
+/** Basename-first path tail (`parent/name`) keeping the platform separator. */
+export declare function resumePathTail(value: string): string;
+/**
+ * Truncate from the left so the tail stays readable, keeping a drive/UNC root
+ * when there is room for one (`D:\…\repo`, `\\server\share\…\repo`). The
+ * returned string never exceeds `maxWidth` visible columns.
+ */
+export declare function truncateResumePath(value: string, maxWidth: number): string;
+/**
+ * A workspace branch is noise when it repeats the current workspace's branch;
+ * it is kept for the current workspace or when it actually differs.
+ */
+export declare function shouldShowBranch(branch: string | null | undefined, referenceBranch: string | null | undefined, current: boolean, workspaceName?: string): boolean;
+/** Stable right-hand column widths for the conversation list. */
+export interface ConversationColumns {
+    status: number;
+    turns: number;
+    age: number;
+    flags: number;
+}
+/** Width of the status column, fixed across rows so every title starts together. */
+export declare function statusColumnWidth(): number;
+/** Column widths across every visible conversation row, so columns stay put while scrolling. */
+export declare function conversationColumns(rows: readonly ResumeTreeConversationRow[], now?: number): ConversationColumns;
+/**
+ * One dense conversation row: `status | title | turns | age | flags | ⋯`.
+ * The status cell and every metadata column have fixed widths computed once
+ * per frame; the title is the only flexible cell, and nothing ever wraps.
+ */
+export declare function renderConversationRow(row: ResumeTreeConversationRow, options: {
+    width: number;
+    selected: boolean;
+    now?: number;
+    columns?: ConversationColumns;
+    /** Show the conversation cwd as an absolute path instead of omitting it. */
+    fullPaths?: boolean;
+}): string;
+/**
+ * One workspace sub-header, indented one visible step: a coloured fold+name,
+ * a branch chip when it adds information, and right-aligned counts + `⋯`.
+ */
+export declare function renderWorkspaceRow(row: ResumeTreeWorkspaceRow, options: {
+    width: number;
+    selected: boolean;
+    collapsed: boolean;
+    referenceBranch?: string | null;
+    current?: boolean;
+    /** Show absolute workspace paths instead of parent/name tails. */
+    fullPaths?: boolean;
+    /** Workspace scope has no use for the path label; callers can omit it. */
+    showPath?: boolean;
+}): string;
+/**
+ * Project section header: pin + name + path tag on the left, counts/workspaces/
+ * age right-aligned. The caller draws a full-width rule under it.
+ */
+export declare function renderProjectRow(row: ResumeTreeProjectRow, options: {
+    width: number;
+    selected: boolean;
+    collapsed: boolean;
+    now?: number;
+    /** Show the absolute project root instead of the parent/name tail. */
+    fullPaths?: boolean;
+}): string;
+/** Full-width rule closing a project section header. */
+export declare function renderProjectRule(width: number): string;
+/** A scope-segment hit range on the header line, in tree-local columns. */
+export interface ResumeScopeHit {
+    kind: ResumeTreeScope;
+    start: number;
+    end: number;
+}
+/** The three-tab scope control with per-scope counts, plus its clickable ranges. */
+export declare function renderScopeHeaderHits(scope: ResumeTreeScope, summary: ResumeTreeScopeSummary, width: number): {
+    text: string;
+    hits: ResumeScopeHit[];
+};
+/** The three-tab scope control with per-scope counts. */
+export declare function renderScopeHeader(scope: ResumeTreeScope, summary: ResumeTreeScopeSummary, width: number): string;
+interface FlatRow {
+    row: ResumeTreeRow;
+    /** Visible when every ancestor group is expanded. */
+    parentKey?: string;
+}
+export interface ResumeTreeState {
+    collapsedProjects: Set<string>;
+    expandedProjects: Set<string>;
+    collapsedWorkspaces: Set<string>;
+}
+/** Flatten model rows under the current local collapse state (headers always stay). */
+export declare function flattenResumeRows(rows: readonly ResumeTreeRow[], state: ResumeTreeState, searching: boolean): FlatRow[];
+/**
+ * The ANSI resume tree component. The host mounts it inside its panel chrome;
+ * this component renders the scope control, search field, banners and rows.
+ */
+export declare class ResumeTreeComponent implements Component {
+    #private;
+    readonly onSelect: (conversation: ResumeTreeConversation) => void;
+    readonly onCancel: () => void;
+    readonly onExit: () => void;
+    onRequestRender?: () => void;
+    constructor(options: ResumeTreeOptions);
+    /** Rebuild the cached view (call after the host refreshes its directory). */
+    invalidate(): void;
+    get scope(): ResumeTreeScope;
+    get fullPaths(): boolean;
+    /**
+     * Toggle absolute paths. In workspace scope the path is redundant, so the
+     * key surfaces a one-line hint and leaves the setting untouched; the
+     * project/all scopes actually flip and persist it.
+     */
+    toggleFullPaths(): void;
+    /** Adopt a host-refreshed view while keeping selection and collapse state. */
+    setView(view: ResumeTreeView | null): void;
+    /** Cycle workspace → project → all → workspace. */
+    cycleScope(direction?: 1 | -1): void;
+    /** Switch to a scope (the scope segments and Tab share this path). */
+    setScope(scope: ResumeTreeScope): void;
+    /** Re-read the directory through the host source. */
+    refresh(): Promise<void>;
+    /** Focus the search field (the `/` key, and the initial state). */
+    focusSearch(): void;
+    /** Pin the selected conversation (`p`) or its project (`P`). */
+    pinSelected(project: boolean): Promise<void>;
+    /**
+     * Hit-test an SGR mouse report against the rows the last render recorded.
+     * The fullscreen picker paints from screen row 0, so callers pass the
+     * component's frame offset (`row` of the first rendered line, `col` of its
+     * first content column). Keyboard handling never depends on this path.
+     */
+    handleMouse(data: string, offset?: {
+        row?: number;
+        col?: number;
+    }): boolean;
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+    dispose(): void;
+}
+export {};

package/dist/types/overlays/session-selector.d.ts

@@ -1,6 +1,7 @@
 import { type Component, Input } from "../index.js";
 import type { TspPickerGroup, TspPickerItem } from "@linxiraos/pi-wire";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
+import { type ResumeSourceLike } from "./resume-picker.js";
 /** Session lifecycle status presented by the picker. */
 export type SessionSelectorStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
 /** Session listing fields consumed by the picker. */
@@ -18,6 +19,8 @@ export interface SessionSelectorEntry {
     /** Path to the parent session when this one was forked. */
     parentSessionPath?: string;
 }
+import { ResumeTreeComponent } from "./resume-tree.js";
+export type { ResumeConversationLike, ResumeDirectoryLike, ResumeProjectLike, ResumeQueryLike, ResumeScopeInputLike, ResumeScopeKindLike, ResumeSourceLike, ResumeViewLike, ResumeViewRowLike, ResumeWorkspaceLike, } from "./resume-picker.js";
 import { OverlayPanel } from "../chrome/overlay-box.js";
 /** The session list's part of the picker props, plus the memo keys it was built from. */
 interface SessionPickerView {
@@ -76,6 +79,11 @@ declare class SessionList<T extends SessionSelectorEntry> implements Component {
     constructor(sessions: T[], showCwd?: boolean, historyMatcher?: SessionHistoryMatcher, getTerminalRows?: () => number, pinnedIds?: ReadonlySet<string>, currentSessionPath?: string | (() => string | undefined));
     /** Replace the visible dataset, e.g. when toggling folder/all-projects scope. */
     setSessions(sessions: T[], showCwd: boolean, pinnedIds?: ReadonlySet<string>): void;
+    /**
+     * Resume-model mode: the given sessions are already the model's ordered,
+     * filtered view, so mirror them and keep the selection when it survives.
+     */
+    syncSessions(sessions: readonly T[], preferredPath?: string | null): void;
     /** Cancel pending async search work; idempotent, called on every picker exit path. */
     dispose(): void;
     removeSession(sessionPath: string): void;
@@ -125,6 +133,17 @@ export interface SessionSelectorOptions<T extends SessionSelectorEntry = Session
     loadAllSessions?: () => Promise<T[]>;
     /** Preloaded all-projects list; cached so the first Tab toggle is instant. */
     allSessions?: T[];
+    /**
+     * The host's resume model (project → workspace → conversation) and its
+     * pure view builder. When set, the native `picker` describes the resume
+     * tree instead of the flat day-grouped list; the ANSI path is unchanged.
+     */
+    resumeSource?: ResumeSourceLike;
+    /**
+     * What delete does to the session file: an in-session picker moves it to
+     * the trash, `--resume` deletes it permanently. Wording only.
+     */
+    deleteMode?: "trash" | "permanent";
     /** Picker heading; defaults to "Resume Session". */
     title?: string;
     /** Primary action label; defaults to "Resume" (ANSI footer defaults to "select"). */
@@ -160,9 +179,7 @@ export interface SessionSelectorOptions<T extends SessionSelectorEntry = Session
      */
     standalone?: boolean;
 }
-/**
- * Component that renders a session selector with optional confirmation dialog
- */
+/** Component that renders a session selector with optional confirmation dialog. */
 export declare class SessionSelectorComponent<T extends SessionSelectorEntry = SessionSelectorEntry> extends OverlayPanel {
     #private;
     constructor(sessions: T[], onSelect: (session: T) => void, onCancel: () => void, onExit: () => void, options?: SessionSelectorOptions<T>);
@@ -196,5 +213,6 @@ export declare class SessionSelectorComponent<T extends SessionSelectorEntry = S
     handleNativeEvent(event: NativeUiEvent): void;
     handleInput(keyData: string): void;
     getSessionList(): SessionList<T>;
+    /** The ANSI resume tree when the host supplied a resume source. */
+    getResumeTree(): ResumeTreeComponent | undefined;
 }
-export {};

package/dist/types/render/output-block.d.ts

@@ -10,6 +10,8 @@ import type { State } from "./types.js";
 export interface OutputBlockOptions {
     header?: string;
     headerMeta?: string;
+    /** Facts drawn inside the bottom border (`╰── Wall 0.16s · Timeout 300s ──╯`). */
+    footerMeta?: string;
     state?: State;
     sections?: Array<{
         label?: string;

package/dist/types/render/tool-card.d.ts

@@ -22,6 +22,8 @@ export interface ToolCardSnapshot {
     /** Structured status header, rendered by the shared status-line primitive. */
     status?: StatusLineOptions;
     headerMeta?: string;
+    /** Short facts drawn inside the frame's bottom border (framed); a trailing row otherwise. */
+    footerMeta?: string;
     phase?: ToolCardPhase;
     body?: ToolCardContent;
     sections?: readonly ToolCardSection[];

package/dist/types/sixel.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Give an empty first band an explicit transparent width. Zellij derives the
+ * decoded image width from its first pixel row, ignoring the raster minimum
+ * for transparent images; an omitted band otherwise makes the image invisible.
+ * Palette definitions stay before drawing so cropping can still parse them.
+ */
+export declare function ensureSixelRasterWidth(sequence: string): string;
+/**
+ * Crop integer pixel rows from a raw (not tmux-wrapped) SIXEL DCS image.
+ * Runs are shifted between adjacent six-pixel bands, never decoded to pixels.
+ * Palette selections, overdraw order, transparent gaps and DCS background mode
+ * are retained. A nonpositive crop returns the original sequence unchanged.
+ *
+ * The supported grammar is the native icy_sixel encoder's: one leading raster
+ * declaration with positive dimensions and square pixels, prefix RGB/HLS palette
+ * definitions, register selections, sixel characters, repeats, `$` and `-`.
+ * ESC DCS/ST framing only, as the TUI emits it. Palette definitions after
+ * drawing, additional raster declarations, other controls and malformed input
+ * throw; forwarding an unsupported image uncropped would reintroduce raster
+ * overflow.
+ *
+ * Without maxHeightPixels the crop is exact, including a partial final band with
+ * zero padding bits and the exact declared raster height. Some terminals still
+ * allocate all six rows of that final band. The TUI supplies its available pixel
+ * height to cap the result at a whole-band boundary, matching the native encoder's
+ * policy of dropping bottom pixels rather than overwriting the following row.
+ */
+export declare function cropSixelTop(sequence: string, pixels: number, maxHeightPixels?: number): string;

package/dist/types/status-line/host.d.ts

@@ -1,6 +1,7 @@
 import type { AgentMessage, ThinkingLevel } from "@linxiraos/pi-agent-core";
 import type { Tool, UsageLimit, UsageReport } from "@linxiraos/pi-ai";
 import type { Model } from "@linxiraos/pi-catalog/types";
+import type { JobWidgetEntry } from "../tools/job-widget.js";
 import type { CompactionBoundaries } from "./context-usage.js";
 import type { StatusLineSettings, StatusResetExpiry } from "./types.js";
 export interface StatusAccountIdentity {
@@ -74,6 +75,8 @@ export interface StatusLineSession {
             agentId?: string;
         }[];
     } | null | undefined;
+    /** Widgets of the running background jobs, in job order; the jobs segment appends the freshest one's glance. */
+    getRunningJobWidgets?(): readonly JobWidgetEntry[];
     getGoalModeState(): {
         goal?: {
             status: string;

package/dist/types/terminal-capabilities.d.ts

@@ -18,7 +18,7 @@ export declare enum NotifyProtocol {
     Osc99 = "\u001B]99;;",
     Osc9 = "\u001B]9;"
 }
-export type TerminalId = "kitty" | "ghostty" | "wezterm" | "iterm2" | "vscode" | "alacritty" | "warp" | "orca" | "otty" | "rio" | "tern" | "monstar" | "base" | "trueColor";
+export type TerminalId = "kitty" | "ghostty" | "wezterm" | "iterm2" | "vscode" | "alacritty" | "warp" | "orca" | "otty" | "rio" | "tern" | "monstar" | "zetawork" | "base" | "trueColor";
 /** Terminal capability details used for rendering and protocol selection. */
 export declare class TerminalInfo {
     readonly id: TerminalId;
@@ -401,6 +401,11 @@ export declare function encodeITerm2(base64Data: string, options?: {
     preserveAspectRatio?: boolean;
     inline?: boolean;
 }): string;
+/**
+ * The encoded image `encodeITerm2` wrote into `line`, without the size
+ * parameters a rewrap changes; undefined for a line without one.
+ */
+export declare function iterm2ImagePayload(line: string): string | undefined;
 export declare function calculateImageRows(imageDimensions: ImageDimensions, targetWidthCells: number, cellDimensions?: CellDimensions): number;
 export declare function getPngDimensions(base64Data: string): ImageDimensions | null;
 export declare function getJpegDimensions(base64Data: string): ImageDimensions | null;

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

@@ -117,6 +117,7 @@ export declare function createShellRenderer<TArgs>(config: ShellRendererConfig<T
     }, args?: TArgs): NativeToolView;
     mergeCallAndResult: true;
     inline: true;
+    tickElapsed: true;
 };
 /** Renders bash command previews and output. */
 export declare const bashToolRenderer: {
@@ -146,4 +147,5 @@ export declare const bashToolRenderer: {
     }, args?: BashRenderArgs | undefined): NativeToolView;
     mergeCallAndResult: true;
     inline: true;
+    tickElapsed: true;
 };

package/dist/types/tools/default-renderer.d.ts

@@ -23,6 +23,9 @@ export declare function formatDefaultToolExecution(input: DefaultToolRenderInput
 /**
  * TSP view of the generic fallback card: the tool label with a one-line args
  * summary as the head target; the result as a JSON tree or raw `ansi` output.
+ * The complete output goes over the wire — the card-level disclosure clamp the
+ * terminal applies is the only bound, so an expanded card keeps every row. JSON
+ * the tree's depth, node or scalar caps would cut keeps the raw path instead.
  */
 export declare function describeDefaultToolExecution(input: DefaultToolRenderInput): NativeToolView;
 /** Render the generic fallback as the state-tinted card used by direct custom tools. */

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

@@ -61,7 +61,7 @@ export interface EvalCellResult {
     durationMs?: number;
     exitCode?: number;
     statusEvents?: EvalStatusEvent[];
-    /** Discrete events dropped from the front of `statusEvents` (see {@link recordStatusEvent}). */
+    /** Evictable events dropped from the front of `statusEvents` (see {@link recordStatusEvent}). */
     statusEventsElided?: number;
 }
 /** Tool result detail object surfaced to the UI/transcript. */
@@ -69,7 +69,7 @@ export interface EvalToolDetails {
     cells?: EvalCellResult[];
     images?: ImageContent[];
     statusEvents?: EvalStatusEvent[];
-    /** Discrete events dropped from the front of `statusEvents` (see {@link recordStatusEvent}). */
+    /** Evictable events dropped from the front of `statusEvents` (see {@link recordStatusEvent}). */
     statusEventsElided?: number;
     isError?: boolean;
     meta?: OutputMeta;
@@ -104,7 +104,7 @@ interface EvalRenderContext {
     timeout?: number;
 }
 /**
- * Coalescing key of a progress-snapshot event: `agent` and `judge_batch`
+ * Coalescing key of a progress-snapshot event: `agent`, `judge_batch`, and `mcp_progress`
  * events keyed by `id`, where only the newest snapshot matters. Discrete
  * actions (everything else) have no key. Shared by {@link upsertStatusEvent}
  * and the executors' display collectors so both coalesce identically.
@@ -114,12 +114,12 @@ export declare function statusEventKey(event: {
     [key: string]: unknown;
 }): string | undefined;
 /**
- * Discrete status events a log keeps. A cell polling a helper in a loop emits
+ * Evictable status events a log keeps. A cell polling a helper in a loop emits
  * one event per call (hundreds of thousands), and every live update and the
  * persisted tool result would otherwise carry them all.
  */
 export declare const MAX_STATUS_EVENTS = 200;
-/** A status event list plus the count of discrete events dropped from its front. */
+/** A status event list plus the count of evictable events dropped from its front. */
 export type StatusEventLog = Pick<EvalCellResult, "statusEvents" | "statusEventsElided">;
 /**
  * Append or replace a status event. Progress snapshots (see
@@ -129,9 +129,10 @@ export type StatusEventLog = Pick<EvalCellResult, "statusEvents" | "statusEvents
 export declare function upsertStatusEvent(events: EvalStatusEvent[], event: EvalStatusEvent): void;
 /**
  * {@link upsertStatusEvent} into a bounded log. Past {@link MAX_STATUS_EVENTS},
- * the oldest discrete event is dropped and counted. Snapshots stay, since agent
- * cards read them, and so does the newest committed `todo` result, which the
- * session todo panel refreshes from. Renderers already show only the newest
+ * the oldest discrete event or MCP progress snapshot is dropped and counted.
+ * Agent/judgment-batch snapshots stay, since agent cards read them, and so does
+ * the newest committed `todo` result, which the session todo panel refreshes
+ * from. Renderers already show only the newest
  * events behind an "… N earlier" row.
  */
 export declare function recordStatusEvent(log: StatusEventLog, event: EvalStatusEvent): void;

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

@@ -123,6 +123,8 @@ export interface CoordinationDetails {
     }[];
     /** Running subagents not represented by a job row in this result. */
     agents?: AgentActivitySnapshot[];
+    /** `wait` returned early because blocking would deadlock (mesh S6). */
+    status?: "peer-waiting-on-you";
 }
 /** Hub result details: coordination snapshots or launch (process) state. */
 export type HubDetails = CoordinationDetails | LaunchToolDetails;
@@ -204,7 +206,7 @@ export interface IrcMessage {
 /** Delivery outcome for one peer recipient. */
 export interface IrcDeliveryReceipt {
     to: string;
-    outcome: "injected" | "woken" | "revived" | "failed";
+    outcome: "injected" | "woken" | "revived" | "queued" | "failed";
     error?: string;
 }
 /** Broker-facing launch parameters; the hub adapts its `ps` op to `list` before calling in. */

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

@@ -19,11 +19,21 @@ export interface IrcMessage {
      * ping-pong forever.
      */
     wakeRelay?: boolean;
+    /**
+     * One leg of an `all` broadcast. Like relays, broadcasts never draw an
+     * automatic wake-turn reply: every woken idle peer would otherwise answer
+     * the broadcaster, mostly to say the message was not for it.
+     */
+    broadcast?: boolean;
 }
 /** Delivery outcome for one peer recipient. */
 export interface IrcDeliveryReceipt {
     to: string;
-    outcome: "injected" | "woken" | "revived" | "failed";
+    /**
+     * `queued` is the cross-process offline path: the message is in the peer's
+     * persistent mailbox and will be injected when its process next starts.
+     */
+    outcome: "injected" | "woken" | "revived" | "queued" | "failed";
     error?: string;
 }
 /** Status ordering for peer rosters in child prompts. */