@oh-my-pi/pi-tui 18.12.2 → 18.12.3

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [18.12.3] - 2026-10-19
+
+### Added
+
+- Added `IrcMessage.broadcast`, set on each copy of an `agent://all` broadcast so recipients can tell it from a direct message ([#16312](https://github.com/can1357/oh-my-pi/pull/16312) by [@will-bogusz](https://github.com/will-bogusz))
+- `AutocompleteItem.descriptionMatch` marks a slash command matched only through its description; `Editor` Enter no longer applies such a row unless the user moved the selection onto it ([#16265](https://github.com/can1357/oh-my-pi/issues/16265))
+- `ApprovalDialogComponent` accepts `grants` and `onGrant`: grant choices above **Approve Once**, led by a toggle that keeps them across sessions ([#16049](https://github.com/can1357/oh-my-pi/pull/16049) by [@Peribunt](https://github.com/Peribunt))
+- Added `describeJobWidget`/`renderJobWidgetLines` to draw a background job's widget natively and as terminal lines, `describeJobTiles`/`renderJobTileLines` to draw jobs as tiles (status, title, figure, widget), and `renderSparkline` (with `peakBuckets`/`fitSparkValues`) for one-row block sparklines
+
+### Fixed
+
+- Fixed transparent images with empty top rows disappearing inside Zellij ([#16346](https://github.com/can1357/oh-my-pi/pull/16346) by [@Bouska](https://github.com/Bouska))
+- Fixed bash output rewritten by the output minimizer skipping the per-line column cap (`tools.outputMaxColumns`), so a line wider than the cap reached the model whole; the raw output stays in its artifact ([#16314](https://github.com/can1357/oh-my-pi/pull/16314) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed the composer caret drifting one cell left per pasted image or video chip in terminals that draw the chip icon as a wide emoji (JetBrains terminal); the `unicode` preset now uses `📷`/`🎬` chip icons ([#16270](https://github.com/can1357/oh-my-pi/issues/16270))
+- Fixed Tern hiding user text sent with `/skill:<name>` inside a collapsed skill card; only the loaded skill prompt is hidden ([#16311](https://github.com/can1357/oh-my-pi/issues/16311))
+- Fixed SIXEL charts and images overlapping following content when their top rows scroll out of the viewport ([#16245](https://github.com/can1357/oh-my-pi/pull/16245) by [@JustasMasiulis](https://github.com/JustasMasiulis)).
+
 ## [18.12.2] - 2026-10-18
 
 ### Added

package/dist/types/autocomplete.d.ts

@@ -39,6 +39,12 @@ export interface AutocompleteItem {
     state?: string;
     /** Dim hint text shown inline after cursor when this item is selected */
     hint?: string;
+    /**
+     * Slash command matched only through its description, not its name or an alias:
+     * a browse hit, so Enter submits the typed text instead of running it unless the
+     * user moved the selection onto it.
+     */
+    descriptionMatch?: boolean;
 }
 type Awaitable<T> = T | Promise<T>;
 export interface SlashCommand {

package/dist/types/chat/skill-message.d.ts

@@ -20,10 +20,9 @@ export declare class SkillMessageComponent extends Container {
     setExpanded(expanded: boolean): void;
     handleNativeEvent(event: NativeUiEvent): void;
     /**
-     * A user-toned card (role `omp.skill`): the skill chip (linked to its
-     * SKILL.md) and prompt size in the head, the user's draft as markdown, and
-     * the loaded skill prompt, described only while expanded because it can
-     * be large.
+     * A user-toned card (role `omp.skill`): the skill chip and prompt size in
+     * the head, the user's draft always visible, and only the loaded skill
+     * prompt behind a disclosure.
      */
     describe(): NativeNode;
     /**

package/dist/types/components/sparkline.d.ts

@@ -0,0 +1,34 @@
+/**
+ * One-row block sparklines (`▁▂▃▅▇█`) for ANSI renderers: the usage history
+ * in `omp usage`, a job widget's series in the `wait` card and status line.
+ */
+/** Block glyphs from lowest to highest. */
+export declare const SPARK_LEVELS: readonly ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+/** How {@link renderSparkline} maps values to glyphs and styles them. */
+export interface SparklineOptions {
+    /** Domain low end; values at or below it draw the lowest block. Default 0. */
+    readonly min?: number;
+    /** Domain high end; values at or above it draw the full block. Default the largest value. */
+    readonly max?: number;
+    /** Styles one glyph; `fraction` is the value's 0–1 position in the domain. */
+    readonly style?: (glyph: string, value: number, fraction: number) => string;
+    /** What a missing value draws, already styled. Default a space. */
+    readonly gap?: string;
+}
+/** The block glyph for a 0–1 fraction of the domain. */
+export declare function sparkGlyph(fraction: number): string;
+/** One cell per value, oldest first; `undefined` (and non-finite) values draw the gap. */
+export declare function renderSparkline(values: readonly (number | undefined)[], options?: SparklineOptions): string;
+/**
+ * `values` squeezed into at most `cells` points by equal-count bucket means,
+ * newest bucket last; shorter series come back unchanged.
+ */
+export declare function fitSparkValues(values: readonly number[], cells: number): readonly number[];
+/**
+ * The largest value per time bucket over `[sinceMs, nowMs]`, `cells` buckets
+ * wide; buckets without a point are `undefined` (a gap in the sparkline).
+ */
+export declare function peakBuckets(points: Iterable<{
+    readonly at: number;
+    readonly value: number;
+}>, sinceMs: number, nowMs: number, cells: number): (number | undefined)[];

package/dist/types/index.d.ts

@@ -24,6 +24,7 @@ export * from "./components/section.js";
 export * from "./components/select-list.js";
 export * from "./components/settings-list.js";
 export * from "./components/spacer.js";
+export * from "./components/sparkline.js";
 export * from "./components/tab-bar.js";
 export * from "./components/table.js";
 export * from "./components/text.js";

package/dist/types/native/describe.d.ts

@@ -9,7 +9,7 @@
  *   ]);
  * }
  */
-import type { TspKind, TspProps, TspSpan, TspText } from "@oh-my-pi/pi-wire";
+import type { TspKind, TspPropNode, TspProps, TspSpan, TspText } from "@oh-my-pi/pi-wire";
 import type { NativeChild, NativeNode } from "./node.js";
 /** A node of any kind. */
 export declare function node<K extends TspKind>(k: K, p?: TspProps<K>, c?: readonly NativeChild[], key?: string): NativeNode;
@@ -37,6 +37,12 @@ export declare const EMPTY_NODE: NativeNode;
 export declare function keyed(described: NativeNode, key: string): NativeNode;
 /** `described` mounted but not laid out when `hidden` (cheap visibility toggles keep ids and view state). */
 export declare function withHidden(described: NativeNode, hidden: boolean): NativeNode;
+/**
+ * A described tree as the node tree a prop carries (a `hovercard`): plain
+ * nodes only, since nothing reconciles inside a prop; component children
+ * (which describe themselves per frame) are left out.
+ */
+export declare function propNode(described: NativeNode): TspPropNode;
 /** Stable node key for an arbitrary identity string; keys join into `/` keypaths, so identities are hashed. */
 export declare function stableKey(identity: string): string;
 /** Drop absent entries (`undefined`, `null`, `false`) from a child list. */

package/dist/types/native/tone.d.ts

@@ -17,6 +17,8 @@ export interface BackgroundChrome {
 }
 /** Map an omp background token to card tone/role. */
 export declare function backgroundChrome(bg: ThemeBg | undefined): BackgroundChrome;
+/** The omp theme colour an ANSI renderer draws a TSP tone with (the inverse of {@link colorTone}). */
+export declare function toneColor(tone: TspTone): ThemeColor;
 /**
  * Tone of an omp colour used as a severity or border colour; undefined for
  * colours that carry no tone (callers pick their own fallback).

package/dist/types/overlays/agent-hub.d.ts

@@ -5,11 +5,11 @@
  * - Table view: every registered agent except Main (Main IS the ambient
  *   chat), live from the global AgentHubRegistry — status, unread irc count,
  *   current/last task, last activity. Navigate with keys, wheel, hover, and
- *   click; `r` revives a parked agent, `x` aborts + releases one.
+ *   click; `r` revives a parked or killed agent, `x` aborts + releases one.
  * - Chat view: per-agent transcript (incremental session-file tail, absorbed
  *   from the old session observer overlay) plus an input line. Submitting
- *   revives a parked agent, then prompts/steers it; the message lands in the
- *   agent's persisted history via the normal prompt path.
+ *   revives a parked or killed agent, then prompts/steers it; the message
+ *   lands in the agent's persisted history via the normal prompt path.
  *
  * Replaces the old SessionObserverOverlayComponent (ctrl+s observer).
  */

package/dist/types/overlays/approval-dialog.d.ts

@@ -1,7 +1,8 @@
 /**
  * Tool-approval prompt in the composer's place, presented like the ask
  * dialog: the approval title and its details over a list of choices —
- * Approve, an optional "approve for this session", and Deny — and an action
+ * optional grants (led by a toggle that keeps them across sessions), Approve,
+ * an optional "approve for this session", and Deny — and an action
  * bar. The arrows move between the choices and Enter takes the highlighted
  * one; `app.approval.approve` (Ctrl+Enter by default) approves this call
  * outright and Esc denies. Enter and the approve chord only arm
@@ -23,6 +24,13 @@ interface ApprovalDialogCallbacks {
     onApprove(): void;
     onDeny(): void;
 }
+/** A choice that approves the call and remembers more than it: a folder, or the exact target. */
+export interface ApprovalDialogGrant {
+    /** Label while the grant is remembered for this session. */
+    readonly label: string;
+    /** Label once the remember toggle keeps it across sessions. */
+    readonly alwaysLabel: string;
+}
 /** The composer mounted beneath the dialog: it receives every key the dialog does not own. */
 export interface ApprovalDialogDraft {
     /** True while the composer holds a draft — text, attachments, or a paste still landing: keys then edit and send it. */
@@ -48,6 +56,12 @@ interface ApprovalDialogOptions {
         label: string;
         onApprove(): void;
     };
+    /**
+     * Grants to offer above Approve, led by a toggle that keeps them across sessions; Approve then
+     * reads "Approve Once". `onGrant` gets the chosen grant and whether the toggle was on.
+     */
+    grants?: readonly ApprovalDialogGrant[];
+    onGrant?(grant: ApprovalDialogGrant, always: boolean): void;
 }
 export declare class ApprovalDialogComponent implements Component {
     #private;

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 "@oh-my-pi/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/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 "@oh-my-pi/pi-agent-core";
 import type { Tool, UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
 import type { Model } from "@oh-my-pi/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/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 "@oh-my-pi/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 `omp.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 `omp.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 `omp.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/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/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

@@ -265,6 +265,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": "@oh-my-pi/pi-tui",
-	"version": "18.12.2",
+	"version": "18.12.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.12.2",
-		"@oh-my-pi/pi-agent-core": "18.12.2",
-		"@oh-my-pi/pi-ai": "18.12.2",
-		"@oh-my-pi/pi-catalog": "18.12.2",
-		"@oh-my-pi/pi-natives": "18.12.2",
-		"@oh-my-pi/pi-utils": "18.12.2",
-		"@oh-my-pi/pi-wire": "18.12.2",
-		"@oh-my-pi/snapcompact": "18.12.2"
+		"@oh-my-pi/omptype": "18.12.3",
+		"@oh-my-pi/pi-agent-core": "18.12.3",
+		"@oh-my-pi/pi-ai": "18.12.3",
+		"@oh-my-pi/pi-catalog": "18.12.3",
+		"@oh-my-pi/pi-natives": "18.12.3",
+		"@oh-my-pi/pi-utils": "18.12.3",
+		"@oh-my-pi/pi-wire": "18.12.3",
+		"@oh-my-pi/snapcompact": "18.12.3"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/autocomplete.ts

@@ -226,6 +226,12 @@ export interface AutocompleteItem {
 	state?: string;
 	/** Dim hint text shown inline after cursor when this item is selected */
 	hint?: string;
+	/**
+	 * Slash command matched only through its description, not its name or an alias:
+	 * a browse hit, so Enter submits the typed text instead of running it unless the
+	 * user moved the selection onto it.
+	 */
+	descriptionMatch?: boolean;
 }
 
 type Awaitable<T> = T | Promise<T>;
@@ -437,6 +443,7 @@ function buildSlashCommandCompletions(
 						...(cmd.iconName && { iconName: cmd.iconName }),
 						...(fullDesc && { description: fullDesc }),
 						...nativeTextMemo,
+						...(nameScore === 0 && { descriptionMatch: true }),
 					};
 				}
 
@@ -444,7 +451,11 @@ function buildSlashCommandCompletions(
 					for (const alias of getCommandAliases(cmd)) {
 						if (alias === name) continue;
 						const aliasScore = scoreCommandTextMatch(lowerPrefix, alias.toLowerCase());
-						if (aliasScore === 0 || (best && aliasScore <= best.score)) continue;
+						if (aliasScore === 0) continue;
+						// An alias can match even when the description outranks it; Enter
+						// must still accept the command rather than submit the raw query.
+						if (best?.descriptionMatch) delete best.descriptionMatch;
+						if (best && aliasScore <= best.score) continue;
 						const fullDesc = resolveFullDesc();
 						best = {
 							value: alias,