pantheon-opencode 1.6.0-beta.3 → 1.6.0-beta.4

package/src/plugins/tui/dist/tui.d.ts

@@ -1,6 +1,6 @@
 import { TuiPluginModule } from "@opencode-ai/plugin/tui";
 //#region src/index.d.ts
-type DelegationEntry = {
+export type DelegationEntry = {
   /** Job alias, e.g. "apo-1" (from the H1 title, falling back to filename). */
   alias: string;
   /** Parent session the job was launched from (dir name under .pantheon/delegations). */
@@ -34,13 +34,13 @@ type DelegationEntry = {
  *  Linear, single-pass over `raw.split('\n')` with plain string operations
  *  (startsWith/indexOf/slice) — zero regex, so worst case is O(bytes) even
  *  on adversarial whitespace-heavy input (ReDoS regression, CodeQL 12x HIGH). */
-declare function parseDelegationMarkdown(raw: string, fileAlias?: string, sessionID?: string): DelegationEntry | null;
+export declare function parseDelegationMarkdown(raw: string, fileAlias?: string, sessionID?: string): DelegationEntry | null;
 /** Read every delegation report under `<dir>/<sessionID>/<alias>.md`.
  *  Fail-open: a missing/unreadable directory yields [], and each unreadable
  *  or malformed file is skipped individually. Entries are sorted running
  *  first, then terminal by `updatedAt` (most recent first) so the panel can
  *  render them in order directly. */
-declare function readDelegationEntries(dir: string): Promise<DelegationEntry[]>;
+export declare function readDelegationEntries(dir: string): Promise<DelegationEntry[]>;
 /** Read delegation reports from EVERY session under
  *  `<root>/.pantheon/delegations/<sessionID>/<alias>.md` — the panel's
  *  ENRICHMENT source. The read is deliberately unfiltered (each entry carries
@@ -49,21 +49,21 @@ declare function readDelegationEntries(dir: string): Promise<DelegationEntry[]>;
  *  before rendering — only the active session's reports are shown. Entries are
  *  running first, Finalized desc (the sort applied by readDelegationEntries).
  *  Fail-open: a missing/unreadable directory yields []. */
-declare function readAllDelegationEntries(root: string): Promise<DelegationEntry[]>;
+export declare function readAllDelegationEntries(root: string): Promise<DelegationEntry[]>;
 /** Resolve the PROJECT ROOT used by every pantheon file channel. `directory`
  *  wins over `worktree` (the old `resolveDelegationsDir` already did this);
  *  an absent/empty root or `/` (no git — e.g. the sandbox test project) falls
  *  back to cwd. Standardised here so the delegations md and the panel logger
  *  all read the SAME root (audit finding: the channels
  *  resolved the root independently). Pure — no I/O. */
-declare function resolvePantheonRoot(state: {
+export declare function resolvePantheonRoot(state: {
   directory?: string;
   worktree?: string;
 } | undefined, cwd?: string): string;
 /** Resolve the directory where delegation md reports are written.
  *  The finalizer writes `.pantheon/delegations` RELATIVE to the server cwd,
  *  which the TUI exposes as `TuiState.path.directory`. */
-declare function resolveDelegationsDir(state: {
+export declare function resolveDelegationsDir(state: {
   directory?: string;
   worktree?: string;
 } | undefined, cwd?: string): string;
@@ -72,36 +72,36 @@ declare function resolveDelegationsDir(state: {
  *  the delegations dir (or its dirname) directly made createTuiLogger append
  *  to `<root>/.pantheon/.pantheon/logs/hooks.log`, a nested empty dir the real
  *  log never saw. Pure — no I/O. */
-declare function panelLogDir(delegationsDir: string): string;
+export declare function panelLogDir(delegationsDir: string): string;
 /** Where the panel logger appends lines: `<projectRoot>/.pantheon/logs/hooks.log`.
  *  Pure — testable without the runtime. */
-declare function tuiLogPath(projectRoot: string): string;
+export declare function tuiLogPath(projectRoot: string): string;
 /** Sort delegations: running first, then terminal by recency (updatedAt,
  *  falling back to startedAt, descending). Shared by the md reader and
  *  mergeDelegationSources. */
-declare function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry): number;
+export declare function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry): number;
 /** Split the panel list: active jobs (running/retry, stale-marked) first,
  *  then the most recent terminal reports; the remaining tail is collapsed
  *  by the View into a single "… +N more" line. Pure — so the history-only panel (no sessionID) is testable
  *  without the TUI runtime. */
-declare function splitDelegationList(all: readonly DelegationEntry[], maxRecent?: number, now?: number, staleThresholdMs?: number): {
+export declare function splitDelegationList(all: readonly DelegationEntry[], maxRecent?: number, now?: number, staleThresholdMs?: number): {
   active: DelegationEntry[];
   recent: DelegationEntry[];
 };
 /** Live-first window used by {@link ceilingDelegationList} (kept for the
  *  ceiling helper and existing tests): active jobs first, then the most
  *  recent terminal reports (capped). Pure. */
-declare function visibleDelegationList(all: readonly DelegationEntry[], maxTerminal?: number, now?: number, staleThresholdMs?: number): DelegationEntry[];
+export declare function visibleDelegationList(all: readonly DelegationEntry[], maxTerminal?: number, now?: number, staleThresholdMs?: number): DelegationEntry[];
 /** Default stale-running threshold: 30 minutes. */
-declare const STALE_RUNNING_THRESHOLD_MS: number;
+export declare const STALE_RUNNING_THRESHOLD_MS: number;
 /** Idle silence window: if no updatedAt change in this window, the entry is
  *  considered stale. Combined with the stale-running threshold to produce the
  *  display-only `stale-running` state. */
-declare const IDLE_SILENCE_MS: number;
+export declare const IDLE_SILENCE_MS: number;
 /** Visual-only terminal retention windows. Reports remain on disk; these
  *  constants only control which rows enter the TUI window. */
-declare const DELEGATION_DONE_RETENTION_MS: number;
-declare const DELEGATION_FAILED_RETENTION_MS: number;
+export declare const DELEGATION_DONE_RETENTION_MS: number;
+export declare const DELEGATION_FAILED_RETENTION_MS: number;
 /** Grace window for an ABSENT child status. `api.state.session.status()` only
  *  carries the sessions that are currently ALIVE; every finished child of a
  *  long-lived session is missing from that map. A child with no status is
@@ -111,7 +111,7 @@ declare const DELEGATION_FAILED_RETENTION_MS: number;
  *  has not been registered by the status API yet: within this window of its
  *  last activity (`time.updated`, falling back to `time.created`) it still
  *  reads as running. */
-declare const DELEGATION_CHILD_STATUS_GRACE_MS: number;
+export declare const DELEGATION_CHILD_STATUS_GRACE_MS: number;
 /** Recency window for the children channel. `session.children` returns EVERY
  *  child the focused session ever spawned, so a long session accumulates
  *  hundreds of historical rows that would inflate the panel. A child whose
@@ -119,12 +119,12 @@ declare const DELEGATION_CHILD_STATUS_GRACE_MS: number;
  *  is older than this window is dropped BEFORE it can enter the list. 24h
  *  keeps the sidebar scoped to current work while still covering long
  *  delegations. A child with no timestamp at all is kept (fail-open). */
-declare const DELEGATION_CHILDREN_RECENCY_MS: number;
+export declare const DELEGATION_CHILDREN_RECENCY_MS: number;
 /** Alias-less NATIVE task() live entries never receive a report alias (the
  *  task tool output carries none), so the 30s alias-less prune in
  *  mergeChildDelegationSources must not apply to them — 5 minutes covers a
  *  slow child listing while still bounding the live map. */
-declare const NATIVE_LIVE_ALIASLESS_TTL_MS: number;
+export declare const NATIVE_LIVE_ALIASLESS_TTL_MS: number;
 /**
  * Mark a running entry as `stale-running` if it has been running longer than
  * the threshold AND has no recent activity (no `updatedAt` change in the last
@@ -133,40 +133,40 @@ declare const NATIVE_LIVE_ALIASLESS_TTL_MS: number;
  * A `stale-running` entry renders with a warning indicator but the underlying
  * delegation is still treated as running by the backend.
  */
-declare function markStaleIfRunning(entry: DelegationEntry, now: number, thresholdMs?: number): DelegationEntry;
+export declare function markStaleIfRunning(entry: DelegationEntry, now: number, thresholdMs?: number): DelegationEntry;
 /** Compact elapsed-time label, single unit only: "12s"/"3m"/"1h"/"2d" — ticks every
  *  second for running jobs. */
-declare function fmtElapsed(ms: number): string;
+export declare function fmtElapsed(ms: number): string;
 /** Elapsed label for one entry: an ACTIVE entry (running/retry/stale-running)
  *  ticks `now - startedAt`; a terminal one is fixed at
  *  `updatedAt - startedAt` (em dash when no finalized timestamp). */
-declare function delegationElapsed(entry: DelegationEntry, now: number): string;
+export declare function delegationElapsed(entry: DelegationEntry, now: number): string;
 /** The activity labels shown by the animated row. Keeping this pure makes the
  * state machine testable without booting OpenCode's renderer. */
-type DelegationActivity = 'delegating' | 'working' | 'completed' | 'error' | 'cancelled';
-declare function delegationActivity(entry: DelegationEntry): DelegationActivity;
-declare function delegationActivityLabel(entry: DelegationEntry): string;
+export type DelegationActivity = 'delegating' | 'working' | 'completed' | 'error' | 'cancelled';
+export declare function delegationActivity(entry: DelegationEntry): DelegationActivity;
+export declare function delegationActivityLabel(entry: DelegationEntry): string;
 /** Return the spinner glyph for the given frame counter. The frame counter
  *  is incremented every ~80ms by a dedicated animation timer, decoupled from
  *  the data poll cycle. Pure — no side effects. */
-declare function delegationSpinnerFrame(frame: number): string;
+export declare function delegationSpinnerFrame(frame: number): string;
 /** Every state the row knows how to draw: the delegation lifecycle states
  *  derived from the children status + md reports (`completed`, `error`,
  *  `cancelled`, `startup_failed`, `startup_unknown`) plus the TUI-only
  *  states (`retry`, `stale-running`). Fase 1 deliberately omits speculative
  *  blocked/paused/scheduled/skipped. There is no `pending` display state: a
  *  pre-dispatch tool part maps to `running` in {@link reduceDelegationToolPart}. */
-type DelegationDisplayState = DelegationEntry['state'];
+export type DelegationDisplayState = DelegationEntry['state'];
 /** Semantic tone mapped to the TUI theme at the row ({@link DelegationRow}).
  *  Kept separate + pure so the color channel is testable without booting the
  *  renderer. Every display state resolves to one of the three status colors;
  *  the row paints its whole content with it (see {@link DelegationRow}). */
-type DelegationStateTone = 'warning' | 'error' | 'success';
+export type DelegationStateTone = 'warning' | 'error' | 'success';
 /** Status → color mapping for the whole-row tone. Red = failure, green =
  *  terminal, yellow = in flight. The glyph remains a redundant channel so the
  *  state stays legible in monochrome. Display-only; no behavior change. */
-declare function delegationStateTone(state: DelegationDisplayState): DelegationStateTone;
-type ToolActivity = {
+export declare function delegationStateTone(state: DelegationDisplayState): DelegationStateTone;
+export type ToolActivity = {
   tool: string;
   summary: string;
   at: number;
@@ -174,7 +174,7 @@ type ToolActivity = {
 /** Reduce one message.part.updated tool part to displayable activity.
  *  Returns null for non-tool parts, completed/error parts (no live activity)
  *  or parts without a session id. Pure. */
-declare function extractToolActivity(part: {
+export declare function extractToolActivity(part: {
   type?: string;
   tool?: string;
   sessionID?: string;
@@ -187,18 +187,18 @@ declare function extractToolActivity(part: {
   activity: ToolActivity;
 } | null;
 /** Record an activity sample (bounded map, oldest dropped). */
-declare function trackToolActivity(map: Map<string, ToolActivity>, sessionID: string, activity: ToolActivity): void;
+export declare function trackToolActivity(map: Map<string, ToolActivity>, sessionID: string, activity: ToolActivity): void;
 /** Latest live activity for a child session, or null when absent/stale. */
-declare function latestToolActivityFor(map: Map<string, ToolActivity>, sessionID: string | undefined, now?: number, ttlMs?: number): ToolActivity | null;
+export declare function latestToolActivityFor(map: Map<string, ToolActivity>, sessionID: string | undefined, now?: number, ttlMs?: number): ToolActivity | null;
 /** Merge the immediate tool-event channel into the child-session channel.
  *
  * Children remain the durable source, while live entries make a delegation
  * visible before the child API/report catches up. A finalized md entry wins
  * over a stale live entry; a child-only row is upgraded with live agent,
  * alias, phase and timestamps. */
-declare function mergeChildDelegationSources(children: readonly DelegationEntry[], live: readonly LiveDelegationEntry[]): DelegationEntry[];
+export declare function mergeChildDelegationSources(children: readonly DelegationEntry[], live: readonly LiveDelegationEntry[]): DelegationEntry[];
 /** Duck-typed subset of a tool part (SDK v2 `ToolPart` / `ToolState`). */
-type DelegationToolPart = {
+export type DelegationToolPart = {
   id?: string;
   callID?: string;
   sessionID?: string;
@@ -216,7 +216,7 @@ type DelegationToolPart = {
   };
 };
 /** One live delegation tracked in-memory, keyed by the task callID. */
-type LiveDelegationEntry = {
+export type LiveDelegationEntry = {
   /** Tool call id of the task part (stable across events). */
   callID: string;
   /** Part id (for message.part.removed cleanup). */
@@ -236,7 +236,7 @@ type LiveDelegationEntry = {
   updatedAt: number | null;
 };
 /** Result of parsing one tool part into lifecycle-relevant fields. */
-type ParsedDelegationToolPart = {
+export type ParsedDelegationToolPart = {
   callID: string;
   partID: string;
   sessionID: string;
@@ -254,13 +254,13 @@ type ParsedDelegationToolPart = {
  *  reduce it to what the panel needs. Returns null for anything that is
  *  not the native `task` subagent tool (parentID === caller mechanism —
  *  its children render `nat:`), or is missing its callID. */
-declare function parseDelegationToolPart(part: DelegationToolPart, now?: number): ParsedDelegationToolPart | null;
+export declare function parseDelegationToolPart(part: DelegationToolPart, now?: number): ParsedDelegationToolPart | null;
 /** Apply one tool part to the live map. Returns true when the map changed.
  *  Pure w.r.t. I/O — only mutates `map`. */
-declare function reduceDelegationToolPart(map: Map<string, LiveDelegationEntry>, part: DelegationToolPart, now?: number): boolean;
+export declare function reduceDelegationToolPart(map: Map<string, LiveDelegationEntry>, part: DelegationToolPart, now?: number): boolean;
 /** Remove a live entry by part id (message.part.removed) or call id.
  *  Returns true when something was removed. */
-declare function removeDelegationEntry(map: Map<string, LiveDelegationEntry>, partIDOrCallID: string): boolean;
+export declare function removeDelegationEntry(map: Map<string, LiveDelegationEntry>, partIDOrCallID: string): boolean;
 /** Collect native task tool parts from a session's messages.
  *  Messages may carry their parts inline (duck-typed `msg.parts`); when
  *  they don't, the optional `getParts(messageID)` callback is used (the TUI
@@ -269,7 +269,7 @@ declare function removeDelegationEntry(map: Map<string, LiveDelegationEntry>, pa
  *  the refresh signal (rows come from the children channel). Pure w.r.t.
  *  I/O — used by the mount re-scan to re-seed the live map after
  *  compaction/attach. */
-declare function collectDelegationToolParts(messages: readonly {
+export declare function collectDelegationToolParts(messages: readonly {
   id?: string;
   parts?: unknown[];
 }[] | undefined, getParts?: (messageID: string) => readonly unknown[] | undefined): DelegationToolPart[];
@@ -277,16 +277,16 @@ declare function collectDelegationToolParts(messages: readonly {
  *  mount to re-seed entries that `message.part.removed` (compaction) wiped,
  *  from the session's existing tool parts. Returns how many parts changed
  *  the map (0 on the second identical seed — idempotent, no extra bumps). */
-declare function seedLiveDelegationMap(map: Map<string, LiveDelegationEntry>, parts: readonly DelegationToolPart[], now?: number): number;
+export declare function seedLiveDelegationMap(map: Map<string, LiveDelegationEntry>, parts: readonly DelegationToolPart[], now?: number): number;
 /** Convert a live entry into the shared display shape. Alias falls back to
  *  a `live-<callID>` prefix while the task call has not completed yet. */
-declare function toDelegationEntry(live: LiveDelegationEntry): DelegationEntry;
+export declare function toDelegationEntry(live: LiveDelegationEntry): DelegationEntry;
 /** Combine the live channel with the md (historical) channel into one
  *  display list. Dedupes by (sessionID, alias) — aliases are per-parent-
  *  session, so the same alias in different sessions stays separate. A
  *  terminal md entry is authoritative over a live running entry for the
  *  same job (it carries Finalized/timedOut/cancelled from finalize). */
-declare function mergeDelegationSources(live: readonly LiveDelegationEntry[], md: readonly DelegationEntry[]): DelegationEntry[];
+export declare function mergeDelegationSources(live: readonly LiveDelegationEntry[], md: readonly DelegationEntry[]): DelegationEntry[];
 /** Scope a fully-merged display list to the ACTIVE session only.
  *
  *  The panel is session-scoped: rows from other sessions (md history under
@@ -303,7 +303,7 @@ declare function mergeDelegationSources(live: readonly LiveDelegationEntry[], md
  *  Returns [] when no active session resolves (null/placeholder) — there is no
  *  scope to show. Native children always carry the active session id (stamped
  *  by `childrenToDelegationEntries`), so they survive the filter. Pure. */
-declare function filterDelegationsToSession(entries: readonly DelegationEntry[], activeSessionID: string | null | undefined): DelegationEntry[];
+export declare function filterDelegationsToSession(entries: readonly DelegationEntry[], activeSessionID: string | null | undefined): DelegationEntry[];
 /** Server-aligned session id validity: opencode rejects anything not starting
  *  with "ses" (SchemaError). This deliberately mirrors that exact contract —
  *  nothing stricter, nothing looser — so a template placeholder ("{sessionID}"),
@@ -312,11 +312,11 @@ declare function filterDelegationsToSession(entries: readonly DelegationEntry[],
  *  never reach a path and error-spam the log. Confirmed: "{sessionID}" starts
  *  with "{" and "%7BsessionID%7D" with "%" — both fail startsWith("ses"), so
  *  the placeholder is rejected WITHOUT an explicit denylist (covered by tests). */
-declare function isValidSessionId(id: unknown): id is string;
+export declare function isValidSessionId(id: unknown): id is string;
 /** Sources the sidebar can resolve the CURRENT session id from. Duck-typed
  *  subsets of TuiPluginApi / TuiState / TuiRouteCurrent so the helper stays
  *  pure and testable without the TUI runtime. */
-type TuiSessionSources = {
+export type TuiSessionSources = {
   /** sidebar_content slot prop (`session_id`). */
   sessionID?: string | null;
   api?: {
@@ -338,7 +338,7 @@ type TuiSessionSources = {
  *  (typed route). Every source is validated; invalid/absent → next source.
  *  NEVER returns a placeholder or non-ses id. Null → callers MUST skip the
  *  fetch (empty panel, zero errors). Pure — no I/O, no runtime required. */
-declare function resolveCurrentSessionID(sources: TuiSessionSources): string | null;
+export declare function resolveCurrentSessionID(sources: TuiSessionSources): string | null;
 /** THE single choke point for every `session.children` / session-API path.
  *  Returns the v2 SDK parameter shape `{ sessionID }` ONLY for a
  *  server-valid session id; returns null for anything else (placeholder,
@@ -350,7 +350,7 @@ declare function resolveCurrentSessionID(sources: TuiSessionSources): string | n
  *  unsubstituted (`/session/%7BsessionID%7D/children`). Every session-API
  *  call site MUST go through this function (enforced by the source-scan
  *  test in tests/pantheon/tui-delegations.test.ts). */
-declare function safeSessionPath(id: unknown): {
+export declare function safeSessionPath(id: unknown): {
   sessionID: string;
 } | null;
 /** Build the `session.children` parameters ONLY from a validated session id.
@@ -358,11 +358,11 @@ declare function safeSessionPath(id: unknown): {
  *  the v2 SDK shape `{ sessionID }`; null for null/invalid ids so the caller
  *  skips the fetch instead of sending an unsubstituted placeholder (the
  *  "%7BsessionID%7D" regression). */
-declare function buildChildrenPath(id: string | null | undefined): {
+export declare function buildChildrenPath(id: string | null | undefined): {
   sessionID: string;
 } | null;
 /** Duck-typed subset of a child Session (+ its live status type). */
-type ChildDelegationLike = {
+export type ChildDelegationLike = {
   /** Child session id (= task id). */
   id: string;
   /** Session title — the delegate's description or prompt prefix. */
@@ -395,7 +395,7 @@ type ChildDelegationLike = {
  *  @param now     current wall-clock ms (injectable for tests)
  *  @param graceMs recency window for the absent-status running assumption
  *  Pure — no I/O. */
-declare function childStatusToState(status: string | undefined, time?: {
+export declare function childStatusToState(status: string | undefined, time?: {
   created?: number;
   updated?: number;
 }, now?: number, graceMs?: number): 'running' | 'completed' | 'retry';
@@ -405,58 +405,58 @@ declare function childStatusToState(status: string | undefined, time?: {
  *  `{glyph} {alias:7} {elapsed:>5}` plus a muted description line. The short
  *  alias (`apo-1`) is the single identity; rows without a report alias show
  *  the agent instead (never both). */
-type DelegationRowStatus = 'active' | 'done' | 'failed' | 'retry';
+export type DelegationRowStatus = 'active' | 'done' | 'failed' | 'retry';
 /** Map every FSM/display state to one of the 4 row kinds. reconciled never
  *  reaches the panel (the md parser drops it) but reads as done;
  *  cancelled reads as done; startup_failed reads as failed while
  *  startup_unknown (no error known) reads as retry. Pure. */
-declare function delegationRowStatus(state: DelegationDisplayState): DelegationRowStatus;
+export declare function delegationRowStatus(state: DelegationDisplayState): DelegationRowStatus;
 /** The only 4 glyphs a row may show: animated active, done, failed, retry.
  *  Shape is redundant with color (never the only signal). Pure. */
-declare const DELEGATION_ROW_GLYPHS: Readonly<Record<DelegationRowStatus, string>>;
-declare function delegationRowGlyph(status: DelegationRowStatus): string;
+export declare const DELEGATION_ROW_GLYPHS: Readonly<Record<DelegationRowStatus, string>>;
+export declare function delegationRowGlyph(status: DelegationRowStatus): string;
 /** Row marker (`<glyph> `) — the single state channel. `active` animates
  *  through the spinner for the given frame counter (incremented every ~80ms);
  *  every other kind is static. Pure. */
-declare function delegationRowMarker(state: DelegationDisplayState, frame?: number): string;
+export declare function delegationRowMarker(state: DelegationDisplayState, frame?: number): string;
 /** ONE identity per row: the short report alias (`apo-1`); a row without a
  *  report alias (native task() child `native-task` / `native-<id>`, or an
  *  alias-less native live row `live-<callID>` kept as children-only) shows
  *  the agent instead — never alias + agent stacked. Pure. */
-declare function delegationRowIdentity(entry: DelegationEntry): string;
+export declare function delegationRowIdentity(entry: DelegationEntry): string;
 /** Fixed alias cell, pad-right + hard-truncate to `width` (default 7) so
  *  identities line up across rows. Pure. */
-declare const DELEGATION_ALIAS_WIDTH = 7;
-declare function formatDelegationAlias(identity: string, width?: number): string;
+export declare const DELEGATION_ALIAS_WIDTH = 7;
+export declare function formatDelegationAlias(identity: string, width?: number): string;
 /** Max description width on the row detail line — the old 180-char slice
  *  wrapped the sidebar; 44 keeps one readable line. */
-declare const DELEGATION_DESCRIPTION_MAX = 44;
+export declare const DELEGATION_DESCRIPTION_MAX = 44;
 /** Truncate a description to `max` graphemes appending `…` when cut. Exact
  *  `max`-length text is left untouched. Grapheme-granular, so an emoji made of
  *  several code points is never split into mojibake at the boundary. Pure. */
-declare function truncateDelegationDescription(text: string, max?: number): string;
+export declare function truncateDelegationDescription(text: string, max?: number): string;
 /** Fixed elapsed-time box: right-aligned to `width` (default 5) so elapsed
  *  values line up across rows, e.g. `  12s`. A label that already fills
  *  the box is returned untouched. Pure. */
-declare const DELEGATION_ELAPSED_WIDTH = 5;
-declare function formatDelegationElapsed(entry: DelegationEntry, now: number, width?: number): string;
+export declare const DELEGATION_ELAPSED_WIDTH = 5;
+export declare function formatDelegationElapsed(entry: DelegationEntry, now: number, width?: number): string;
 /** Colored left half of a row line: `<marker><alias:7> ` — the state glyph
  *  plus the single identity, padded so the muted elapsed column aligns. The
  *  row renders this colored lead separately from the muted elapsed tail. Pure. */
-declare function formatDelegationRowLead(entry: DelegationEntry, marker: string): string;
+export declare function formatDelegationRowLead(entry: DelegationEntry, marker: string): string;
 /** Visible-row ceiling for the panel: the remainder collapses into a single
  *  "… +N more" line. Live rows render first, so a running job is never hidden
  *  by the cap. */
-declare const DELEGATION_VISIBLE_CEILING = 8;
+export declare const DELEGATION_VISIBLE_CEILING = 8;
 /** Header summary: `(N active · M done)` plus `· K failed` only when K > 0.
  *  Active counts running/retry AND display-only stale-running (a stale row is
  *  still a live job — it must never read as done); failed counts
  *  error/startup_failed; cancelled reads as done. Pure. */
-declare function formatDelegationHeader(entries: readonly DelegationEntry[]): string;
+export declare function formatDelegationHeader(entries: readonly DelegationEntry[]): string;
 /** Cap the panel: live rows first, then most-recent retained terminal rows, at
  *  most `maxVisible` total. Hidden counts describe the retained render list,
  *  not expired history. */
-declare function ceilingDelegationList(all: readonly DelegationEntry[], maxVisible?: number, now?: number): {
+export declare function ceilingDelegationList(all: readonly DelegationEntry[], maxVisible?: number, now?: number): {
   visible: DelegationEntry[];
   hidden: number;
   hiddenActive: number;
@@ -465,7 +465,7 @@ declare function ceilingDelegationList(all: readonly DelegationEntry[], maxVisib
 /** Split a display list into native task() rows vs pantheon report rows.
  *  Native = source 'children-only' (no delegate report); everything else counts
  *  as pantheon. Pure — powers the hooks.log line. */
-declare function countDelegationSources(entries: readonly DelegationEntry[]): {
+export declare function countDelegationSources(entries: readonly DelegationEntry[]): {
   native: number;
   pantheon: number;
   total: number;
@@ -473,25 +473,25 @@ declare function countDelegationSources(entries: readonly DelegationEntry[]): {
 /** Diagnostic hooks.log line for a panel re-fetch, with the children
  *  breakdown (pantheon = children WITH a delegate report, native = children
  *  WITHOUT one). Pure — the View logs the returned string verbatim. */
-declare function formatPanelLogLine(children: number, pantheon: number, native: number, md: number, events: number): string;
-declare function childrenToDelegationEntries(children: readonly ChildDelegationLike[] | undefined, md: readonly DelegationEntry[], now?: number, parentSessionID?: string): DelegationEntry[];
+export declare function formatPanelLogLine(children: number, pantheon: number, native: number, md: number, events: number): string;
+export declare function childrenToDelegationEntries(children: readonly ChildDelegationLike[] | undefined, md: readonly DelegationEntry[], now?: number, parentSessionID?: string): DelegationEntry[];
 /** Navigate the TUI to a child session (click/Enter on a delegation row).
  *  Returns false when the route API is unavailable or the target id is
  *  missing/placeholder — the row stays inert instead of crashing. Only a
  *  server-valid session id ("ses...") ever reaches the router, so an
  *  unsubstituted "{sessionID}" placeholder can never be routed. */
-declare function navigateToDelegationSession(route: {
+export declare function navigateToDelegationSession(route: {
   navigate?: (name: string, params?: Record<string, unknown>) => void | PromiseLike<void>;
 } | undefined, taskID: string | undefined): boolean;
 /** Build the mouse handler used by each delegation row. */
-declare function createDelegationRowOpenHandler(route: {
+export declare function createDelegationRowOpenHandler(route: {
   navigate?: (name: string, params?: Record<string, unknown>) => void | PromiseLike<void>;
 } | undefined, taskID: string | undefined): () => void;
 /** Plugin-level live delegation store shared with the event subscriptions
  *  in `tui()`: the map of live entries + a version signal bumped on every
  *  mutation. The View subscribes to the version (in an effect) to refresh the
  *  durable child list and also reads the map as an optimistic live source. */
-type LiveDelegationStore = {
+export type LiveDelegationStore = {
   map: Map<string, LiveDelegationEntry>;
   /** Reactive version getter — View reads it inside an effect to re-fetch. */
   version: () => number;
@@ -503,5 +503,5 @@ declare const plugin: TuiPluginModule & {
   setup: () => Promise<void>;
 };
 //#endregion
-export { ChildDelegationLike, DELEGATION_ALIAS_WIDTH, DELEGATION_CHILDREN_RECENCY_MS, DELEGATION_CHILD_STATUS_GRACE_MS, DELEGATION_DESCRIPTION_MAX, DELEGATION_DONE_RETENTION_MS, DELEGATION_ELAPSED_WIDTH, DELEGATION_FAILED_RETENTION_MS, DELEGATION_ROW_GLYPHS, DELEGATION_VISIBLE_CEILING, DelegationActivity, DelegationDisplayState, DelegationEntry, DelegationRowStatus, DelegationStateTone, DelegationToolPart, IDLE_SILENCE_MS, LiveDelegationEntry, LiveDelegationStore, NATIVE_LIVE_ALIASLESS_TTL_MS, ParsedDelegationToolPart, STALE_RUNNING_THRESHOLD_MS, ToolActivity, TuiSessionSources, buildChildrenPath, ceilingDelegationList, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, countDelegationSources, createDelegationRowOpenHandler, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationRowGlyph, delegationRowIdentity, delegationRowMarker, delegationRowStatus, delegationSpinnerFrame, delegationStateTone, extractToolActivity, filterDelegationsToSession, fmtElapsed, formatDelegationAlias, formatDelegationElapsed, formatDelegationHeader, formatDelegationRowLead, formatPanelLogLine, isValidSessionId, latestToolActivityFor, markStaleIfRunning, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, resolvePantheonRoot, safeSessionPath, seedLiveDelegationMap, splitDelegationList, toDelegationEntry, trackToolActivity, truncateDelegationDescription, tuiLogPath, visibleDelegationList };
+export { plugin as default };
 //# sourceMappingURL=tui.d.ts.map

package/src/plugins/tui/dist/tui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":"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"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":"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"}

package/src/plugins/tui/dist/tui.js

@@ -121,12 +121,14 @@ async function resolvePresetForTui(env, cwd) {
 }
 async function detectVersion(api) {
 	try {
-		const pkgContent = await readFile(fileURLToPath(new URL("../../package.json", import.meta.url)), "utf8");
+		const pkgUrl = new URL("../../package.json", import.meta.url);
+		const pkgContent = await readFile(fileURLToPath(pkgUrl), "utf8");
 		const pkg = JSON.parse(pkgContent);
 		if (pkg.version) return pkg.version;
 	} catch {}
 	try {
-		const pkgContent = await readFile(fileURLToPath(new URL("../../../../package.json", import.meta.url)), "utf8");
+		const pkgUrl = new URL("../../../../package.json", import.meta.url);
+		const pkgContent = await readFile(fileURLToPath(pkgUrl), "utf8");
 		const pkg = JSON.parse(pkgContent);
 		if (pkg.version) return pkg.version;
 	} catch {}
@@ -165,7 +167,7 @@ async function detectVersion(api) {
 			if (ver) return ver;
 		}
 	} catch {}
-	return "1.6.0-beta.3";
+	return "1.6.0-beta.4";
 }
 /**
 * usage-bar — AI subscription usage gauge for the opencode TUI.
@@ -763,10 +765,7 @@ function parseDelegationMarkdown(raw, fileAlias, sessionID = "") {
 			case "Started":
 				if (value !== "" && started === void 0) started = value;
 				break;
-			case "Finalized":
-				finalized = value;
-				break;
-			default: break;
+			case "Finalized": finalized = value;
 		}
 	}
 	const startedAt = started !== void 0 ? Date.parse(started) : NaN;
@@ -885,7 +884,7 @@ function compareDelegationEntries(a, b) {
 *  then the most recent terminal reports; the remaining tail is collapsed
 *  by the View into a single "… +N more" line. Pure — so the history-only panel (no sessionID) is testable
 *  without the TUI runtime. */
-function splitDelegationList(all, maxRecent = 8, now = Date.now(), staleThresholdMs = 1800 * 1e3) {
+function splitDelegationList(all, maxRecent = 8, now = Date.now(), staleThresholdMs = 18e5) {
 	const isActiveState = (st) => st === "running" || st === "retry" || st === "stale-running";
 	return {
 		active: all.filter((d) => isActiveState(d.state)).map((d) => markStaleIfRunning(d, now, staleThresholdMs)).sort(compareDelegationEntries),
@@ -900,20 +899,20 @@ function splitDelegationList(all, maxRecent = 8, now = Date.now(), staleThreshol
 /** Live-first window used by {@link ceilingDelegationList} (kept for the
 *  ceiling helper and existing tests): active jobs first, then the most
 *  recent terminal reports (capped). Pure. */
-function visibleDelegationList(all, maxTerminal = 8, now = Date.now(), staleThresholdMs = 1800 * 1e3) {
+function visibleDelegationList(all, maxTerminal = 8, now = Date.now(), staleThresholdMs = 18e5) {
 	const { active, recent } = splitDelegationList(all, maxTerminal, now, staleThresholdMs);
 	return [...active, ...recent];
 }
 /** Default stale-running threshold: 30 minutes. */
-const STALE_RUNNING_THRESHOLD_MS = 1800 * 1e3;
+const STALE_RUNNING_THRESHOLD_MS = 18e5;
 /** Idle silence window: if no updatedAt change in this window, the entry is
 *  considered stale. Combined with the stale-running threshold to produce the
 *  display-only `stale-running` state. */
-const IDLE_SILENCE_MS = 60 * 1e3;
+const IDLE_SILENCE_MS = 6e4;
 /** Visual-only terminal retention windows. Reports remain on disk; these
 *  constants only control which rows enter the TUI window. */
-const DELEGATION_DONE_RETENTION_MS = 120 * 1e3;
-const DELEGATION_FAILED_RETENTION_MS = 600 * 1e3;
+const DELEGATION_DONE_RETENTION_MS = 12e4;
+const DELEGATION_FAILED_RETENTION_MS = 6e5;
 /** Grace window for an ABSENT child status. `api.state.session.status()` only
 *  carries the sessions that are currently ALIVE; every finished child of a
 *  long-lived session is missing from that map. A child with no status is
@@ -923,7 +922,7 @@ const DELEGATION_FAILED_RETENTION_MS = 600 * 1e3;
 *  has not been registered by the status API yet: within this window of its
 *  last activity (`time.updated`, falling back to `time.created`) it still
 *  reads as running. */
-const DELEGATION_CHILD_STATUS_GRACE_MS = 60 * 1e3;
+const DELEGATION_CHILD_STATUS_GRACE_MS = 6e4;
 /** Recency window for the children channel. `session.children` returns EVERY
 *  child the focused session ever spawned, so a long session accumulates
 *  hundreds of historical rows that would inflate the panel. A child whose
@@ -931,12 +930,12 @@ const DELEGATION_CHILD_STATUS_GRACE_MS = 60 * 1e3;
 *  is older than this window is dropped BEFORE it can enter the list. 24h
 *  keeps the sidebar scoped to current work while still covering long
 *  delegations. A child with no timestamp at all is kept (fail-open). */
-const DELEGATION_CHILDREN_RECENCY_MS = 1440 * 60 * 1e3;
+const DELEGATION_CHILDREN_RECENCY_MS = 864e5;
 /** Alias-less NATIVE task() live entries never receive a report alias (the
 *  task tool output carries none), so the 30s alias-less prune in
 *  mergeChildDelegationSources must not apply to them — 5 minutes covers a
 *  slow child listing while still bounding the live map. */
-const NATIVE_LIVE_ALIASLESS_TTL_MS = 300 * 1e3;
+const NATIVE_LIVE_ALIASLESS_TTL_MS = 3e5;
 /**
 * Mark a running entry as `stale-running` if it has been running longer than
 * the threshold AND has no recent activity (no `updatedAt` change in the last
@@ -1040,7 +1039,7 @@ function delegationStateTone(state) {
 /** Bounded tracker: child session id → latest running tool call. */
 const latestToolActivity = /* @__PURE__ */ new Map();
 const MAX_TOOL_ACTIVITY_ENTRIES = 200;
-const TOOL_ACTIVITY_TTL_MS = 300 * 1e3;
+const TOOL_ACTIVITY_TTL_MS = 3e5;
 /** First usable summary string from common tool input fields. */
 function summarizeToolInput(input) {
 	if (!input) return "";
@@ -1558,9 +1557,7 @@ function formatDelegationHeader(entries) {
 		case "failed":
 			failed++;
 			break;
-		case "done":
-			done++;
-			break;
+		case "done": done++;
 	}
 	const tail = failed > 0 ? ` · ${failed} failed` : "";
 	return `(${active} active · ${done} done${tail})`;