pantheon-opencode 1.5.0-beta.11 → 1.5.0-beta.13

package/src/plugins/tui/src/index.tsx

@@ -5,9 +5,10 @@
 /**
  * pantheon-tui — Pantheon TUI plugin for opencode.
  *
- * Single self-contained entry file: `tsdown && cp src/index.tsx dist/tui.tsx`
- * keeps the no-build load path working (dist/tui.tsx is raw source, transpiled
- * on the fly by opencode). All feature code lives in this one file.
+ * Bundled entry: `tsdown` emits `dist/tui.js`, and the package `exports`
+ * (`./tui` → ./dist/tui.js, `./server` → ./dist/server.js) is the ONLY load
+ * path — no raw TSX copy is shipped. Because the bundle inlines relative
+ * imports, this entry may be split into modules without breaking the loader.
  *
  * Slots:
  *   - sidebar_content        (order 900) — Pantheon sidebar (header/version/
@@ -90,9 +91,9 @@ const PRESET_REFRESH_MS = 30_000
 /* ─── Helpers ───────────────────────────────────────────── */
 
 /* ─── Active Preset Detection ──────────────────────────────
- * Inline replica of src/pantheon/presets.mjs resolveActivePreset() — the TUI
- * plugin is self-contained (dist/tui.tsx is a raw copy of this file with no
- * relative imports), so the resolution logic is mirrored here rather than
+ * Inline replica of src/pantheon/presets.mjs resolveActivePreset() — the
+ * copied plugin ships only dist/ + package.json, so it cannot reach
+ * src/pantheon at runtime; the resolution logic is mirrored here rather than
  * importing presets.mjs.
  *
  * Priority: env PANTHEON_MODEL_PRESET > first existing candidate file > none.
@@ -155,7 +156,7 @@ async function resolvePresetForTui(
  *
  * Try order:
  *   0a. pantheon-tui/package.json (installed: dist/tui.js → 2 níveis)
- *   0b. pantheon/package.json (dev: src/plugins/tui/dist/tui.tsx → 4 níveis)
+ *   0b. pantheon/package.json (dev: src/plugins/tui/dist/tui.js → 4 níveis)
  *   1. api.client.file.read package.json
  *   2. git describe --tags
  *   3. opencode --version
@@ -163,7 +164,7 @@ async function resolvePresetForTui(
  *   5. null                                                      */
 
 // Build-time embedded version (tsdown `define` in tsdown.config.ts). Injected
-// only into the bundled dist/tui.js; the raw dist/tui.tsx copy falls through.
+// into the bundled dist/tui.js — the only artifact the loader consumes.
 declare const __PANTHEON_VERSION__: string | undefined
 
 async function detectVersion(api: TuiPluginApi): Promise<string | null> {
@@ -175,7 +176,7 @@ async function detectVersion(api: TuiPluginApi): Promise<string | null> {
     if (pkg.version) return pkg.version
   } catch {}
 
-  // Try 0b: dev location (4 levels: src/plugins/tui/dist/tui.tsx → package.json)
+  // Try 0b: dev location (4 levels: src/plugins/tui/dist/tui.js → package.json)
   try {
     const pkgUrl = new URL('../../../../package.json', import.meta.url)
     const pkgContent = await readFile(fileURLToPath(pkgUrl), 'utf8')
@@ -899,9 +900,9 @@ async function setupUsageBar(api: TuiPluginApi) {
  *      and the native `task()` tool ALSO spawns a child session with
  *      parentID = caller. A child WITHOUT a board report is a native
  *      task() child: childrenToDelegationEntries tags it source
- *      'children-only' with the `nat:` row tag (distinct info color),
+ *      'children-only' (distinct info color),
  *      so native task() work is visible in the panel alongside board
- *      delegates (`pan:apo-1`) — never filtered out, never duplicated
+ *      delegates — never filtered out, never duplicated
  *      with a board row for the same child (a child WITH a report keeps the
  *      md entry, source 'md').
  *
@@ -983,8 +984,9 @@ export type DelegationEntry = {
   // Reintroduce them once nested rows are actually produced.
   /** Internal provenance used to keep a finalized md report authoritative.
    *  'children-only' = a native task() child session with NO board report
-   *  (rendered with the distinct `nat:` prefix); 'md' = board report wins. */
-  source?: 'child' | 'live' | 'md' | 'children-only'
+   *  (a native child row); 'md' = board report wins;
+   *  'board' = read from .pantheon/board/state.json (cross-session FSM). */
+  source?: 'child' | 'live' | 'md' | 'children-only' | 'board'
 }
 
 /** True for `\s` characters (space, tab, newline, CR) — plain char checks so
@@ -1168,20 +1170,108 @@ export async function readAllDelegationEntries(root: string): Promise<Delegation
   return readDelegationEntries(join(root, '.pantheon', 'delegations'))
 }
 
+/* ─── Job board channel (4th source: .pantheon/board/state.json) ────────
+ * `session.children` is scoped to the focused session, so a job running in
+ * ANOTHER session is invisible to it (the "Delegations (0)" symptom).
+ * The board state file is the only durable, cross-session source:
+ * FilePersistence (src/pantheon/file-persistence.ts) stores every
+ * BackgroundJobRecord there as a JSON array. Reads are fail-open — absent,
+ * corrupt or unreadable → [] — so a broken board never crashes the panel. */
+
+/** The persisted subset of BackgroundJobRecord the panel consumes. Duck-typed
+ *  so a corrupt/older record never breaks parsing. */
+export type BoardJobRecord = {
+  taskID: string
+  parentSessionID: string
+  agent: string
+  description?: string
+  state: string
+  alias: string
+  launchedAt?: number
+  completedAt?: number
+  updatedAt?: number
+  timedOut?: boolean
+}
+
+/** The FilePersistence state path: `<root>/.pantheon/board/state.json`. */
+export function boardStatePath(root: string): string {
+  return join(root, '.pantheon', 'board', 'state.json')
+}
+
+/** Validate one parsed record, keeping only the fields the panel uses.
+ *  Returns null for anything without a taskID/state (a corrupt entry is
+ *  skipped individually — the rest of the snapshot still loads). */
+function normalizeBoardRecord(item: unknown): BoardJobRecord | null {
+  if (typeof item !== 'object' || item === null) return null
+  const rec = item as Record<string, unknown>
+  if (typeof rec.taskID !== 'string' || rec.taskID === '') return null
+  if (typeof rec.state !== 'string' || rec.state === '') return null
+  const record: BoardJobRecord = {
+    taskID: rec.taskID,
+    parentSessionID: typeof rec.parentSessionID === 'string' ? rec.parentSessionID : '',
+    agent: typeof rec.agent === 'string' && rec.agent !== '' ? rec.agent : 'agent',
+    state: rec.state,
+    alias: typeof rec.alias === 'string' ? rec.alias : '',
+  }
+  if (typeof rec.description === 'string') record.description = rec.description
+  if (typeof rec.launchedAt === 'number' && Number.isFinite(rec.launchedAt))
+    record.launchedAt = rec.launchedAt
+  if (typeof rec.completedAt === 'number' && Number.isFinite(rec.completedAt))
+    record.completedAt = rec.completedAt
+  if (typeof rec.updatedAt === 'number' && Number.isFinite(rec.updatedAt))
+    record.updatedAt = rec.updatedAt
+  if (typeof rec.timedOut === 'boolean') record.timedOut = rec.timedOut
+  return record
+}
+
+/** Read `.pantheon/board/state.json` (the cross-session job board snapshot).
+ *  Fail-open: missing file, corrupt JSON, non-array payload or an unreadable
+ *  path all yield [] — the panel keeps rendering from the other channels. */
+export async function readBoardState(root: string): Promise<BoardJobRecord[]> {
+  let raw: string
+  try {
+    raw = await readFile(boardStatePath(root), 'utf8')
+  } catch {
+    return [] // absent/unreadable — no board yet
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return [] // corrupt JSON — never crash the sidebar
+  }
+  if (!Array.isArray(parsed)) return []
+  const records: BoardJobRecord[] = []
+  for (const item of parsed) {
+    const record = normalizeBoardRecord(item)
+    if (record !== null) records.push(record)
+  }
+  return records
+}
+
+/** 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, the board state file
+ *  and the panel logger all read the SAME root (audit finding: the channels
+ *  resolved the root independently). Pure — no I/O. */
+export function resolvePantheonRoot(
+  state: { directory?: string; worktree?: string } | undefined,
+  cwd = process.cwd(),
+): string {
+  const root = state?.directory ?? state?.worktree ?? ''
+  if (root === '' || root === '/') return cwd
+  return root
+}
+
 /** Resolve the directory where the job board writes delegation md reports.
  *  The board writes `.pantheon/delegations` RELATIVE to the server cwd,
- *  which the TUI exposes as `TuiState.path.directory`. `project` does NOT
- *  exist on `TuiState.path` (the old `state?.project ?? state?.worktree`
- *  resolution was always undefined for the first term) and `worktree` is
- *  `/` when there is no git (e.g. the sandbox test project) — a root of
- *  `''` or `'/'` must fall back to `process.cwd()`. */
+ *  which the TUI exposes as `TuiState.path.directory`. */
 export function resolveDelegationsDir(
   state: { directory?: string; worktree?: string } | undefined,
   cwd = process.cwd(),
 ): string {
-  const root = state?.directory ?? state?.worktree ?? ''
-  if (root === '' || root === '/') return join(cwd, '.pantheon', 'delegations')
-  return join(root, '.pantheon', 'delegations')
+  return join(resolvePantheonRoot(state, cwd), '.pantheon', 'delegations')
 }
 
 /** Project root derived from the delegations dir: `<root>/.pantheon/delegations`
@@ -1212,18 +1302,18 @@ export function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry)
 }
 
 /** Split the panel list: active jobs (running/retry, stale-marked) first,
- *  then the most recent terminal reports, then the archived tail (paginated
- *  in the View). Pure — so the history-only panel (no sessionID) is testable
+ *  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. */
 export function splitDelegationList(
   all: readonly DelegationEntry[],
   maxRecent = 8,
   now = Date.now(),
   staleThresholdMs = 30 * 60 * 1000, // 30 minutes
-): { active: DelegationEntry[]; recent: DelegationEntry[]; archived: DelegationEntry[] } {
+): { active: DelegationEntry[]; recent: DelegationEntry[] } {
   // Active = running OR retry OR the display-only stale-running. A stale row
   // is still a live job (backend state unchanged), so it must never fall into
-  // the terminal/archived tail — archiving a running delegation hid the row
+  // the terminal tail — pushing a running delegation out hid the row
   // the user launched.
   const isActiveState = (st: DelegationEntry['state']): boolean =>
     st === 'running' || st === 'retry' || st === 'stale-running'
@@ -1234,13 +1324,12 @@ export function splitDelegationList(
   return {
     active,
     recent: terminal.slice(0, maxRecent),
-    archived: terminal.slice(maxRecent),
   }
 }
 
-/** The list the panel actually renders (kept for the header count and
- *  existing tests): active jobs first, then the most recent terminal
- *  reports (capped) — the archived tail is rendered separately. Pure. */
+/** 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. */
 export function visibleDelegationList(
   all: readonly DelegationEntry[],
   maxTerminal = 8,
@@ -1280,7 +1369,7 @@ export function markStaleIfRunning(
   return { ...entry, state: 'stale-running' as const }
 }
 
-/** Compact elapsed-time label: "5m 12s", "1h 30m", "2d 4h" — ticks every
+/** Compact elapsed-time label, single unit only: "12s"/"3m"/"1h"/"2d" — ticks every
  *  second for running jobs. */
 export function fmtElapsed(ms: number): string {
   const total = Math.max(0, Math.floor(ms / 1000))
@@ -1288,9 +1377,9 @@ export function fmtElapsed(ms: number): string {
   const hours = Math.floor((total % 86_400) / 3_600)
   const minutes = Math.floor((total % 3_600) / 60)
   const seconds = total % 60
-  if (days > 0) return `${days}d ${hours}h`
-  if (hours > 0) return `${hours}h ${minutes}m`
-  if (minutes > 0) return `${minutes}m ${seconds}s`
+  if (days > 0) return `${days}d`
+  if (hours > 0) return `${hours}h`
+  if (minutes > 0) return `${minutes}m`
   return `${seconds}s`
 }
 
@@ -1361,38 +1450,14 @@ export function delegationSpinnerFrame(now: number): string {
  *  pre-dispatch tool part maps to `running` in {@link reduceDelegationToolPart}. */
 export type DelegationDisplayState = DelegationEntry['state']
 
-/** Static glyph per display state. `running` shows its base spinner frame;
- *  callers that animate must prefer {@link delegationStateMarker}. Unicode
- *  geometric shapes only (no Nerd Font) — shape is an independent channel
- *  from color, so rows stay legible without color. */
-export const DELEGATION_STATE_GLYPHS: Readonly<Record<DelegationDisplayState, string>> = {
-  running: '\u280b', // ⠋ base frame of the animated spinner
-  retry: '\u27f3', // ⟳ retrying
-  'stale-running': '\u26a0', // ⚠ stale (display-only alert)
-  completed: '\u2713', // ✓
-  error: '\u2715', // ✕
-  cancelled: '\u2212', // − minus: stopped, distinct from error's ✕
-  startup_failed: '\u26a0', // ⚠ boot failed
-  startup_unknown: '\u26a0', // ⚠ boot outcome unknown
-}
-
-export function delegationStateGlyph(state: DelegationDisplayState): string {
-  return DELEGATION_STATE_GLYPHS[state]
-}
-
-/** Row marker (`<glyph> `) — the state channel. `running` animates through
- *  {@link delegationSpinnerFrame} for the given tick; every other state is
- *  static. Pure. */
-export function delegationStateMarker(state: DelegationDisplayState, now = Date.now()): string {
-  const glyph = state === 'running' ? delegationSpinnerFrame(now) : delegationStateGlyph(state)
-  return `${glyph} `
-}
-
 /** 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. */
 export type DelegationStateTone = 'warning' | 'error' | 'success' | 'muted'
 
+/** Color is the ONLY channel separating `stale-running` from a live `running`
+ *  row — the 4-glyph row design has no dedicated stale shape. Display-only;
+ *  no behavior change. */
 export function delegationStateTone(state: DelegationDisplayState): DelegationStateTone {
   switch (state) {
     case 'running':
@@ -1428,10 +1493,6 @@ const latestToolActivity = new Map<string, ToolActivity>()
 const MAX_TOOL_ACTIVITY_ENTRIES = 200
 const TOOL_ACTIVITY_TTL_MS = 5 * 60 * 1000
 
-/** Archived-section pagination state — module-level so it survives sidebar
- *  remounts (route changes) without leaking into the component tree. */
-const archivedUiState = { page: 0 }
-
 /** First usable summary string from common tool input fields. */
 function summarizeToolInput(input: Record<string, unknown> | undefined): string {
   if (!input) return ''
@@ -1521,6 +1582,17 @@ export function mergeChildDelegationSources(
     )
       continue
     const incoming = toDelegationEntry(liveEntry)
+    // A native task() live part never carries a board alias — it is a
+    // children-only row by definition whether it lands on a new row or
+    // upgrades an existing
+    // children-only one. pantheon_delegate pending parts keep source 'live'.
+    const isNativeLive = liveEntry.tool === 'task' && liveEntry.alias === null
+    if (isNativeLive) {
+      // Native task() rows carry no board alias — reuse the synthetic
+      // 'native-task' marker so the single identity falls back to the agent.
+      incoming.source = 'children-only'
+      incoming.alias = 'native-task'
+    }
     const index =
       (incoming.taskID !== undefined ? byTask.get(incoming.taskID) : undefined) ??
       (incoming.alias !== ''
@@ -1568,7 +1640,10 @@ export function mergeChildDelegationSources(
       startedAt: Math.min(existing.startedAt, incoming.startedAt),
       updatedAt: incoming.updatedAt,
       read: incoming.read,
-      source: 'live',
+      // A native task() live upgrade must not flip a children-only row to
+      // 'live' (that would drop the children-only provenance); pantheon_delegate
+      // upgrades still take source 'live'.
+      source: isNativeLive ? existing.source : 'live',
     }
   }
 
@@ -1713,7 +1788,7 @@ export function parseDelegationToolPart(
   // The alias/taskID only exist once the delegate tool COMPLETES (they are
   // returned in its output); a running/pending part has neither. Native
   // `task` parts never carry a board alias — the children channel supplies
-  // the child session id, so the row renders `nat:`.
+  // the child session id and the row's identity.
   let alias: string | null = null
   let taskID: string | null = null
   if (status === 'completed') {
@@ -1787,7 +1862,7 @@ export function reduceDelegationToolPart(
   // job launched (running). A COMPLETED delegate tool only means the job was
   // registered — it stays running and we pick up alias + taskID from the
   // output. Native `task` parts never yield a board alias, so their rows
-  // stay `nat:` until the children channel resolves them.
+  // stay identity-less until the children channel resolves them.
   const existing = map.get(parsed.callID)
   if (parsed.status === 'error') {
     if (existing !== undefined && existing.state === 'error' && existing.updatedAt === parsed.endAt)
@@ -1872,7 +1947,7 @@ export function removeDelegationEntry(
  *  SDK exposes `api.state.part(messageID)`). The native `task` tool spawns a
  *  child session with parentID = caller — the same mechanism as
  *  pantheon_delegate — so its parts feed the live-map as the native signal
- *  (rows render `nat:` via the children channel). Pure w.r.t. I/O — used
+ *  (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. */
 export function collectDelegationToolParts(
   messages: readonly { id?: string; parts?: unknown[] }[] | undefined,
@@ -1970,6 +2045,95 @@ export function mergeDelegationSources(
   return all
 }
 
+/* ─── Board channel: record → display + authoritative merge ───────────── */
+
+/** Job-board FSM → panel display state. `reconciled` is intentionally absent:
+ *  the panel parser rejects it (a reconciled job is done and folded away). */
+const BOARD_STATE_TO_DISPLAY: Record<string, DelegationEntry['state']> = {
+  running: 'running',
+  completed: 'completed',
+  error: 'error',
+  startup_failed: 'startup_failed',
+  startup_unknown: 'startup_unknown',
+  cancelled: 'cancelled',
+}
+
+/** Map one persisted board record into the display shape. Returns null for
+ *  states the panel does not render (reconciled / unknown). Pure. */
+export function boardRecordToDelegationEntry(record: BoardJobRecord): DelegationEntry | null {
+  const state = BOARD_STATE_TO_DISPLAY[record.state]
+  if (state === undefined) return null
+  const running = state === 'running'
+  return {
+    alias: record.alias !== '' ? record.alias : `job-${record.taskID.slice(0, 8)}`,
+    sessionID: record.parentSessionID,
+    taskID: record.taskID,
+    agent: record.agent,
+    state,
+    startedAt: record.launchedAt ?? record.updatedAt ?? 0,
+    updatedAt: running ? null : (record.completedAt ?? record.updatedAt ?? null),
+    timedOut: record.timedOut === true,
+    description: record.description ?? '',
+    source: 'board',
+  }
+}
+
+/** Map a whole board snapshot, dropping unrenderable states. Sorted like every
+ *  other channel (running first, then most recent). Pure. */
+export function boardRecordsToDelegationEntries(
+  records: readonly BoardJobRecord[],
+): DelegationEntry[] {
+  const out: DelegationEntry[] = []
+  for (const record of records) {
+    const entry = boardRecordToDelegationEntry(record)
+    if (entry !== null) out.push(entry)
+  }
+  out.sort(compareDelegationEntries)
+  return out
+}
+
+/** Merge the board over any other channel. The board is AUTHORITATIVE for
+ *  state/alias/agent (it is the persisted FSM) and it is the only channel
+ *  that carries jobs from OTHER sessions. Dedup by taskID first, then by
+ *  (sessionID, alias) — aliases are per parent session. Pure. */
+export function mergeBoardDelegationSources(
+  base: readonly DelegationEntry[],
+  board: readonly DelegationEntry[],
+): DelegationEntry[] {
+  const key = (sessionID: string, alias: string): string => `${sessionID}\u0000${alias}`
+  const byTaskID = new Map<string, number>()
+  const bySessionAlias = new Map<string, number>()
+  const out = [...base]
+  out.forEach((entry, index) => {
+    if (entry.taskID !== undefined) byTaskID.set(entry.taskID, index)
+    bySessionAlias.set(key(entry.sessionID, entry.alias), index)
+  })
+
+  for (const incoming of board) {
+    const index =
+      (incoming.taskID !== undefined ? byTaskID.get(incoming.taskID) : undefined) ??
+      bySessionAlias.get(key(incoming.sessionID, incoming.alias))
+    if (index === undefined) {
+      out.push(incoming)
+      const next = out.length - 1
+      if (incoming.taskID !== undefined) byTaskID.set(incoming.taskID, next)
+      bySessionAlias.set(key(incoming.sessionID, incoming.alias), next)
+      continue
+    }
+    out[index] = {
+      ...incoming,
+      // Session preservation: the board is authoritative for state/alias/agent,
+      // but an EMPTY board sessionID (record without parentSessionID) must
+      // never clobber a known session — otherwise a focused-session row would
+      // lose its attribution. Keep the known session.
+      sessionID: incoming.sessionID !== '' ? incoming.sessionID : (out[index]?.sessionID ?? ''),
+    } // board wins — it is the persisted source of truth
+  }
+
+  out.sort(compareDelegationEntries)
+  return out
+}
+
 /* ─── Children channel (primary source, delegations-sidebar pattern) ────
  * `api.client.session.children` returns the child sessions of the current
  * session — every pantheon_delegate spawns one (parentID = caller). The
@@ -2089,37 +2253,72 @@ export function childStatusToState(status: string | undefined): 'running' | 'com
   return 'running' // busy or unknown
 }
 
-/** Short row prefix for a delegation entry (one of the two visual channels
- *  that split native task() work from pantheon_delegate jobs — the other is
- *  {@link delegationIcon}):
+/** Status-only row model: ONE glyph + ONE identity per row.
  *
- *  - `nat:<agent>` — a native task() child (source 'children-only', no board
- *    report). The child session carries no board alias, so the agent IS the
- *    identity.
- *  - `pan:<alias>` — a pantheon_delegate board row (`pan:apo-1`), the same
- *    alias the manager prints in pantheon_delegation_list.
- *
- *  Short prefixes keep the narrow sidebar readable (the old
- *  `pan:apo-1`/`nat:` tags ate the row width). */
-export function delegationTag(entry: DelegationEntry): string {
-  return entry.source === 'children-only' ? `nat:${entry.agent}` : `pan:${entry.alias}`
+ *  A row is
+ *  `{glyph} {alias:7} {elapsed:>5}` plus a muted description line. The short
+ *  alias (`apo-1`) is the single identity; rows without a board alias show
+ *  the agent instead (never both). */
+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 board 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. */
+export function delegationRowStatus(state: DelegationDisplayState): DelegationRowStatus {
+  switch (state) {
+    case 'running':
+    case 'stale-running':
+      return 'active'
+    case 'retry':
+    case 'startup_unknown':
+      return 'retry'
+    case 'completed':
+    case 'cancelled':
+      return 'done'
+    case 'error':
+    case 'startup_failed':
+      return 'failed'
+  }
+}
+
+/** The only 4 glyphs a row may show: animated active, done, failed, retry.
+ *  Shape is redundant with color (never the only signal). Pure. */
+export const DELEGATION_ROW_GLYPHS: Readonly<Record<DelegationRowStatus, string>> = {
+  active: '⠋', // base frame of the animated spinner
+  done: '✓',
+  failed: '✕',
+  retry: '⟳',
 }
 
-/** Row glyph: hollow diamond `◇` for native task() children (info color,
- *  outline) vs filled diamond `◆` for pantheon_delegate rows (state color).
- *  Shape + color are independent channels, so the split stays legible even
- *  without color. */
-export function delegationIcon(entry: DelegationEntry): string {
-  return entry.source === 'children-only' ? '\u25c7' : '\u25c6'
+export function delegationRowGlyph(status: DelegationRowStatus): string {
+  return DELEGATION_ROW_GLYPHS[status]
+}
+
+/** Row marker (`<glyph> `) — the single state channel. `active` animates
+ *  through the 1s spinner for the given tick; every other kind is static.
+ *  Pure. */
+export function delegationRowMarker(state: DelegationDisplayState, now = Date.now()): string {
+  const status = delegationRowStatus(state)
+  const glyph = status === 'active' ? delegationSpinnerFrame(now) : delegationRowGlyph(status)
+  return `${glyph} `
 }
 
-/** Row identity after the status marker + glyph. Pantheon rows append the
- *  agent (`pan:apo-1 apollo`); native rows already carry it inside the tag
- *  (`nat:apollo`) and must not duplicate it. */
-export function formatDelegationIdentity(entry: DelegationEntry): string {
-  return entry.source === 'children-only'
-    ? delegationTag(entry)
-    : `${delegationTag(entry)} ${entry.agent}`
+/** ONE identity per row: the short board alias (`apo-1`); a row without a
+ *  board alias (native task() child, alias `native-task`) shows the agent
+ *  instead — never alias + agent stacked. Pure. */
+export function delegationRowIdentity(entry: DelegationEntry): string {
+  if (entry.alias === 'native-task' && entry.agent !== '') return entry.agent
+  return entry.alias
+}
+
+/** Fixed alias cell, pad-right + hard-truncate to `width` (default 7) so
+ *  identities line up across rows. Pure. */
+export const DELEGATION_ALIAS_WIDTH = 7
+
+export function formatDelegationAlias(identity: string, width = DELEGATION_ALIAS_WIDTH): string {
+  if (identity.length >= width) return identity.slice(0, width)
+  return `${identity}${' '.repeat(width - identity.length)}`
 }
 
 /** Max description width on the row detail line — the old 180-char slice
@@ -2153,10 +2352,10 @@ export function truncateDelegationDescription(
   return `${graphemes.slice(0, Math.max(0, max - 1)).join('')}\u2026`
 }
 
-/** Fixed elapsed-time box: right-aligned to `width` (default 8) so elapsed
- *  values line up across rows, e.g. `     12s`. A label that already fills
+/** 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. */
-export const DELEGATION_ELAPSED_WIDTH = 8
+export const DELEGATION_ELAPSED_WIDTH = 5
 
 export function formatDelegationElapsed(
   entry: DelegationEntry,
@@ -2168,10 +2367,11 @@ export function formatDelegationElapsed(
   return `${' '.repeat(width - label.length)}${label}`
 }
 
-/** First row line: `<marker><glyph> <identity>`. The marker already carries
- *  its trailing space. Pure — the row renders the returned string verbatim. */
-export function formatDelegationRow(entry: DelegationEntry, marker: string): string {
-  return `${marker}${delegationIcon(entry)} ${formatDelegationIdentity(entry)}`
+/** 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. */
+export function formatDelegationRowLead(entry: DelegationEntry, marker: string): string {
+  return `${marker}${formatDelegationAlias(delegationRowIdentity(entry))} `
 }
 
 // Tree connectors (`isNestedDelegation` / `delegationTreePrefix`) were removed
@@ -2179,22 +2379,52 @@ export function formatDelegationRow(entry: DelegationEntry, marker: string): str
 // ever actually nested and the connectors were never populated in production.
 // BACKLOG: produce real grandchild rows first, then reintroduce them.
 
-/** Header summary: `(N active · M done · nat:K pan:M)`. Active counts
- *  running/retry AND display-only stale-running (a stale row is still a live
- *  job — it must never read as done). Pure. */
+/** 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. */
+export 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. */
 export function formatDelegationHeader(entries: readonly DelegationEntry[]): string {
   let active = 0
+  let done = 0
+  let failed = 0
   for (const e of entries) {
-    if (e.state === 'running' || e.state === 'retry' || e.state === 'stale-running') active++
+    switch (delegationRowStatus(e.state)) {
+      case 'active':
+      case 'retry':
+        active++
+        break
+      case 'failed':
+        failed++
+        break
+      case 'done':
+        done++
+        break
+    }
   }
-  const done = entries.length - active
-  const counts = countDelegationSources(entries)
-  return `(${active} active \u00b7 ${done} done \u00b7 nat:${counts.native} pan:${counts.pantheon})`
+  const tail = failed > 0 ? ` · ${failed} failed` : ''
+  return `(${active} active · ${done} done${tail})`
+}
+
+/** Cap the panel: live rows first, then most-recent terminal rows, at most
+ *  `maxVisible` total. `hidden` is how many were dropped (rendered as
+ *  "… +N more"). Pure. */
+export function ceilingDelegationList(
+  all: readonly DelegationEntry[],
+  maxVisible = DELEGATION_VISIBLE_CEILING,
+  now = Date.now(),
+): { visible: DelegationEntry[]; hidden: number } {
+  const visible = visibleDelegationList(all, maxVisible, now).slice(0, maxVisible)
+  return { visible, hidden: Math.max(0, all.length - visible.length) }
 }
 
 /** Split a display list into native task() rows vs pantheon_delegate rows.
  *  Native = source 'children-only' (no board report); everything else counts
- *  as pantheon. Pure — powers the header breakdown + the hooks.log line. */
+ *  as pantheon. Pure — powers the hooks.log line. */
 export function countDelegationSources(entries: readonly DelegationEntry[]): {
   native: number
   pantheon: number
@@ -2227,18 +2457,22 @@ export function formatPanelLogLine(
  *  time.created. A report-less child is a NATIVE task() child (every
  *  child of the current session — pantheon_delegate OR the native `task()`
  *  tool — carries parentID = caller), so it gets source 'children-only',
- *  the internal alias 'native-task' and the `nat:` tag instead of a
+ *  the internal alias 'native-task' instead of a
  *  board alias. The 'task nativa' description fallback keeps the row
  *  non-empty when the child carries no title.
  *  Terminal md state wins over the derived state; a running md defers to
  *  the child's live status. A running child is NEVER archived — it always
  *  lands in the active split (splitDelegationList active = running/retry).
+ *  `parentSessionID` (the focused session id) is stamped on report-less
+ *  children so the row carries its origin session; omit it and they stay
+ *  unscoped ('').
  *  Sorted running-first (compareDelegationEntries).
  *  Pure — no I/O. */
 export function childrenToDelegationEntries(
   children: readonly ChildDelegationLike[] | undefined,
   md: readonly DelegationEntry[],
   now = Date.now(),
+  parentSessionID = '',
 ): DelegationEntry[] {
   const byTaskID = new Map<string, DelegationEntry>()
   for (const m of md) {
@@ -2256,7 +2490,11 @@ export function childrenToDelegationEntries(
         : childStatusToState(child.status)
     out.push({
       alias: mdEntry?.alias ?? 'native-task',
-      sessionID: mdEntry?.sessionID ?? '',
+      // A report-less child IS a child of the focused session
+      // (session.children is session-scoped), so the caller-passed
+      // parentSessionID is stamped on it as its origin session; an md
+      // match always carries its own session (the report dir name).
+      sessionID: mdEntry?.sessionID ?? parentSessionID,
       taskID: child.id,
       agent: mdEntry?.agent ?? child.agent ?? 'agent',
       state,
@@ -2293,8 +2531,8 @@ export function navigateToDelegationSession(
 }
 
 /* ─── Silence-by-default panel logger ──────────────────────
- * Mirrors src/pantheon/logger.ts createPantheonLogger (the TUI plugin is
- * self-contained — dist/tui.tsx is a raw copy with no relative imports):
+ * Mirrors src/pantheon/logger.ts createPantheonLogger (the copied plugin
+ * ships only dist/ + package.json, so it cannot import from src/pantheon):
  * every line is ALWAYS appended to `<logDir>/.pantheon/logs/hooks.log` and
  * echoed to the console ONLY when PANTHEON_HOOKS_LOG is truthy (opencode
  * renders plugin console output directly into the TUI — the pollution bug).
@@ -2395,7 +2633,7 @@ function SessionRow(props: { api: TuiPluginApi; session: any }) {
   )
 }
 
-/* ─── Delegation Row (single job from the children/md channels) ─ */
+/* ─── Delegation Row (single job from the children/md/board channels) ─ */
 
 function DelegationRow(props: {
   api: TuiPluginApi
@@ -2405,7 +2643,10 @@ function DelegationRow(props: {
 }) {
   const theme = () => props.api.theme.current
 
-  const color = createMemo(() => {
+  // Color is a SEPARATE channel from the glyph: the lead (glyph + identity)
+  // carries the state tone, while elapsed + description stay muted so the
+  // state reads at a glance without shouting.
+  const tone = createMemo(() => {
     const t = theme()
     switch (delegationStateTone(props.job.state)) {
       case 'warning':
@@ -2419,16 +2660,10 @@ function DelegationRow(props: {
     }
   })
 
-  const marker = createMemo(() => delegationStateMarker(props.job.state, props.animationNow))
-
-  // Two visual channels split native task() from pantheon_delegate: the tag
-  // prefix (`nat:`/`pan:`, via delegationTag) and the glyph color — info
-  // (cyan) for native, state color for board rows. The glyph shape (◇/◆) is
-  // the third, color-independent channel.
-  const tagColor = createMemo(() => (props.job.source === 'children-only' ? theme().info : color()))
-
-  const description = createMemo(() => truncateDelegationDescription(props.job.description))
+  const marker = createMemo(() => delegationRowMarker(props.job.state, props.animationNow))
+  const lead = createMemo(() => formatDelegationRowLead(props.job, marker()))
   const elapsed = createMemo(() => formatDelegationElapsed(props.job, props.now))
+  const description = createMemo(() => truncateDelegationDescription(props.job.description))
 
   // beta.6: live tool call the child is running RIGHT NOW ("↳ bash npm test"),
   // fed by message.part.updated activity tracking. Null while idle/done.
@@ -2445,22 +2680,22 @@ function DelegationRow(props: {
 
   return (
     <box onMouseDown={open}>
+      {/* Line 1: colored lead (glyph + identity) + muted elapsed tail. */}
       <box flexDirection="row">
-        <text fg={tagColor()}>{formatDelegationRow(props.job, marker())}</text>
-      </box>
-      {/* Elapsed is ALWAYS rendered (outside the optional-description Show) so
-       * an active job with no description never loses its timer. */}
-      <box flexDirection="row" justifyContent={description() !== '' ? 'space-between' : 'flex-end'}>
-        <Show when={description() !== ''}>
-          <text fg={theme().textMuted}>{description()}</text>
-        </Show>
-        <text fg={theme().textMuted}>{elapsed()}</text>
+        <text>
+          <span fg={tone()}>{lead()}</span>
+          <span fg={theme().textMuted}>{elapsed()}</span>
+        </text>
       </box>
+      {/* Line 2: the description, indented under the identity and muted. */}
+      <Show when={description() !== ''}>
+        <text fg={theme().textMuted}>{`  ${description()}`}</text>
+      </Show>
       <Show when={activity()}>
         {(a) => (
           <text
             fg={theme().textMuted}
-          >{`  \u21b3 ${truncateDelegationDescription(`${a().tool}${a().summary !== '' ? ` ${a().summary}` : ''}`)}`}</text>
+          >{`  ↳ ${truncateDelegationDescription(`${a().tool}${a().summary !== '' ? ` ${a().summary}` : ''}`)}`}</text>
         )}
       </Show>
     </box>
@@ -2569,14 +2804,15 @@ function View(props: {
   // (.pantheon/delegations) enriches each child with alias/agent/description
   // and terminal duration via the `Task ID` match. Live tool-call events are
   // merged optimistically so the row appears before those channels catch up.
-  const delegationsDir = createMemo(() => resolveDelegationsDir((props.api.state as any).path))
+  // Consistent project root (directory ?? worktree, cwd fallback) — the md
+  // history, the board state file and the panel logger all read the SAME
+  // root (audit finding: the channels resolved it independently).
+  const projectRoot = createMemo(() => resolvePantheonRoot((props.api.state as any).path))
   // Silence-by-default panel logger → the REAL <root>/.pantheon/logs/hooks.log.
-  // panelLogDir(<root>/.pantheon/delegations) = <root>: the old code passed
-  // dirname(delegationsDir()) (= <root>/.pantheon), which createTuiLogger
-  // re-joined with `.pantheon/logs/hooks.log` → a nested
-  // <root>/.pantheon/.pantheon/logs/hooks.log that never reached the real
-  // hooks.log (the empty nested dirs observed in production).
-  const panelLog = createTuiLogger(panelLogDir(delegationsDir()))
+  const panelLog = createTuiLogger(projectRoot())
+  // Every job the board knows about is shown — no scope filter ("showing is
+  // what matters"). Live-first ordering keeps running rows on top; the
+  // ceiling collapses the rest into "… +N more".
   // The rendered list is childDelegations (children enriched with md);
   // there is no separate md-only signal — the md channel only feeds
   // childrenToDelegationEntries below.
@@ -2609,10 +2845,19 @@ function View(props: {
         // the full historical list. Fail-open: a missing dir yields [].
         let md: DelegationEntry[] = []
         try {
-          md = await readAllDelegationEntries(panelLogDir(delegationsDir()))
+          md = await readAllDelegationEntries(projectRoot())
         } catch {
           md = [] // fail-open: never crash the sidebar on a read error
         }
+        // 0b. board snapshot — the 4th channel. Cross-session and AUTHORITATIVE
+        // for state/alias/agent (the persisted FSM). This is what makes a job
+        // running in ANOTHER session visible. Fail-open: absent/corrupt → [].
+        let board: DelegationEntry[] = []
+        try {
+          board = boardRecordsToDelegationEntries(await readBoardState(projectRoot()))
+        } catch {
+          board = [] // fail-open: never crash the sidebar on a board read error
+        }
         // 1. current session — resolve + GUARD (placeholder regression). The
         // runtime may render the sidebar with an unsubstituted "{sessionID}"
         // slot prop; forwarding it to session.children made the server reject
@@ -2622,9 +2867,9 @@ function View(props: {
         // (zero children, zero errors).
         const sessionID = resolveCurrentSessionID({ sessionID: props.sessionID, api: props.api })
         if (sessionID === null) {
-          setChildDelegations(md)
+          setChildDelegations(mergeBoardDelegationSources(md, board))
           panelLog.info(
-            `${formatPanelLogLine(0, 0, 0, md.length, eventRefreshCount)} (no sessionID — history shown)`,
+            `${formatPanelLogLine(0, 0, 0, md.length, eventRefreshCount)} (no sessionID — history+board shown)`,
           )
           return
         }
@@ -2655,7 +2900,10 @@ function View(props: {
           }
         }
         const withStatus = children.map((c) => ({ ...c, status: resolveStatus(c.id) }))
-        const childEntries = childrenToDelegationEntries(withStatus, md, now())
+        // Report-less rows ARE children of the focused session
+        // (session.children is session-scoped), so the resolved id is stamped on
+        // the row as its origin session.
+        const childEntries = childrenToDelegationEntries(withStatus, md, now(), sessionID)
         for (const [k, v] of props.liveStore.map)
           if (v.alias === null && v.taskID === null && Date.now() - v.startedAt > 30_000)
             props.liveStore.map.delete(k)
@@ -2665,7 +2913,14 @@ function View(props: {
         const liveEntries = [...props.liveStore.map.values()].filter(
           (entry) => entry.sessionID === sessionID,
         )
-        setChildDelegations(mergeChildDelegationSources(childEntries, liveEntries))
+        // Board LAST so it is authoritative over children/md/live for the same
+        // job, and adds the rows from other sessions the children API cannot see.
+        setChildDelegations(
+          mergeBoardDelegationSources(
+            mergeChildDelegationSources(childEntries, liveEntries),
+            board,
+          ),
+        )
         // 4. diagnostic line — every re-fetch (silence-by-default, hooks.log).
         const counts = countDelegationSources(childEntries)
         panelLog.info(
@@ -2683,24 +2938,13 @@ function View(props: {
     })()
     return delegationsInflight
   }
-  // beta.6: active (running/retry) first, then the 8 most recent terminal
-  // reports, then the archived tail (paginated). Pagination state lives at
-  // module level so sidebar remounts keep the user's page.
-  const delegationSplit = createMemo(() => splitDelegationList(childDelegations()))
-  const visibleDelegations = createMemo(() => [
-    ...delegationSplit().active,
-    ...delegationSplit().recent,
-  ])
-  // Header summary over the FULL list (active + recent + archived): active
-  // vs done plus the native/pantheon breakdown, so a busy session reads
-  // "Delegations (2 active · 9 done · nat:3 pan:8)".
+  // Live-first ceiling: at most DELEGATION_VISIBLE_CEILING rows render; the
+  // remainder collapses into a single "… +N more" line. The header counts the
+  // FULL board list — every session, no scope filter.
+  const delegationCeiling = createMemo(() =>
+    ceilingDelegationList(childDelegations(), DELEGATION_VISIBLE_CEILING, now()),
+  )
   const delegationHeader = createMemo(() => formatDelegationHeader(childDelegations()))
-  const [archivedPage, setArchivedPage] = createSignal(archivedUiState.page)
-  const clampArchivedPage = (page: number, pages: number) => {
-    const clamped = Math.max(0, Math.min(page, Math.max(0, pages - 1)))
-    archivedUiState.page = clamped
-    setArchivedPage(clamped)
-  }
 
   // ── Event subscriptions for live session/delegation updates ──
   onMount(() => {
@@ -2840,16 +3084,18 @@ function View(props: {
         </Show>
       </Show>
 
-      {/* ── Delegations (session.children primary + .pantheon/delegations md enrichment) ── */}
+      {/* ── Delegations (session.children primary + .pantheon/delegations md enrichment + board snapshot) ── */}
       <box onMouseDown={() => setShowDelegations((x) => !x)}>
         <text fg={theme().text} attributes={1}>
           {`${showDelegations() ? '▼' : '▶'} Delegations`}
         </text>
-        <text fg={theme().textMuted}>{` ${delegationHeader()}`}</text>
+        <text fg={theme().textMuted}>
+          {childDelegations().length > 0 ? ` ${delegationHeader()}` : ' — idle'}
+        </text>
       </box>
       <Show when={showDelegations()}>
         <Show
-          when={visibleDelegations().length > 0}
+          when={delegationCeiling().visible.length > 0}
           fallback={
             <box marginLeft={1}>
               <text fg={theme().textMuted}>No delegations</text>
@@ -2857,7 +3103,7 @@ function View(props: {
           }
         >
           <box marginLeft={1} flexDirection="column">
-            <For each={visibleDelegations()}>
+            <For each={delegationCeiling().visible}>
               {(job) => (
                 <DelegationRow
                   api={props.api}
@@ -2867,40 +3113,8 @@ function View(props: {
                 />
               )}
             </For>
-            <Show when={delegationSplit().archived.length > 0}>
-              {(() => {
-                const archived = delegationSplit().archived
-                const pageSize = 8
-                const pages = Math.ceil(archived.length / pageSize)
-                const page = Math.min(archivedPage(), pages - 1)
-                const slice = archived.slice(page * pageSize, page * pageSize + pageSize)
-                return (
-                  <box flexDirection="column">
-                    <box flexDirection="row" marginLeft={0}>
-                      <text
-                        fg={theme().textMuted}
-                        onMouseDown={() => clampArchivedPage(page - 1, pages)}
-                      >{`\u2039 `}</text>
-                      <text fg={theme().textMuted}>{`Archived (${archived.length}) `}</text>
-                      <text fg={theme().textMuted}>{`${page + 1}/${pages}`}</text>
-                      <text
-                        fg={theme().textMuted}
-                        onMouseDown={() => clampArchivedPage(page + 1, pages)}
-                      >{` \u203a`}</text>
-                    </box>
-                    <For each={slice}>
-                      {(job) => (
-                        <DelegationRow
-                          api={props.api}
-                          job={job}
-                          now={now()}
-                          animationNow={animationNow()}
-                        />
-                      )}
-                    </For>
-                  </box>
-                )
-              })()}
+            <Show when={delegationCeiling().hidden > 0}>
+              <text fg={theme().textMuted}>{`… +${delegationCeiling().hidden} more`}</text>
             </Show>
           </box>
         </Show>