pantheon-opencode 1.5.0-beta.1 → 1.5.0-beta.10

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

@@ -47,7 +47,7 @@
 
 import { Buffer } from 'node:buffer'
 import type { Dirent } from 'node:fs'
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises'
+import { appendFile, mkdir, readdir, readFile, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -899,9 +899,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 `[native]` row tag (distinct info color),
+ *      'children-only' with the `nat:` row tag (distinct info color),
  *      so native task() work is visible in the panel alongside board
- *      delegates ([pantheon:apo-1]) — never filtered out, never duplicated
+ *      delegates (`pan:apo-1`) — never filtered out, never duplicated
  *      with a board row for the same child (a child WITH a report keeps the
  *      md entry, source 'md').
  *
@@ -921,9 +921,12 @@ async function setupUsageBar(api: TuiPluginApi) {
  *      children; a 1s safety poll (oh-my-opencode-slim pattern) re-fetches
  *      children + re-reads the md so the panel updates EVEN without events.
  *
- *   4. DIAGNOSTICS — every re-fetch logs "panel: children=N md=N events=N"
+ *   4. DIAGNOSTICS — every re-fetch logs
+ *      "panel: children=N(pantheon=M native=K) md=N events=N"
  *      to `.pantheon/logs/hooks.log` (silence-by-default, createPantheonLogger
- *      policy) so the (0) symptom is diagnosable from disk. A children fetch
+ *      policy) so the (0) symptom is diagnosable from disk: children>0 means
+ *      the source works, pantheon/native splits board vs task() children.
+ *      A children fetch
  *      failure logs "panel: error <msg>" (previously silenced), and a missing
  *      current session (null/placeholder sessionID) logs "panel: children=0
  *      md=N ... (no sessionID — history shown)" — the md HISTORY renders
@@ -959,6 +962,7 @@ export type DelegationEntry = {
   agent: string
   state:
     | 'running'
+    | 'retry'
     | 'completed'
     | 'error'
     | 'startup_failed'
@@ -973,9 +977,13 @@ export type DelegationEntry = {
   description: string
   /** True while the panel is waiting for pantheon_delegation_read. */
   read?: boolean
+  // NOTE: the nested/tree view is BACKLOG. `session.children` returns direct
+  // children only, so no real grandchild rows exist yet; the parentTaskID /
+  // childCount fields + tree-connector helpers were removed as dead code.
+  // 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 `[native]` tag); 'md' = board report wins. */
+   *  (rendered with the distinct `nat:` prefix); 'md' = board report wins. */
   source?: 'child' | 'live' | 'md' | 'children-only'
 }
 
@@ -1195,27 +1203,52 @@ export function tuiLogPath(projectRoot: string): string {
  *  falling back to startedAt, descending). Shared by the md reader and
  *  mergeDelegationSources. */
 export function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry): number {
-  const aRun = a.state === 'running' || a.state === 'stale-running' ? 1 : 0
-  const bRun = b.state === 'running' || b.state === 'stale-running' ? 1 : 0
+  const isActive = (st: DelegationEntry['state']) =>
+    st === 'running' || st === 'retry' || st === 'stale-running' ? 1 : 0
+  const aRun = isActive(a.state)
+  const bRun = isActive(b.state)
   if (aRun !== bRun) return bRun - aRun
   return (b.updatedAt ?? b.startedAt) - (a.updatedAt ?? a.startedAt)
 }
 
-/** The list the panel actually renders: running jobs first, then the most
- *  recent terminal reports (capped). Pure — so the history-only panel (no
- *  sessionID) is testable without the TUI runtime. The header count uses the
- *  same "running + recentes" list. */
+/** 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
+ *  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 = 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 user launched.
+  const isActiveState = (st: DelegationEntry['state']): boolean =>
+    st === 'running' || st === 'retry' || st === 'stale-running'
+  const active = all
+    .filter((d) => isActiveState(d.state))
+    .map((d) => markStaleIfRunning(d, now, staleThresholdMs))
+  const terminal = all.filter((d) => !isActiveState(d.state))
+  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. */
 export function visibleDelegationList(
   all: readonly DelegationEntry[],
   maxTerminal = 8,
   now = Date.now(),
   staleThresholdMs = 30 * 60 * 1000, // 30 minutes
 ): DelegationEntry[] {
-  const running = all
-    .filter((d) => d.state === 'running')
-    .map((d) => markStaleIfRunning(d, now, staleThresholdMs))
-  const terminal = all.filter((d) => d.state !== 'running').slice(0, maxTerminal)
-  return [...running, ...terminal]
+  const { active, recent } = splitDelegationList(all, maxTerminal, now, staleThresholdMs)
+  return [...active, ...recent]
 }
 
 /** Default stale-running threshold: 30 minutes. */
@@ -1261,10 +1294,11 @@ export function fmtElapsed(ms: number): string {
   return `${seconds}s`
 }
 
-/** Elapsed label for one entry: running → ticks `now - startedAt`, terminal
- *  → fixed `updatedAt - startedAt` (em dash when no finalized timestamp). */
+/** 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). */
 export function delegationElapsed(entry: DelegationEntry, now: number): string {
-  if (entry.state === 'running' || entry.state === 'stale-running')
+  if (entry.state === 'running' || entry.state === 'retry' || entry.state === 'stale-running')
     return fmtElapsed(now - entry.startedAt)
   return entry.updatedAt !== null ? fmtElapsed(entry.updatedAt - entry.startedAt) : '\u2014'
 }
@@ -1294,6 +1328,7 @@ export function delegationActivity(entry: DelegationEntry): DelegationActivity {
 }
 
 export function delegationActivityLabel(entry: DelegationEntry): string {
+  if (entry.state === 'retry') return 'RETRYING'
   switch (delegationActivity(entry)) {
     case 'delegating':
       return 'DELEGATING'
@@ -1312,12 +1347,96 @@ export function delegationActivityLabel(entry: DelegationEntry): string {
 
 const DELEGATION_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
 
-/** Return a deterministic spinner frame. The View ticks this every 140ms. */
+/** Return a deterministic spinner frame. The View ticks this every 1000ms
+ *  (not 140ms — the fast tick flickered without adding information). */
 export function delegationSpinnerFrame(now: number): string {
-  const index = Math.floor(Math.max(0, now) / 140) % DELEGATION_SPINNER_FRAMES.length
+  const index = Math.floor(Math.max(0, now) / 1_000) % DELEGATION_SPINNER_FRAMES.length
   return DELEGATION_SPINNER_FRAMES[index] ?? DELEGATION_SPINNER_FRAMES[0]
 }
 
+/* ─── Live tool activity per child session (beta.6) ────────────────────────
+ *  The delegation panel's activity line ("↳ bash npm test") — what the agent
+ *  is doing RIGHT NOW. Sourced from message.part.updated tool parts: every
+ *  pending/running tool part updates a per-child-session record (latest wins).
+ *  Module-level by design: the sidebar remounts on route changes and the
+ *  "what is each agent doing" state should survive that (OMO pattern). */
+
+export type ToolActivity = {
+  tool: string
+  summary: string
+  at: number
+}
+
+/** Bounded tracker: child session id → latest running tool call. */
+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 ''
+  const candidates = ['command', 'description', 'prompt', 'filePath', 'pattern', 'url', 'query']
+  for (const key of candidates) {
+    const value = input[key]
+    if (typeof value === 'string' && value.trim() !== '') return value
+  }
+  return ''
+}
+
+/** 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. */
+export function extractToolActivity(
+  part: {
+    type?: string
+    tool?: string
+    sessionID?: string
+    state?: { status?: string; input?: Record<string, unknown> }
+  },
+  now = Date.now(),
+): { sessionID: string; activity: ToolActivity } | null {
+  if (part?.type !== 'tool') return null
+  const status = part.state?.status
+  if (status !== 'pending' && status !== 'running') return null
+  const sessionID = typeof part.sessionID === 'string' ? part.sessionID : ''
+  if (sessionID === '') return null
+  const tool = typeof part.tool === 'string' && part.tool !== '' ? part.tool : 'tool'
+  const summary = summarizeToolInput(part.state?.input).replace(/\s+/g, ' ').trim().slice(0, 48)
+  return { sessionID, activity: { tool, summary, at: now } }
+}
+
+/** Record an activity sample (bounded map, oldest dropped). */
+export function trackToolActivity(
+  map: Map<string, ToolActivity>,
+  sessionID: string,
+  activity: ToolActivity,
+): void {
+  if (sessionID === '') return
+  if (map.size >= MAX_TOOL_ACTIVITY_ENTRIES) {
+    const oldest = map.keys().next().value
+    if (oldest !== undefined) map.delete(oldest)
+  }
+  map.set(sessionID, activity)
+}
+
+/** Latest live activity for a child session, or null when absent/stale. */
+export function latestToolActivityFor(
+  map: Map<string, ToolActivity>,
+  sessionID: string | undefined,
+  now = Date.now(),
+  ttlMs = TOOL_ACTIVITY_TTL_MS,
+): ToolActivity | null {
+  if (!sessionID) return null
+  const hit = map.get(sessionID)
+  if (hit === undefined) return null
+  if (now - hit.at > ttlMs) return null
+  return hit
+}
+
 /** Merge the immediate tool-event channel into the child-session channel.
  *
  * Children remain the durable source, while live entries make a delegation
@@ -1405,9 +1524,11 @@ export function mergeChildDelegationSources(
  * Source of truth for jobs born while opencode is open. The TUI event bus
  * (api.event.on) delivers `message.part.updated` for every part change;
  * we only care about tool parts whose `tool` is pantheon_delegate (job
- * launch) or pantheon_delegation_read (blocking until terminal → closes
- * the entry). Shape-adapted from the SDK v2 ToolPart but duck-typed so the
- * pure helpers are testable without the SDK. */
+ * launch), the native `task` subagent tool (same parentID === caller
+ * mechanism — its rows render `nat:`), or pantheon_delegation_read
+ * (blocking until terminal → closes the entry). Shape-adapted from the
+ * SDK v2 ToolPart but duck-typed so the pure helpers are testable without
+ * the SDK. */
 
 /** Duck-typed subset of a tool part (SDK v2 `ToolPart` / `ToolState`). */
 export type DelegationToolPart = {
@@ -1433,7 +1554,7 @@ export type LiveDelegationEntry = {
   partID: string
   /** Parent session the delegation was launched from. */
   sessionID: string
-  tool: 'pantheon_delegate' | 'pantheon_delegation_read'
+  tool: 'pantheon_delegate' | 'pantheon_delegation_read' | 'task'
   /** Agent name (from the delegate input args). */
   agent: string
   description: string
@@ -1453,7 +1574,7 @@ export type ParsedDelegationToolPart = {
   callID: string
   partID: string
   sessionID: string
-  tool: 'pantheon_delegate' | 'pantheon_delegation_read'
+  tool: 'pantheon_delegate' | 'pantheon_delegation_read' | 'task'
   /** null for read parts (no agent arg — the id targets an existing job). */
   agent: string | null
   description: string
@@ -1473,13 +1594,20 @@ const READ_ALIAS_PATTERN = /^[a-z]{2,8}-\d+$/i
 
 /** Extract the tool name + args from a `message.part.updated` part and
  *  reduce it to what the panel needs. Returns null for anything that is
- *  not a pantheon delegation tool part (or is missing its callID). */
+ *  not a pantheon delegation tool part, the native `task` subagent tool
+ *  (same parentID === caller mechanism — its children render `nat:`),
+ *  or is missing its callID. */
 export function parseDelegationToolPart(
   part: DelegationToolPart,
   now = Date.now(),
 ): ParsedDelegationToolPart | null {
   if (part.type !== 'tool') return null
-  if (part.tool !== 'pantheon_delegate' && part.tool !== 'pantheon_delegation_read') return null
+  if (
+    part.tool !== 'pantheon_delegate' &&
+    part.tool !== 'pantheon_delegation_read' &&
+    part.tool !== 'task'
+  )
+    return null
   const callID = part.callID
   if (callID === undefined || callID === '') return null
   const sessionID = part.sessionID ?? ''
@@ -1514,10 +1642,22 @@ export function parseDelegationToolPart(
     }
   }
 
-  const agent = typeof input.agent === 'string' ? input.agent : 'agent'
-  const description = typeof input.description === 'string' ? input.description : ''
+  const agent =
+    typeof input.agent === 'string'
+      ? input.agent
+      : typeof input.subagent_type === 'string'
+        ? (input.subagent_type as string)
+        : 'agent'
+  const description =
+    typeof input.description === 'string'
+      ? input.description
+      : typeof input.prompt === 'string'
+        ? (input.prompt as string).slice(0, 120)
+        : ''
   // The alias/taskID only exist once the delegate tool COMPLETES (they are
-  // returned in its output); a running/pending part has neither.
+  // 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:`.
   let alias: string | null = null
   let taskID: string | null = null
   if (status === 'completed') {
@@ -1529,7 +1669,7 @@ export function parseDelegationToolPart(
     callID,
     partID: part.id ?? '',
     sessionID,
-    tool: 'pantheon_delegate',
+    tool: part.tool === 'task' ? 'task' : 'pantheon_delegate',
     agent,
     description,
     status,
@@ -1587,9 +1727,11 @@ export function reduceDelegationToolPart(
     return changed
   }
 
-  // Delegate tool: pending/running → 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.
+  // Delegate tool (pantheon_delegate AND native task): pending/running →
+  // 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.
   const existing = map.get(parsed.callID)
   if (parsed.status === 'error') {
     if (existing !== undefined && existing.state === 'error' && existing.updatedAt === parsed.endAt)
@@ -1598,7 +1740,7 @@ export function reduceDelegationToolPart(
       callID: parsed.callID,
       partID: parsed.partID,
       sessionID: parsed.sessionID,
-      tool: 'pantheon_delegate',
+      tool: parsed.tool,
       agent: parsed.agent ?? 'agent',
       description: parsed.description,
       alias: existing?.alias ?? null,
@@ -1615,7 +1757,7 @@ export function reduceDelegationToolPart(
       callID: parsed.callID,
       partID: parsed.partID,
       sessionID: parsed.sessionID,
-      tool: 'pantheon_delegate',
+      tool: parsed.tool,
       agent: parsed.agent ?? 'agent',
       description: parsed.description,
       alias: parsed.alias,
@@ -1668,11 +1810,14 @@ export function removeDelegationEntry(
   return false
 }
 
-/** Collect pantheon delegation tool parts from a session's messages.
+/** Collect pantheon delegation + 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
- *  SDK exposes `api.state.part(messageID)`). Pure w.r.t. I/O — used by the
- *  mount re-scan to re-seed the live map after compaction/attach. */
+ *  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
+ *  by the mount re-scan to re-seed the live map after compaction/attach. */
 export function collectDelegationToolParts(
   messages: readonly { id?: string; parts?: unknown[] }[] | undefined,
   getParts?: (messageID: string) => readonly unknown[] | undefined,
@@ -1690,7 +1835,9 @@ export function collectDelegationToolParts(
       const part = raw as DelegationToolPart
       if (
         part?.type === 'tool' &&
-        (part.tool === 'pantheon_delegate' || part.tool === 'pantheon_delegation_read')
+        (part.tool === 'pantheon_delegate' ||
+          part.tool === 'pantheon_delegation_read' ||
+          part.tool === 'task')
       ) {
         out.push(part)
       }
@@ -1880,19 +2027,139 @@ export type ChildDelegationLike = {
  *  (the child is actively working), idle → completed, unknown → running
  *  (fail-open: a freshly-seen child is assumed active; the 1s poll + md
  *  correct it as soon as terminal data exists). */
-export function childStatusToState(status: string | undefined): 'running' | 'completed' {
+export function childStatusToState(status: string | undefined): 'running' | 'completed' | 'retry' {
   if (status === 'idle') return 'completed'
-  return 'running' // busy, retry, or unknown
+  if (status === 'retry') return 'retry'
+  return 'running' // busy or unknown
 }
 
-/** Row tag for a delegation entry: `[native]` for native task() children
- *  (source 'children-only' — no board report), `[pantheon:<alias>]` for board
- *  rows ([pantheon:apo-1]) — the same tags the manager prints in
- *  pantheon_delegation_list, so panel rows and CLI list lines match. The
- *  panel renders the tag with a distinct style so native task() children are
- *  visually separable from pantheon_delegate jobs. */
+/** 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}):
+ *
+ *  - `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' ? '[native]' : `[pantheon:${entry.alias}]`
+  return entry.source === 'children-only' ? `nat:${entry.agent}` : `pan:${entry.alias}`
+}
+
+/** 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'
+}
+
+/** 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}`
+}
+
+/** Max description width on the row detail line — the old 180-char slice
+ *  wrapped the sidebar; 44 keeps one readable line. */
+export const DELEGATION_DESCRIPTION_MAX = 44
+
+/** Lazily-built grapheme segmenter. `Intl.Segmenter` keeps ZWJ emoji families
+ *  (and skin-tone/variation sequences) intact; `Array.from` (code points) is
+ *  the fallback for runtimes without it. */
+let graphemeSegmenter: Intl.Segmenter | undefined
+
+/** Split `text` into display graphemes so truncation never cuts a multi-unit
+ *  emoji in half (surrogate pair → mojibake). */
+function splitGraphemes(text: string): string[] {
+  if (typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function') {
+    graphemeSegmenter ??= new Intl.Segmenter('pt', { granularity: 'grapheme' })
+    return Array.from(graphemeSegmenter.segment(text), (s) => s.segment)
+  }
+  return Array.from(text)
+}
+
+/** 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. */
+export function truncateDelegationDescription(
+  text: string,
+  max = DELEGATION_DESCRIPTION_MAX,
+): string {
+  const graphemes = splitGraphemes(text)
+  if (graphemes.length <= max) return text
+  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
+ *  the box is returned untouched. Pure. */
+export const DELEGATION_ELAPSED_WIDTH = 8
+
+export function formatDelegationElapsed(
+  entry: DelegationEntry,
+  now: number,
+  width = DELEGATION_ELAPSED_WIDTH,
+): string {
+  const label = delegationElapsed(entry, now)
+  if (label.length >= width) return label
+  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)}`
+}
+
+// Tree connectors (`isNestedDelegation` / `delegationTreePrefix`) were removed
+// as dead code: `session.children` returns direct children only, so no row is
+// 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. */
+export function formatDelegationHeader(entries: readonly DelegationEntry[]): string {
+  let active = 0
+  for (const e of entries) {
+    if (e.state === 'running' || e.state === 'retry' || e.state === 'stale-running') active++
+  }
+  const done = entries.length - active
+  const counts = countDelegationSources(entries)
+  return `(${active} active \u00b7 ${done} done \u00b7 nat:${counts.native} pan:${counts.pantheon})`
+}
+
+/** 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. */
+export function countDelegationSources(entries: readonly DelegationEntry[]): {
+  native: number
+  pantheon: number
+  total: number
+} {
+  let native = 0
+  for (const e of entries) if (e.source === 'children-only') native++
+  return { native, pantheon: entries.length - native, total: entries.length }
+}
+
+/** Diagnostic hooks.log line for a panel re-fetch, with the children
+ *  breakdown (pantheon = children WITH a board report, native = children
+ *  WITHOUT one). Pure — the View logs the returned string verbatim. */
+export function formatPanelLogLine(
+  children: number,
+  pantheon: number,
+  native: number,
+  md: number,
+  events: number,
+): string {
+  return `panel: children=${children}(pantheon=${pantheon} native=${native}) md=${md} events=${events}`
 }
 
 /** Turn child sessions (PRIMARY) enriched with md reports into the display
@@ -1903,10 +2170,14 @@ export function delegationTag(entry: DelegationEntry): string {
  *  itself (fallback 'agent'), state derived from its status, startedAt from
  *  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'
- *  and the `[native]` tag instead of a board alias.
+ *  tool — carries parentID = caller), so it gets source 'children-only',
+ *  the internal alias 'native-task' and the `nat:` tag 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. Sorted running-first (compareDelegationEntries).
+ *  the child's live status. A running child is NEVER archived — it always
+ *  lands in the active split (splitDelegationList active = running/retry).
+ *  Sorted running-first (compareDelegationEntries).
  *  Pure — no I/O. */
 export function childrenToDelegationEntries(
   children: readonly ChildDelegationLike[] | undefined,
@@ -1928,7 +2199,7 @@ export function childrenToDelegationEntries(
         ? mdEntry.state
         : childStatusToState(child.status)
     out.push({
-      alias: mdEntry?.alias ?? 'task',
+      alias: mdEntry?.alias ?? 'native-task',
       sessionID: mdEntry?.sessionID ?? '',
       taskID: child.id,
       agent: mdEntry?.agent ?? child.agent ?? 'agent',
@@ -1941,7 +2212,9 @@ export function childrenToDelegationEntries(
       description:
         mdEntry !== undefined && mdEntry.description !== ''
           ? mdEntry.description
-          : (child.title ?? ''),
+          : child.title !== undefined && child.title !== ''
+            ? child.title
+            : 'task nativa',
       source: mdEntry !== undefined ? 'md' : 'children-only',
     })
   }
@@ -2007,8 +2280,19 @@ function createTuiLogger(projectRoot: string | undefined, module = 'pantheon-tui
           `${lines.map((l) => `[${stamp}] [${module}] ${l}`).join('\n')}\n`,
           'utf8',
         )
-      } catch {
-        /* best-effort file log — never break the panel over logging */
+      } catch (err) {
+        /* best-effort file log — never break the panel over logging, but do
+         * NOT swallow the failure silently: a missing symbol here (e.g.
+         * `appendFile` used without an import) previously threw an invisible
+         * ReferenceError and the log silently stopped writing. Gated by the
+         * echo flag to avoid the TUI-pollution bug described above. */
+        if (echo) {
+          try {
+            process.stderr.write(`[${module}] file-log failed: ${formatArg(err)}\n`)
+          } catch {
+            /* stderr unavailable — never break the panel */
+          }
+        }
       }
     })()
     if (echo) {
@@ -2070,6 +2354,8 @@ function DelegationRow(props: {
     switch (props.job.state) {
       case 'running':
         return t.warning
+      case 'retry':
+        return t.warning
       case 'stale-running':
         return t.error // warning color for stale delegations
       case 'completed':
@@ -2083,6 +2369,7 @@ function DelegationRow(props: {
 
   const marker = createMemo(() => {
     if (props.job.state === 'running') return `${delegationSpinnerFrame(props.animationNow)} `
+    if (props.job.state === 'retry') return '\u27f3 ' // ⟳ retrying
     if (props.job.state === 'stale-running') return '\u26a0 ' // warning triangle
     switch (props.job.state) {
       case 'completed':
@@ -2094,17 +2381,20 @@ function DelegationRow(props: {
     }
   })
 
-  // The row tag: `[native]` for native task() children (no board report),
-  // `[pantheon:apo-1]`-style alias for pantheon_delegate board rows. Rendered with
-  // the info color so task() children are visually distinct from delegates.
+  // 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 detail = createMemo(() => {
-    const elapsed = delegationElapsed(props.job, props.now)
-    const description = props.job.description !== '' ? ` \u2014 ${props.job.description}` : ''
-    const line = `${elapsed}${description}`
-    return line.length > 180 ? `${line.slice(0, 177)}\u2026` : line
-  })
+  const description = createMemo(() => truncateDelegationDescription(props.job.description))
+  const elapsed = createMemo(() => formatDelegationElapsed(props.job, props.now))
+
+  // 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.
+  const activity = createMemo(() =>
+    latestToolActivityFor(latestToolActivity, props.job.taskID, props.now),
+  )
 
   // Click a row → navigate to the child session (route API guarded in the
   // helper). Enter-key binding is left out (per-row keymap wiring is not
@@ -2116,13 +2406,23 @@ function DelegationRow(props: {
   return (
     <box onMouseDown={open}>
       <box flexDirection="row">
-        <text fg={color()}>{marker()}</text>
-        <text fg={tagColor()}>{delegationTag(props.job)}</text>
-        <text
-          fg={color()}
-        >{` ${props.job.agent} \u2014 ${delegationActivityLabel(props.job)}`}</text>
+        <text fg={tagColor()}>{formatDelegationRow(props.job, marker())}</text>
       </box>
-      <text fg={theme().textMuted}>{detail()}</text>
+      {/* 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>
+      </box>
+      <Show when={activity()}>
+        {(a) => (
+          <text
+            fg={theme().textMuted}
+          >{`  \u21b3 ${truncateDelegationDescription(`${a().tool}${a().summary !== '' ? ` ${a().summary}` : ''}`)}`}</text>
+        )}
+      </Show>
     </box>
   )
 }
@@ -2249,9 +2549,10 @@ function View(props: {
   // remains on the 1s ticker to avoid unnecessary work.
   const [animationNow, setAnimationNow] = createSignal(Date.now())
   // Cumulative count of event-triggered refreshes — logged with every fetch
-  // ("panel: children=N md=N events=N") so the (0) symptom is diagnosable:
-  // children>0 means the source works; events=0 means the event bus isn't
-  // delivering, and the 1s poll is what keeps the panel honest.
+  // ("panel: children=N(pantheon=M native=K) md=N events=N") so the (0)
+  // symptom is diagnosable: children>0 means the source works; events=0
+  // means the event bus isn't delivering, and the 1s poll is what keeps
+  // the panel honest.
   let eventRefreshCount = 0
   // In-flight guard: overlap between the poll, events and the version effect
   // collapses into one fetch — no duplicate work, no duplicate entries.
@@ -2283,7 +2584,7 @@ function View(props: {
         if (sessionID === null) {
           setChildDelegations(md)
           panelLog.info(
-            `panel: children=0 md=${md.length} events=${eventRefreshCount} (no sessionID — history shown)`,
+            `${formatPanelLogLine(0, 0, 0, md.length, eventRefreshCount)} (no sessionID — history shown)`,
           )
           return
         }
@@ -2326,8 +2627,15 @@ function View(props: {
         )
         setChildDelegations(mergeChildDelegationSources(childEntries, liveEntries))
         // 4. diagnostic line — every re-fetch (silence-by-default, hooks.log).
+        const counts = countDelegationSources(childEntries)
         panelLog.info(
-          `panel: children=${children.length} md=${md.length} events=${eventRefreshCount}`,
+          formatPanelLogLine(
+            children.length,
+            counts.pantheon,
+            counts.native,
+            md.length,
+            eventRefreshCount,
+          ),
         )
       } finally {
         delegationsInflight = null
@@ -2335,9 +2643,24 @@ function View(props: {
     })()
     return delegationsInflight
   }
-  // Running jobs first, then the 8 most recent terminal reports. The header
-  // count uses this same "running + recentes" list.
-  const visibleDelegations = createMemo(() => visibleDelegationList(childDelegations()))
+  // 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)".
+  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(() => {
@@ -2385,7 +2708,7 @@ function View(props: {
       void refreshDelegations()
     }, 1_000)
     cleanup.push(() => clearInterval(poll))
-    const animation = setInterval(() => setAnimationNow(Date.now()), 140)
+    const animation = setInterval(() => setAnimationNow(Date.now()), 1_000)
     cleanup.push(() => clearInterval(animation))
 
     // Compaction recovery: `message.part.removed` clears live entries while
@@ -2480,9 +2803,9 @@ function View(props: {
       {/* ── Delegations (session.children primary + .pantheon/delegations md enrichment) ── */}
       <box onMouseDown={() => setShowDelegations((x) => !x)}>
         <text fg={theme().text} attributes={1}>
-          {`${showDelegations() ? '\u25bc' : '\u25b6'} Delegations`}
+          {`${showDelegations() ? '▼' : '▶'} Delegations`}
         </text>
-        <text fg={theme().textMuted}>{` (${String(visibleDelegations().length)})`}</text>
+        <text fg={theme().textMuted}>{` ${delegationHeader()}`}</text>
       </box>
       <Show when={showDelegations()}>
         <Show
@@ -2504,6 +2827,41 @@ 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>
           </box>
         </Show>
       </Show>
@@ -2552,6 +2910,11 @@ const tui: TuiPlugin = (api, _options, _meta) => {
         const props = (event?.properties ?? {}) as { part?: unknown; info?: { part?: unknown } }
         const part = (props.part ?? props.info?.part) as DelegationToolPart | undefined
         if (part === undefined) return
+        // beta.6: track the live tool call per child session (panel's
+        // activity line). Fire-and-forget — display-only state.
+        const sample = extractToolActivity(part as any)
+        if (sample !== null)
+          trackToolActivity(latestToolActivity, sample.sessionID, sample.activity)
         if (reduceDelegationToolPart(liveStore.map, part)) liveStore.bump()
       }),
     )