pantheon-opencode 1.5.0-beta.5 → 1.5.0-beta.7

package/src/pantheon/cost-command.ts

@@ -15,14 +15,19 @@
  *
  * @module cost-command
  */
-import { existsSync } from 'node:fs'
+import { execFile } from 'node:child_process'
+import { accessSync, constants, existsSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { join } from 'node:path'
+import { delimiter, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { z } from 'zod'
 
 import type { ToolContextLike } from './delegation.ts'
 import type { NativeTaskStatus } from './native-task-status.ts'
 
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
 /** One aggregated token row (per agent and phase). */
 export interface CostRow {
   agent: string
@@ -37,6 +42,8 @@ export interface CostCommandOptions {
   dbPath?: string
   /** Injectable loader for tests; production always loads node:sqlite. */
   sqliteLoader?: () => Promise<SqliteModule>
+  /** Injectable CLI-fallback process boundary (tests / unusual runtimes). */
+  cliFallback?: CliFallbackDeps
 }
 
 export type OpenCodeVersion = 'v1' | 'v2'
@@ -220,6 +227,230 @@ function renderMarkdown(rows: readonly CostRow[], days: number): string {
   return lines.join('\n')
 }
 
+// ─── CLI fallback: resolve a REAL Node, not the plugin runtime ──────────
+//
+// Under Bun (the runtime that motivates this fallback), process.execPath IS
+// the Bun binary, which has no node:sqlite — so spawning it could never work.
+// Resolve a genuine Node instead: PANTHEON_NODE → `node` on PATH → clear error.
+
+/** First Node release exposing the built-in `node:sqlite` module. */
+const NODE_SQLITE_MIN_VERSION = '22.5'
+
+/** Minimal injectable child-process boundary (tests / unusual runtimes). */
+export type ExecFileLike = (
+  file: string,
+  args: readonly string[],
+) => Promise<{ stdout: string; stderr?: string }>
+
+/** Injectables so the fallback never depends on the real machine in tests. */
+export interface CliFallbackDeps {
+  /** Environment for PANTHEON_NODE / PATH lookup. Default: process.env. */
+  env?: NodeJS.ProcessEnv
+  /** Child-process boundary. Default: node:child_process.execFile. */
+  execFile?: ExecFileLike
+  /** Executable predicate used by the PANTHEON_NODE / PATH lookups. */
+  isExecutable?: (path: string) => boolean
+}
+
+/** A real Node executable located for the CLI fallback. */
+export interface ResolvedNode {
+  path: string
+  source: 'env' | 'path'
+}
+
+type ExecFailure = Error & { stdout?: string; stderr?: string }
+
+function defaultIsExecutable(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK)
+    return statSync(path).isFile()
+  } catch {
+    return false
+  }
+}
+
+function defaultExecFile(
+  file: string,
+  args: readonly string[],
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(file, [...args], { encoding: 'utf8' }, (error, stdout, stderr) => {
+      if (error) {
+        // execFile's callback error does not always carry the captured output;
+        // attach it so callers can surface cost.mjs's structured {ok:false}.
+        const failure = error as ExecFailure
+        if (typeof failure.stdout !== 'string') failure.stdout = stdout
+        if (typeof failure.stderr !== 'string') failure.stderr = stderr
+        reject(failure)
+        return
+      }
+      resolve({ stdout, stderr })
+    })
+  })
+}
+
+/** Scan PATH (no shell) for a `node` executable. */
+export function resolveNodeFromPath(
+  env: NodeJS.ProcessEnv,
+  isExecutable: (path: string) => boolean = defaultIsExecutable,
+): string | undefined {
+  const pathValue = env.PATH ?? env.Path ?? ''
+  if (pathValue === '') return undefined
+  const isWindows = process.platform === 'win32'
+  const extensions = isWindows
+    ? (env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter((ext) => ext !== '')
+    : ['']
+  for (const dir of pathValue.split(delimiter)) {
+    if (dir === '') continue
+    for (const ext of extensions) {
+      const candidate = join(dir, `node${ext}`)
+      if (isExecutable(candidate)) return candidate
+    }
+  }
+  return undefined
+}
+
+/**
+ * Resolve a REAL Node.js binary for the CLI fallback.
+ *
+ * Order: PANTHEON_NODE (must exist and be executable — an explicit override
+ * that is unusable fails fast instead of being silently ignored) → `node`
+ * from PATH. Returns undefined only when neither source is available.
+ */
+export function resolveNodeExecutable(
+  env: NodeJS.ProcessEnv = process.env,
+  isExecutable: (path: string) => boolean = defaultIsExecutable,
+): ResolvedNode | undefined {
+  const explicit = env.PANTHEON_NODE
+  if (explicit !== undefined && explicit.trim() !== '') {
+    if (isExecutable(explicit)) return { path: explicit, source: 'env' }
+    throw new Error(
+      `PANTHEON_NODE is set to "${explicit}" but that is not an existing executable file`,
+    )
+  }
+  const fromPath = resolveNodeFromPath(env, isExecutable)
+  return fromPath === undefined ? undefined : { path: fromPath, source: 'path' }
+}
+
+function execErrorMessage(err: unknown): string {
+  if (err instanceof Error) {
+    const failure = err as ExecFailure
+    const stderr = typeof failure.stderr === 'string' ? failure.stderr.trim() : ''
+    if (stderr !== '') return stderr
+    return failure.message
+  }
+  return String(err)
+}
+
+function tryParseJson(text: string): unknown {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
+function truncateForError(text: string): string {
+  const trimmed = text.trim()
+  return trimmed.length > 200 ? `${trimmed.slice(0, 200)}…` : trimmed
+}
+
+/** Probe the resolved binary for built-in node:sqlite support. */
+async function assertNodeSqliteSupport(
+  nodePath: string,
+  execFileAsync: ExecFileLike,
+): Promise<void> {
+  try {
+    await execFileAsync(nodePath, ['-e', "require('node:sqlite')"])
+  } catch (err: unknown) {
+    throw new Error(
+      `resolved Node binary "${nodePath}" does not support node:sqlite (Node.js >= ${NODE_SQLITE_MIN_VERSION} required): ${execErrorMessage(err)}`,
+    )
+  }
+}
+
+/** Pull the structured failure message cost.mjs prints to stdout (exit 1). */
+function extractScriptFailure(err: unknown): string {
+  const failure = err as { stdout?: unknown; stderr?: unknown }
+  const stdout = typeof failure.stdout === 'string' ? failure.stdout : ''
+  const parsed = tryParseJson(stdout)
+  if (parsed !== null && typeof parsed === 'object') {
+    const record = parsed as { ok?: unknown; error?: unknown }
+    if (record.ok === false && typeof record.error === 'string' && record.error !== '') {
+      return record.error
+    }
+  }
+  const stderr = typeof failure.stderr === 'string' ? failure.stderr.trim() : ''
+  if (stderr !== '') return stderr
+  return execErrorMessage(err)
+}
+
+/**
+ * Spawn `node scripts/cost.mjs` as a CLI fallback when node:sqlite is
+ * unavailable in the plugin process (e.g. Bun runtime). Returns CostRow[] by
+ * parsing the JSON the script writes to stdout.
+ *
+ * Resolves a REAL Node binary (PANTHEON_NODE → PATH): process.execPath under
+ * Bun is the Bun binary, which cannot run node:sqlite. The resolved binary is
+ * probed for node:sqlite support and the script is always run read-only with
+ * an argument array (never a shell).
+ */
+export async function queryWithCliFallback(
+  dbPath: string,
+  days: number,
+  deps?: CliFallbackDeps,
+): Promise<CostRow[]> {
+  const env = deps?.env ?? process.env
+  const execFileAsync = deps?.execFile ?? defaultExecFile
+  const isExecutable = deps?.isExecutable ?? defaultIsExecutable
+
+  const costScript = join(__dirname, '..', '..', 'scripts', 'cost.mjs')
+  if (!existsSync(costScript)) {
+    throw new Error(`CLI fallback script not found: ${costScript}`)
+  }
+
+  const node = resolveNodeExecutable(env, isExecutable)
+  if (node === undefined) {
+    throw new Error(
+      `no Node.js executable found for the node:sqlite CLI fallback: set PANTHEON_NODE to a Node.js >= ${NODE_SQLITE_MIN_VERSION} binary or put "node" on PATH`,
+    )
+  }
+
+  await assertNodeSqliteSupport(node.path, execFileAsync)
+
+  let stdout: string
+  try {
+    ;({ stdout } = await execFileAsync(node.path, [
+      costScript,
+      '--db-path',
+      dbPath,
+      '--days',
+      String(days),
+    ]))
+  } catch (err: unknown) {
+    // cost.mjs sets exitCode=1 (execFile rejects) and writes {ok:false,error}
+    // to stdout before exiting — surface that structured failure.
+    throw new Error(`CLI fallback failed: ${extractScriptFailure(err)}`)
+  }
+
+  const parsed = tryParseJson(stdout)
+  if (parsed === null || typeof parsed !== 'object') {
+    throw new Error(`CLI fallback returned non-JSON output: ${truncateForError(stdout)}`)
+  }
+  const record = parsed as { ok?: unknown; rows?: unknown; error?: unknown }
+  if (record.ok !== true) {
+    const detail =
+      typeof record.error === 'string' && record.error !== ''
+        ? record.error
+        : 'unexpected response shape from scripts/cost.mjs'
+    throw new Error(`CLI fallback failed: ${detail}`)
+  }
+  if (!Array.isArray(record.rows)) {
+    throw new Error('CLI fallback failed: scripts/cost.mjs response is missing the rows array')
+  }
+  return record.rows as CostRow[]
+}
+
 export function createCostCommand(options?: CostCommandOptions): CostCommand {
   const loadSqlite =
     options?.sqliteLoader ?? (async () => (await import('node:sqlite')) as SqliteModule)
@@ -269,7 +500,22 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
           `opencode.db not found (expected at ${expected}). No token history is available until opencode has stored session data.`,
         )
       }
-      const sqlite = await loadSqlite()
+      let sqlite: SqliteModule | undefined
+      try {
+        sqlite = await loadSqlite()
+      } catch (loadErr: unknown) {
+        // node:sqlite unavailable (e.g. Bun runtime) — fall back to CLI.
+        const status = statusForError(loadErr)
+        if (status === 'UNSUPPORTED') {
+          try {
+            const rows = await queryWithCliFallback(dbPath, days, options?.cliFallback)
+            return `status: OK\n${renderMarkdown(rows, days)}`
+          } catch (cliErr: unknown) {
+            return failure(statusForError(cliErr), diagnostic(cliErr))
+          }
+        }
+        throw loadErr
+      }
       const rows = await queryWithNodeSqlite(dbPath, days, sqlite)
       return `status: OK\n${renderMarkdown(rows, days)}`
     } catch (err: unknown) {

package/src/pantheon/delegation-finalize.ts

@@ -144,9 +144,25 @@ export interface DelegationOptions {
   promptTimeoutMs?: number
   /** Poll interval used by the bootstrap watchdog. */
   bootstrapPollIntervalMs?: number
+  /**
+   * Max completed jobs to keep per agent after pruning (default: 10).
+   * Matches the native delegate-manager default.
+   */
+  keepCompleted?: number
+  /**
+   * Hard cap on total board entries (default: 50).
+   * Matches the native delegate-manager default.
+   */
+  maxEntries?: number
   /** Injectable clock/sleeper for deterministic watchdog tests. */
   now?: () => number
   sleep?: (ms: number) => Promise<void>
+  /**
+   * Kill-switch: when false, all delegation tools (delegate/read/list) throw
+   * immediately. Mirrors `PANTHEON_DELEGATION=off` from the native manager.
+   * Defaults to true (delegation enabled) when not specified.
+   */
+  delegationEnabled?: boolean
 }
 
 /** Dependencies threaded to the finalize path. */
@@ -370,5 +386,21 @@ export async function finalizeDelegation(
     // Terminal in a DIFFERENT state (e.g. timeout already recorded) — the
     // report above still captures this finalize; the board state stands.
   }
+
+  // P1-1: Delete the auto-wake signal file to prevent leaks. The board
+  // writes .signal.json on every terminal transition, but the legacy path
+  // never called deleteSignal — only the native delegate-manager did.
+  // The consumer (auto-wake.ts consumeWakeSignals) is intentionally NOT
+  // wired in the event hook: finalizeDelegation already handles the
+  // terminal transition, so consuming signals would be redundant and risks
+  // double-processing. deleteSignal on finalize is sufficient.
+  await deps.board.deleteSignal(job.alias)
+
+  // P1-4: Prune old completed jobs and enforce the hard entry cap. The
+  // native delegate-manager called these in settle(), but the legacy
+  // finalize path omitted them, allowing unbounded board growth.
+  await deps.board.pruneCompleted(deps.options.keepCompleted ?? 10)
+  await deps.board.enforceEntryCap(deps.options.maxEntries ?? 50)
+
   return deps.board.get(childSessionID) ?? job
 }

package/src/pantheon/delegation.ts

@@ -740,10 +740,54 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
     return finalizeDelegationReport(deps, childSessionID, opts)
   }
 
+  // Kill-switch gate: when delegationEnabled is explicitly false (mirrors
+  // PANTHEON_DELEGATION=off from the native manager), all legacy tools throw.
+  function guardEnabled(): void {
+    if (options.delegationEnabled === false) {
+      throw new Error('pantheon delegation disabled (PANTHEON_DELEGATION=off)')
+    }
+  }
+
+  /**
+   * Best-effort teardown of a child session whose `registerLaunch` was refused
+   * because the per-agent concurrency limit was hit between the pre-check and
+   * the registration (a race with another concurrent dispatch). Removes every
+   * side effect of the aborted dispatch — known-child marker, read-only
+   * registry entry and any reserved budget slot — then deletes the session when
+   * the host client exposes `session.delete`. Never throws: cleanup must not
+   * mask the original rejection.
+   */
+  async function abortRejectedLaunch(
+    childSessionID: string,
+    wasReadOnly: boolean,
+    refund?: { key: string | undefined; reserved: boolean },
+  ): Promise<void> {
+    knownChildren.delete(childSessionID)
+    if (wasReadOnly) readOnlyRegistry.unregister(childSessionID)
+    if (refund?.reserved && refund.key !== undefined) {
+      budgetUsage.set(refund.key, Math.max(0, (budgetUsage.get(refund.key) ?? 1) - 1))
+    }
+    // The plugin's adapted client (adaptDelegationClient) does not expose
+    // session.delete, and older hosts may not either. Delete best-effort so the
+    // abandoned session is not left behind; the registry cleanup above already
+    // removes the side effects that matter for read-only enforcement.
+    const session = client.session as {
+      delete?: (input: { path: { id: string } }) => Promise<unknown>
+    }
+    if (typeof session.delete !== 'function') return
+    try {
+      await session.delete({ path: { id: childSessionID } })
+    } catch (err: unknown) {
+      const reason = err instanceof Error ? err.message : String(err)
+      log.warn(`[pantheon-delegate] failed to delete orphan session ${childSessionID}: ${reason}`)
+    }
+  }
+
   const pantheon_delegate: DelegationTool<typeof delegateArgs> = {
     description: buildDelegateDescription(options),
     args: delegateArgs,
     execute: async (args, ctx) => {
+      guardEnabled()
       if (!isRootSession(ctx.sessionID)) {
         throw new Error(
           `pantheon_delegate rejected: session ${ctx.sessionID} is a sub-session — only root sessions can delegate`,
@@ -871,13 +915,27 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
         readOnlyRegistry.register(childSessionID, entry)
       }
 
-      const job = await board.registerLaunch({
-        taskID: childSessionID,
-        parentSessionID: ctx.sessionID,
-        agent: args.agent,
-        description: args.description ?? effectivePrompt,
-        objective: effectivePrompt,
-      })
+      let job: BackgroundJobRecord
+      try {
+        job = await board.registerLaunch({
+          taskID: childSessionID,
+          parentSessionID: ctx.sessionID,
+          agent: args.agent,
+          description: args.description ?? effectivePrompt,
+          objective: effectivePrompt,
+        })
+      } catch (err: unknown) {
+        // Concurrency race: another dispatch claimed the last slot after the
+        // pre-check above but before this registration. Undo every side effect
+        // of the aborted dispatch so no orphan session/registry survives, then
+        // surface a clear rejection.
+        const reason = err instanceof Error ? err.message : String(err)
+        await abortRejectedLaunch(childSessionID, readOnly, {
+          key: budgetKey,
+          reserved: budgetReserved,
+        })
+        return `pantheon_delegate rejected: ${reason}`
+      }
 
       // Timeout manager: cleared on finalize, unref'd so the timer never
       // keeps the process alive on its own.
@@ -968,13 +1026,34 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
       const retryID = retry.id
       knownChildren.add(retryID)
       options.registerChildSession?.(retryID, ctx.sessionID)
-      const retryJob = await board.registerLaunch({
-        taskID: retryID,
-        parentSessionID: ctx.sessionID,
-        agent: args.agent,
-        description: args.description ?? effectivePrompt,
-        objective: effectivePrompt,
-      })
+
+      // Phase 4 read-only enforcement for the retry: recalculate readOnly
+      // (same logic as the initial child at :866-872) and register the retry
+      // session so the plugin's tool.execute.before guard enforces it.
+      const retryReadOnly =
+        args.read_only === true || (options.readOnlyAgents?.has(args.agent.toLowerCase()) ?? false)
+      if (retryReadOnly) {
+        const entry: { agent: string; readOnlyFlag?: boolean } = { agent: args.agent }
+        if (args.read_only !== undefined) entry.readOnlyFlag = args.read_only
+        readOnlyRegistry.register(retryID, entry)
+      }
+
+      let retryJob: BackgroundJobRecord
+      try {
+        retryJob = await board.registerLaunch({
+          taskID: retryID,
+          parentSessionID: ctx.sessionID,
+          agent: args.agent,
+          description: args.description ?? effectivePrompt,
+          objective: effectivePrompt,
+        })
+      } catch (err: unknown) {
+        // Same race as the initial child: the retry registration can be
+        // refused. Clean up the retry session + registry entry before failing.
+        const reason = err instanceof Error ? err.message : String(err)
+        await abortRejectedLaunch(retryID, retryReadOnly)
+        return `pantheon_delegate rejected: ${reason} (retry)`
+      }
       const retryTimer = setTimeout(() => {
         timers.delete(retryID)
         void finalize(retryID, {
@@ -1035,6 +1114,7 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
       'Resolves by alias or task ID.',
     args: readArgs,
     execute: async (args, ctx) => {
+      guardEnabled()
       const job = board.resolve(ctx.sessionID, args.id)
       if (!job) {
         return `Unknown delegation "${args.id}" for this session. Use pantheon_delegation_list to see active delegations.`
@@ -1093,6 +1173,7 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
       'List background delegations for the current session, with [unread] for finished jobs.',
     args: listArgs,
     execute: async (_args, ctx) => {
+      guardEnabled()
       const jobs = board.list(ctx.sessionID)
       if (jobs.length === 0) return 'No background delegations for this session.'
 

package/src/pantheon/v2-events.ts

@@ -104,12 +104,20 @@ export function createV2EventDispatcher(deps: V2EventDeps): V2EventDispatcher {
             } else {
               // Native task(background=true) child: register on the board
               // atomically (skip if V1 idle hook or re-dispatch already claimed it).
-              await deps.board.registerLaunchIfAbsent({
-                taskID: info.id,
-                parentSessionID: info.parentID,
-                agent: 'native',
-                description: `native child ${info.id}`,
-              })
+              try {
+                await deps.board.registerLaunchIfAbsent({
+                  taskID: info.id,
+                  parentSessionID: info.parentID,
+                  agent: 'native',
+                  description: `native child ${info.id}`,
+                })
+              } catch (err) {
+                // The per-agent concurrency limit can refuse the launch. Do not
+                // abort the rest of the handler: this child is simply not
+                // mirrored on the board, while finalize/idle dispatch for every
+                // other event must still run.
+                log.warn(`[Pantheon V2] native child ${info.id} not mirrored on board:`, err)
+              }
             }
           }
         }

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

@@ -11,7 +11,7 @@ type DelegationEntry = {
   taskID?: string;
   /** Agent name, e.g. "apollo". */
   agent: string;
-  state: 'running' | 'completed' | 'error' | 'startup_failed' | 'startup_unknown' | 'cancelled' | 'stale-running';
+  state: 'running' | 'retry' | 'completed' | 'error' | 'startup_failed' | 'startup_unknown' | 'cancelled' | 'stale-running';
   /** Epoch ms of the `Started` header. */
   startedAt: number;
   /** Epoch ms of the `Finalized` header — null while still running. */
@@ -73,10 +73,18 @@ declare function tuiLogPath(projectRoot: string): string;
  *  falling back to startedAt, descending). Shared by the md reader and
  *  mergeDelegationSources. */
 declare function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry): number;
-/** 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. */
+declare function splitDelegationList(all: readonly DelegationEntry[], maxRecent?: number, now?: number, staleThresholdMs?: number): {
+  active: DelegationEntry[];
+  recent: DelegationEntry[];
+  archived: DelegationEntry[];
+};
+/** 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. */
 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;
@@ -106,6 +114,30 @@ declare function delegationActivity(entry: DelegationEntry): DelegationActivity;
 declare function delegationActivityLabel(entry: DelegationEntry): string;
 /** Return a deterministic spinner frame. The View ticks this every 140ms. */
 declare function delegationSpinnerFrame(now: number): string;
+type ToolActivity = {
+  tool: string;
+  summary: string;
+  at: number;
+};
+/** 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: {
+  type?: string;
+  tool?: string;
+  sessionID?: string;
+  state?: {
+    status?: string;
+    input?: Record<string, unknown>;
+  };
+}, now?: number): {
+  sessionID: string;
+  activity: ToolActivity;
+} | null;
+/** Record an activity sample (bounded map, oldest dropped). */
+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;
 /** Merge the immediate tool-event channel into the child-session channel.
  *
  * Children remain the durable source, while live entries make a delegation
@@ -278,7 +310,7 @@ 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). */
-declare function childStatusToState(status: string | undefined): 'running' | 'completed';
+declare function childStatusToState(status: string | undefined): 'running' | 'completed' | 'retry';
 /** 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
@@ -324,5 +356,5 @@ declare const plugin: TuiPluginModule & {
   setup: () => Promise<void>;
 };
 //#endregion
-export { ChildDelegationLike, DelegationActivity, DelegationEntry, DelegationToolPart, IDLE_SILENCE_MS, LiveDelegationEntry, LiveDelegationStore, ParsedDelegationToolPart, STALE_RUNNING_THRESHOLD_MS, TuiSessionSources, buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, fmtElapsed, isValidSessionId, markStaleIfRunning, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, safeSessionPath, seedLiveDelegationMap, toDelegationEntry, tuiLogPath, visibleDelegationList };
+export { ChildDelegationLike, DelegationActivity, DelegationEntry, DelegationToolPart, IDLE_SILENCE_MS, LiveDelegationEntry, LiveDelegationStore, ParsedDelegationToolPart, STALE_RUNNING_THRESHOLD_MS, ToolActivity, TuiSessionSources, buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, extractToolActivity, fmtElapsed, isValidSessionId, latestToolActivityFor, markStaleIfRunning, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, safeSessionPath, seedLiveDelegationMap, splitDelegationList, toDelegationEntry, trackToolActivity, tuiLogPath, visibleDelegationList };
 //# 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":";;KAo7BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EASA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBAkHmB,sBAAsB,cAAc,QAAQ;;;;;;;;iBAwC5C,yBAAyB,eAAe,QAAQ;;;;;;;;iBAWtD,sBACd;EAAS;EAAoB;eAC7B;;;;;;iBAYc,YAAY;;;iBAMZ,WAAW;;;;iBAOX,yBAAyB,GAAG,iBAAiB,GAAG;;;;;iBAWhD,sBACd,cAAc,mBACd,sBACA,cACA,4BACC;;cASU;;;;cAKA;;;;;;;;;iBAUG,mBACd,OAAO,iBACP,aACA,uBACC;;;iBAWa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAQ9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAc5C,wBAAwB,OAAO;;iBAoB/B,uBAAuB;;;;;;;iBAWvB,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KAmFS;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA,QAAQ;IACR;IACA;IACA;MAAS;MAAgB;;;;;KAKjB;;EAEV;;EAEA;;EAEA;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;;;KAIU;EACV;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;iBAac,wBACd,MAAM,oBACN,eACC;;;iBA+Ea,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;iBA+Fc,sBACd,KAAK,YAAY,sBACjB;;;;;;iBAiBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;iBA2Ba,sBACd,KAAK,YAAY,sBACjB,gBAAgB,sBAChB;;;iBAWc,kBAAkB,MAAM,sBAAsB;;;;;;iBAqB9C,uBACd,eAAe,uBACf,aAAa,oBACZ;;;;;;;;;iBA8Da,iBAAiB,cAAc;;;;KAOnC;;EAEV;EACA;;IAEE;MAAU;;;IAEV;MAAU;QAAY;QAAe,SAAS;;;;;;;;;;iBASlC,wBAAwB,SAAS;;;;;;;;iBAmBjC,gBAAgB;EAAgB;IAAQ;;;;;;;iBASxC,kBAAkB;EAAkC;IAAQ;;;;KAKhE;;EAEV;;EAEA;;;EAGA;;;EAGA;EACA;IACE;IACA;;;;;;;iBAQY,mBAAmB;;;;;;;iBAWnB,cAAc,OAAO;;;;;;;;;;;;;;iBAiBrB,4BACd,mBAAmB,mCACnB,aAAa,mBACb,eACC;;;;;;iBA0Ca,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KAiLU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAucI,QAAQ;EAAoB;EAAY,aAAa"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAo7BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EAUA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBAkHmB,sBAAsB,cAAc,QAAQ;;;;;;;;iBAwC5C,yBAAyB,eAAe,QAAQ;;;;;;;;iBAWtD,sBACd;EAAS;EAAoB;eAC7B;;;;;;iBAYc,YAAY;;;iBAMZ,WAAW;;;;iBAOX,yBAAyB,GAAG,iBAAiB,GAAG;;;;;iBAahD,oBACd,cAAc,mBACd,oBACA,cACA;EACG,QAAQ;EAAmB,QAAQ;EAAmB,UAAU;;;;;iBAerD,sBACd,cAAc,mBACd,sBACA,cACA,4BACC;;cAMU;;;;cAKA;;;;;;;;;iBAUG,mBACd,OAAO,iBACP,aACA,uBACC;;;iBAWa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAQ9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAc5C,wBAAwB,OAAO;;iBAqB/B,uBAAuB;KAY3B;EACV;EACA;EACA;;;;;iBA0Bc,oBACd;EACE;EACA;EACA;EACA;IAAU;IAAiB,QAAQ;;GAErC;EACG;EAAmB,UAAU;;;iBAYlB,kBACd,KAAK,YAAY,eACjB,mBACA,UAAU;;iBAWI,sBACd,KAAK,YAAY,eACjB,+BACA,cACA,iBACC;;;;;;;iBAca,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KAmFS;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA,QAAQ;IACR;IACA;IACA;MAAS;MAAgB;;;;;KAKjB;;EAEV;;EAEA;;EAEA;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;;;KAIU;EACV;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;iBAac,wBACd,MAAM,oBACN,eACC;;;iBA+Ea,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;iBA+Fc,sBACd,KAAK,YAAY,sBACjB;;;;;;iBAiBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;iBA2Ba,sBACd,KAAK,YAAY,sBACjB,gBAAgB,sBAChB;;;iBAWc,kBAAkB,MAAM,sBAAsB;;;;;;iBAqB9C,uBACd,eAAe,uBACf,aAAa,oBACZ;;;;;;;;;iBA8Da,iBAAiB,cAAc;;;;KAOnC;;EAEV;EACA;;IAEE;MAAU;;;IAEV;MAAU;QAAY;QAAe,SAAS;;;;;;;;;;iBASlC,wBAAwB,SAAS;;;;;;;;iBAmBjC,gBAAgB;EAAgB;IAAQ;;;;;;;iBASxC,kBAAkB;EAAkC;IAAQ;;;;KAKhE;;EAEV;;EAEA;;;EAGA;;;EAGA;EACA;IACE;IACA;;;;;;;iBAQY,mBAAmB;;;;;;;iBAYnB,cAAc,OAAO;;;;;;;;;;;;;;iBAiBrB,4BACd,mBAAmB,mCACnB,aAAa,mBACb,eACC;;;;;;iBA0Ca,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KAiMU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cA0fI,QAAQ;EAAoB;EAAY,aAAa"}