@linxiraos/pi-tui 1.4.0 → 1.4.1

package/dist/types/overlays/jobs-panel.d.ts

@@ -1,6 +1,7 @@
 import type { Component } from "../tui.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 import { type JobTreeAgent } from "./job-tree.js";
+import { type JobWidgetView } from "../tools/job-widget.js";
 /** One async job as the session snapshots it. */
 export interface JobsPanelJob {
     readonly id: string;
@@ -35,6 +36,8 @@ export interface JobsPanelDetail {
     readonly output?: string;
     /** Artifact holding the full output when `output` is cut. */
     readonly artifactId?: string;
+    /** The job's live widget (frozen once it settles), drawn above the output. */
+    readonly widget?: JobWidgetView;
 }
 /** The session behind a {@link JobsSheet}. */
 export interface JobsSheetSource {

package/dist/types/overlays/model-browser.d.ts

@@ -7,7 +7,7 @@ import { type ThemeColor } from "../theme/theme.js";
 import type { TspPickerColumn, TspPickerGroup, TspPickerItem, TspPickerMark } from "@linxiraos/pi-wire";
 import type { NativeChild, NativeNode, NativeUiEvent } from "../native/node.js";
 /** Canonical display ordering of built-in model roles. */
-export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "commit" | "tiny" | "memory" | "task" | "advisor" | "image" | "web" | "speech" | "dictation" | "judge";
+export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "commit" | "tiny" | "memory" | "task" | "advisor" | "widget" | "image" | "web" | "speech" | "dictation" | "judge";
 export declare const MODEL_ROLE_IDS: ModelRole[];
 export declare const CHAT_MODEL_ROLE_IDS: ModelRole[];
 export declare const KIND_ROLE_IDS: ModelRole[];

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

@@ -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/irc.d.ts

@@ -19,6 +19,12 @@ 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 {

package/dist/types/tools/job-widget.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Live widgets for background jobs: the rendered state of what a job is
+ * doing (a benchmark's requests/s over time, tests passed per model, CI jobs
+ * green so far), shown in the `wait` card, the HUD's jobs pill and the jobs
+ * sheet.
+ *
+ * A widget is data, not code. In coding-agent, a cheap model writes a
+ * `JobWidgetSpec` once per job (rules that pull numbers out of the job's
+ * output streams, and the blocks to draw them with); the job-widgets runtime
+ * then applies those rules to every new line and recomputes a
+ * {@link JobWidgetView}. Renderers here draw that view as TSP nodes (Tern) or
+ * ANSI lines, and never see a rule or a regex.
+ */
+import type { TspPropNode, TspSpan, TspTone } from "@linxiraos/pi-wire";
+import type { NativeNode } from "../native/node.js";
+import type { Theme } from "../theme/theme.js";
+/** Where a widget's view stands. */
+export type JobWidgetState = 
+/** The cheap model is writing the spec; the view holds the model-free fallback meanwhile. */
+"authoring"
+/** The spec's rules drive the view. */
+ | "live"
+/** No spec (no model, authoring failed, nothing to read yet): last line and rates only. */
+ | "fallback";
+/** A formatted number with the direction it moved, for headlines and stats. */
+export interface JobWidgetTrend {
+    /** `▲ 15%`, `▼ 3.2 ms`. */
+    text: string;
+    /** `success` when the move is toward `better`, `error` away from it, `muted` without a direction. */
+    tone: "success" | "error" | "muted";
+}
+/** The headline value: the one number a glance should take away (`186 tok/s`). */
+export interface JobWidgetHeadline {
+    /** Formatted value with its unit. */
+    text: string;
+    /** What the value is, when the title does not already say it (`decode`, `p50`). */
+    label?: string;
+    trend?: JobWidgetTrend;
+}
+/** A time series drawn as columns, newest right, with optional reference lines. */
+export interface JobWidgetSparkBlock {
+    kind: "spark";
+    /** What the series measures (`tok/s · nvfp4 b1`). */
+    label: string;
+    /** At most 48 values, oldest first, already downsampled. */
+    values: number[];
+    /** Domain of the chart; covers the values and every mark. */
+    min: number;
+    max: number;
+    /** Horizontal reference lines in value units (a target, a baseline). */
+    marks?: {
+        value: number;
+        label: string;
+        tone?: TspTone;
+    }[];
+    /** Latest value, formatted (`186 tok/s`). */
+    last: string;
+    /** Per-point tooltip text, same length as `values` (`12:04:31 · 186 tok/s`). */
+    tips?: string[];
+    tone?: TspTone;
+}
+/** One bar per key (a model, a shard): a value against a common maximum. */
+export interface JobWidgetBarsBlock {
+    kind: "bars";
+    label: string;
+    items: {
+        label: string;
+        value: number;
+        text: string;
+        tone?: TspTone;
+    }[];
+    /** The value a full bar stands for. */
+    max: number;
+}
+/** Progress of a countable whole (`7/9 trials`). */
+export interface JobWidgetMeterBlock {
+    kind: "meter";
+    label: string;
+    /** 0–1. */
+    value: number;
+    /** `7/9 trials`. */
+    text: string;
+    tone?: TspTone;
+}
+/** A few labelled numbers on one line (`p50 41 ms · p99 212 ms · errors 0`). */
+export interface JobWidgetStatBlock {
+    kind: "stat";
+    items: {
+        label: string;
+        text: string;
+        tone?: TspTone;
+        trend?: JobWidgetTrend;
+    }[];
+}
+/** One cell per key with its latest state (CI jobs, shards, workers). */
+export interface JobWidgetGridBlock {
+    kind: "grid";
+    label: string;
+    items: {
+        label: string;
+        text: string;
+        tone: TspTone;
+    }[];
+}
+/** The latest line a rule captured (the test now running, the current phase). */
+export interface JobWidgetTextBlock {
+    kind: "text";
+    text: string;
+}
+export type JobWidgetBlock = JobWidgetSparkBlock | JobWidgetBarsBlock | JobWidgetMeterBlock | JobWidgetStatBlock | JobWidgetGridBlock | JobWidgetTextBlock;
+/**
+ * Everything a renderer needs to draw one job's widget. Plain JSON: it rides
+ * on `JobSnapshot.widget` through `wait` progress updates and is persisted
+ * with the final `wait` result, so a sealed card redraws the last state after
+ * a session reload.
+ */
+export interface JobWidgetView {
+    /** Short name of what is being watched (`verb-bench · 3 models`). */
+    title: string;
+    headline?: JobWidgetHeadline;
+    /** What the job is doing now: a subagent's stage, or the last line of output. */
+    stage?: string;
+    /** Top to bottom; the first block is the primary one, and compact views show only it. */
+    blocks: JobWidgetBlock[];
+    state: JobWidgetState;
+    /** Epoch ms of the newest data the view reflects. */
+    updatedAt: number;
+}
+/** A running job's widget, as the HUD and the status line list them. */
+export interface JobWidgetEntry {
+    id: string;
+    type: JobTileType;
+    view: JobWidgetView;
+}
+/** What a glance at a widget reads: its headline, else the primary figure of its blocks. */
+export interface JobWidgetGlance {
+    text: string;
+    label?: string;
+    trend?: JobWidgetTrend;
+}
+/** What one glance at the widget reads: the headline, else the latest figure of its first spark or meter. */
+export declare function jobWidgetGlance(view: JobWidgetView): JobWidgetGlance | undefined;
+/** The widget's first spark cut to its newest `points` values (the HUD's mini chart); undefined without data. */
+export declare function jobWidgetSpark(view: JobWidgetView, points?: number): JobWidgetSparkBlock | undefined;
+/** The entry whose live widget (one a spec drives) saw data last. */
+export declare function latestJobWidget<T extends JobWidgetEntry>(entries: readonly T[]): T | undefined;
+/** The widget as one plain line for tooltips: `verb-bench · 3 models — decode 186 tok/s ▲ 15%`. */
+export declare function jobWidgetSummary(view: JobWidgetView): string;
+/** Spans of a glance: muted label, strong number, toned trend. */
+export declare function jobWidgetGlanceSpans(glance: JobWidgetGlance): TspSpan[];
+/**
+ * A glance for the ANSI status line: the figure with its trend, then a
+ * `cells`-wide sparkline of the primary spark when there is one.
+ */
+export declare function formatJobWidgetGlance(view: JobWidgetView, theme: Theme, cells?: number): string;
+/**
+ * A job's whole widget as a TSP subtree (role `zeta.job.widget`), as the jobs
+ * sheet details it: a head row (title, stage, headline) over every block.
+ */
+export declare function describeJobWidget(view: JobWidgetView): NativeNode;
+/**
+ * The HUD jobs pill's hover card: up to four running jobs as tiles, then a
+ * count of the rest; undefined without widgets. Its tiles carry no clock:
+ * Tern draws the card only once hovered, and a clock drawn then would start
+ * from the last time the program wrote.
+ */
+export declare function describeJobWidgetsHovercard(entries: readonly JobWidgetEntry[]): TspPropNode | undefined;
+/** The HUD's mini chart: the newest values of the widget's first spark; undefined without one. */
+export declare function describeJobWidgetMiniSpark(view: JobWidgetView): NativeNode | undefined;
+/** Where a tiled job stands. */
+export type JobTileStatus = "running" | "completed" | "failed" | "cancelled";
+/** What kind of job a tile shows: a subagent (`task`) goes by its name, any other job by what it runs. */
+export type JobTileType = "bash" | "task" | "eval";
+/** One job as a tile draws it: who it is, how long it has run, and its widget when it has one. */
+export interface JobTile {
+    id: string;
+    type: JobTileType;
+    status: JobTileStatus;
+    /** The job's label (a command): the title of a job that is no subagent, before a widget names it. */
+    label: string;
+    /** How long the job has run; a tile without it shows no clock. */
+    durationMs?: number;
+    /** Whether the job is live (its dot pulses, its clock runs); settled and sealed tiles freeze. */
+    live: boolean;
+    /** The job's widget; only a live one (a spec drives it) draws figures and charts, any lends its stage. */
+    widget?: JobWidgetView;
+    /** A task's own completion estimate (0–100), drawn as a ring. */
+    completionPercent?: number;
+    /** What the job is doing now, when its widget names nothing: a task's stage in its own words. */
+    stage?: string;
+    exitCode?: number;
+}
+/**
+ * Jobs as one frame of equal tiles (role `zeta.job.tiles`) that wraps onto
+ * more rows when the frame runs out of width.
+ */
+export declare function describeJobTiles(tiles: readonly JobTile[]): NativeNode;
+/**
+ * One job as a tile (role `zeta.job.tile`): a head line (status, name, id,
+ * a task's own completion estimate as a ring, clock), then what a live
+ * widget shows (the figure a glance takes away, its primary block, quiet
+ * lines of stats) and the stage. With nothing to chart, the stage is the
+ * tile's body.
+ */
+export declare function describeJobTile(tile: JobTile): NativeNode;
+/**
+ * A job's whole widget as terminal lines, each within `width` (capped at 80
+ * so bars stay next to their labels): the head line (title, stage, headline
+ * at the right), then every block under a shared label column.
+ */
+export declare function renderJobWidgetLines(view: JobWidgetView, width: number, theme: Theme): string[];
+/** How the ANSI wait card draws a tile. */
+export interface JobTileLineOptions {
+    /** Opens the title line: the caller's status icon and type badge. */
+    lead: string;
+    /** Closes the title line at the right, after the figure: the duration. */
+    meta: string;
+    /** Every block rather than the primary one alone (an expanded card). */
+    full?: boolean;
+}
+/**
+ * A tile as terminal lines within `width`: the lead, name and id with the
+ * figure and meta at the right, then a live widget's primary block (every
+ * block when `full`) and dim lines of stats and stage, capped at 80 cells.
+ */
+export declare function renderJobTileLines(tile: JobTile, width: number, theme: Theme, options: JobTileLineOptions): string[];

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

@@ -70,6 +70,8 @@ export interface JsonTreeDescribeOptions {
     openDepth?: number;
     /** Root object keys omitted. Defaults to internal tool argument metadata. */
     hiddenRootKeys?: readonly string[];
+    /** Called after the tree is built if a depth, node or scalar cap left part of the value out. */
+    onTruncated?: () => void;
 }
 /**
  * TSP `tree` of a JSON value: containers become expandable nodes labelled with

package/dist/types/tools/line-ranges.d.ts

@@ -10,12 +10,19 @@ export interface LineRange {
 export declare const LINE_RANGE_CHUNK_SOURCE: string;
 /** Parse a single `N`, `N-M`, `N-`, `N+K`, or `..`-aliased (`N..M`, `N..`) chunk. Throws via {@link ToolError} on invalid bounds. */
 export declare function parseLineRangeChunk(sel: string): LineRange | null;
+/** What a bare `N` selects in a one-chunk list: lines `N` onward (`:50`), or the single line `N`. */
+export type BareLineMode = "onward" | "single";
 /**
  * Parse a comma-separated list of line ranges (e.g. `5-16,960-973` or `19,59`). Returns
  * the ranges in ascending order with overlapping/adjacent ranges merged so
  * downstream consumers can stream the file in a single forward pass per range.
  */
-export declare function parseLineRanges(sel: string): [LineRange, ...LineRange[]] | null;
+export declare function parseLineRanges(sel: string, bare?: BareLineMode): [LineRange, ...LineRange[]] | null;
+/**
+ * Sort non-empty `ranges` by start line and merge the ones that overlap or touch;
+ * an open-ended range (`endLine` undefined) reaches EOF and absorbs every later one.
+ */
+export declare function mergeLineRanges(ranges: readonly LineRange[]): [LineRange, ...LineRange[]];
 /**
  * Extract the line-range component from a read-tool selector that may also
  * carry a verbatim/index display mode (`raw`, `conflicts`) — alone or compounded

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

@@ -63,6 +63,27 @@ export interface MCPResourceContent {
 }
 /** Supported MCP result content blocks retained in display metadata. */
 export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
+/** Server-reported progress of an in-flight MCP request. */
+export interface MCPProgress {
+    progress: number;
+    total?: number;
+    message?: string;
+}
+/**
+ * Read MCP progress fields from an untrusted record: `progress` must be a
+ * finite number; `total` is kept only when finite and `message` only when a
+ * string. Shared by the transports, the Eval bridge, and the status renderer.
+ */
+export declare function parseMCPProgress(value: unknown): MCPProgress | undefined;
+/**
+ * One-line display text for MCP progress, at most `maxWidth` cells: the
+ * message, with `progress/total` when the server reports a total. The bare
+ * progress value appears only when there is no message: without a total it is
+ * an opaque counter, not a percentage. Home paths in the message show as `~`,
+ * and a long message is cut before the count, so the count stays visible.
+ * Every progress display (tool card and both Eval status renderers) uses it.
+ */
+export declare function formatMCPProgress(progress: MCPProgress, maxWidth?: number): string;
 /** MCP result details shared by renderers and programmatic tool consumers. */
 export interface MCPToolDetails {
     /** Server name */
@@ -81,6 +102,8 @@ export interface MCPToolDetails {
     provider?: string;
     /** Provider display name (e.g., "Claude Code", "MCP Config") */
     providerName?: string;
+    /** Latest progress of a running call; present only on partial updates. */
+    progress?: MCPProgress;
     /** Structured output metadata (set by the spill wrapper when output is truncated to an artifact). */
     meta?: OutputMeta;
 }

package/dist/types/tools/output-meta.d.ts

@@ -110,7 +110,7 @@ export interface OutputMeta {
     /** Capture failure of this output itself; aggregate reports keep source failures on their entries. */
     artifactError?: OutputArtifactError;
     source?: SourceMeta;
-    /** The output is a bounded page of session artifact storage its `source` re-reads with line selectors; spill-to-artifact skips it. */
+    /** The output is a bounded page of a file or session artifact its `source` re-reads with line selectors; spill-to-artifact skips it. */
     pagedSource?: true;
     diagnostics?: DiagnosticMeta;
     limits?: LimitsMeta;

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

@@ -71,8 +71,14 @@ export interface ReadToolDetails {
      */
     displayReadTargetLinks?: Array<string | null>;
 }
-/** Split a filesystem path from its trailing read selector. */
-export declare function splitPathAndSel(rawPath: string): {
+/**
+ * Split a filesystem path from its trailing read selector. `foldListColons: false`
+ * keeps a colon repeated inside a list as part of the path (`a:1-30,:-30` peels
+ * only `:-30`), for callers checking whether that shorter split names a real file.
+ */
+export declare function splitPathAndSel(rawPath: string, options?: {
+    foldListColons?: boolean;
+}): {
     path: string;
     sel?: string;
 };

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

@@ -27,8 +27,9 @@ export interface RenderResultOptions {
     executionStarted?: boolean;
     /**
      * Milliseconds since this call began executing (`tool_execution_start`),
-     * or its total once settled; undefined before it starts. Native describe
-     * hooks only.
+     * or its total once settled; undefined before it starts. The terminal
+     * transcript's options object computes it on read, so a render-time read
+     * is live while the block's spinner ticks.
      */
     elapsedMs?: number;
     /** The call was abandoned without a final result (turn aborted, sealed). Native describe hooks only. */
@@ -177,6 +178,11 @@ export interface ToolRenderer<TArgs = unknown, TDetails = unknown> {
      * `options.spinnerFrame`.
      */
     animatedPartialResult?: boolean | ((args: TArgs) => boolean);
+    /**
+     * Repaint the block once a second while its call executes, for renderers
+     * that show live `options.elapsedMs` without consuming the spinner frame.
+     */
+    tickElapsed?: boolean;
     /**
      * Whether replacing a pending call render with the first result requires a
      * full viewport repaint. Use for merged renderers whose pending rows can be

package/dist/types/tools/result-card.d.ts

@@ -16,5 +16,5 @@ export interface CardToolResult {
 export declare function firstText(result: CardToolResult): string;
 /** Sanitize one display line: tabs become spaces, carriage returns are dropped. */
 export declare function safe(value: string): string;
-/** Padded card whose lines are sanitized and truncated, re-rendered when the expanded state flips. */
+/** Card whose lines are sanitized and truncated, re-rendered when the expanded state flips. */
 export declare function card(lines: (width: number, expanded: boolean) => string[], options: RenderResultOptions): Component;

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

@@ -261,6 +261,7 @@ export declare class OutputSink {
      * Replace the in-memory buffer with the given text. Used when an upstream
      * minimizer rewrites the captured output after the raw bytes have already
      * been streamed.
+     * The replacement is held to the per-line column cap like streamed output.
      *
      * After this call the buffer is authoritative: streaming counters realign
      * to the replacement, the retained head window is cleared, and head

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

@@ -264,6 +264,18 @@ export interface AgentProgress {
     advisor?: boolean;
     /** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbe` side request. */
     completionPercent?: number;
+    /**
+     * The agent's current step in its own words (one line, ≤ 80 chars), from the
+     * same probe reply as {@link completionPercent}. Running rows prefer it over
+     * `lastIntent`; the job widget uses it as its stage line.
+     */
+    stage?: string;
+    /**
+     * What the agent says shows its progress live (one line, ≤ 200 chars), e.g.
+     * "BENCH lines in bg_2 pipe:1, tok_s higher is better, target 70% of roofline";
+     * from the probe reply. Feeds the job widget author's brief; never rendered.
+     */
+    watch?: string;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**

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

@@ -3,6 +3,7 @@ import type { Theme } from "../theme/theme.js";
 import { type OutputMeta } from "./output-meta.js";
 import { type ConfiguredThinkingLevel } from "../render/render-utils.js";
 import type { StructuredSubagentOutput } from "./task.js";
+import { type JobWidgetView } from "./job-widget.js";
 import type { RenderResultOptions, ToolActivitySummary } from "./renderer.js";
 import type { IrcDeliveryReceipt, IrcMessage } from "./irc.js";
 import type { NativeToolView, ToolRenderResult } from "./renderer.js";
@@ -29,6 +30,10 @@ export interface JobSnapshot {
     advisor?: boolean;
     /** The task agent's latest self-estimated completion (0–100); see `AgentProgress.completionPercent`. */
     completionPercent?: number;
+    /** The task agent's latest stage in its own words; see `AgentProgress.stage`. */
+    stage?: string;
+    /** The job's live widget, while one is being drawn; frozen at its last state once the job settles. */
+    widget?: JobWidgetView;
     resultText?: string;
     errorText?: string;
     /** Source-output metadata retained for per-job warnings and persisted row rendering. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-tui",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Linxira-OS",
@@ -38,14 +38,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@linxiraos/pi-omptype": "1.4.0",
-		"@linxiraos/pi-agent-core": "1.4.0",
-		"@linxiraos/pi-ai": "1.4.0",
-		"@linxiraos/pi-catalog": "1.4.0",
-		"@linxiraos/pi-natives": "1.4.0",
-		"@linxiraos/pi-utils": "1.4.0",
-		"@linxiraos/pi-wire": "1.4.0",
-		"@linxiraos/pi-snapcompact": "1.4.0"
+		"@linxiraos/pi-omptype": "1.4.1",
+		"@linxiraos/pi-agent-core": "1.4.1",
+		"@linxiraos/pi-ai": "1.4.1",
+		"@linxiraos/pi-catalog": "1.4.1",
+		"@linxiraos/pi-natives": "1.4.1",
+		"@linxiraos/pi-utils": "1.4.1",
+		"@linxiraos/pi-wire": "1.4.1",
+		"@linxiraos/pi-snapcompact": "1.4.1"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"