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

package/src/pantheon/file-persistence.ts

@@ -1,91 +1,238 @@
 /**
  * File-based persistence adapter for the BackgroundJobBoard.
  *
- * Stores all jobs in a single `state.json` file using atomic writes
- * (write to `state.json.tmp` then rename) to prevent partial writes
- * from crashes.
+ * Stores all jobs in a single `state.json` file. Writes are crash-safe:
+ * the payload is written to a UNIQUE temp file, fsynced, then renamed over
+ * the destination. Writes to the same path are serialized through an
+ * in-process queue so two logical writers (plugin × native) cannot
+ * interleave and corrupt the JSON or race the rename.
+ *
+ * Reads are corruption-tolerant: a malformed `state.json` is moved aside to
+ * `<state>.corrupt-<ts>`, a clear log is emitted, and whatever complete
+ * records can be salvaged from the array are returned — never a throw, so
+ * callers (delete/prune/recover) cannot get stuck in a retry loop.
  *
  * @module file-persistence
  */
 
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
-import { dirname } from 'node:path'
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
 
 import type { BackgroundJobRecord, PersistenceAdapter } from './background-job-board.ts'
+import { salvageRecords } from './file-persistence-salvage.ts'
+import { createPantheonLogger } from './logger.ts'
+
+export { salvageRecords } from './file-persistence-salvage.ts'
+
+const log = createPantheonLogger({ module: 'FilePersistence' })
 
 /** Default path for the state file. */
 const DEFAULT_STATE_PATH = '.pantheon/board/state.json'
 
+/** Max rename attempts after an ENOENT before giving up (dir/tmp recreated each try). */
+const RENAME_MAX_ATTEMPTS = 3
+
+/** Minimal file handle surface used to fsync the temp file before rename. */
+export interface PersistenceFileHandle {
+  writeFile(data: string, encoding: 'utf-8'): Promise<void>
+  sync(): Promise<void>
+  close(): Promise<void>
+}
+
+/**
+ * Filesystem operations used by the adapter. Injectable so tests can fault
+ * inject a failing `rename` (ENOENT) deterministically.
+ */
+export interface PersistenceFsOps {
+  mkdir(dir: string): Promise<void>
+  readFile(path: string, encoding: 'utf-8'): Promise<string>
+  rename(from: string, to: string): Promise<void>
+  openForWrite(path: string): Promise<PersistenceFileHandle>
+  unlink(path: string): Promise<void>
+}
+
+/** Real Node.js filesystem implementation (the default). */
+const defaultFsOps: PersistenceFsOps = {
+  mkdir: async (dir) => {
+    await mkdir(dir, { recursive: true })
+  },
+  readFile: (path, encoding) => readFile(path, encoding),
+  rename: (from, to) => rename(from, to),
+  openForWrite: (path) => open(path, 'w'),
+  unlink: (path) => unlink(path),
+}
+
+function isEnoent(err: unknown): boolean {
+  return err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT'
+}
+
+/**
+ * In-process write queues keyed by absolute state path. Shared across
+ * adapter INSTANCES so a plugin adapter and a native adapter pointing at the
+ * same file serialize their read-modify-write cycles.
+ */
+const writeQueues = new Map<string, Promise<unknown>>()
+
+function enqueueWrite<T>(key: string, task: () => Promise<T>): Promise<T> {
+  const previous = writeQueues.get(key) ?? Promise.resolve()
+  const run = previous.then(task, task)
+  writeQueues.set(
+    key,
+    run.then(
+      () => undefined,
+      () => undefined,
+    ),
+  )
+  return run
+}
+
 /**
  * File-based persistence adapter.
  *
- * All jobs are stored in a single JSON array in `statePath`.
- * Writes are atomic: content is written to a `.tmp` file, then renamed.
- *
- * The board's in-memory `this.jobs` Map is the source of truth —
- * this file is a crash-recovery snapshot. `deleteJob()` removes the
- * record from the snapshot so pruned/reconciled jobs don't resurface
- * after a restart.
+ * All jobs are stored in a single JSON array in `statePath`. Writes are
+ * atomic and serialized (unique tmp + fsync + rename, with ENOENT retry).
+ * Corrupt state is backed up and salvaged instead of throwing.
  */
 export class FilePersistenceAdapter implements PersistenceAdapter {
   private readonly statePath: string
   private readonly dir: string
+  private readonly ops: PersistenceFsOps
+  private readonly lockKey: string
+  private tmpCounter = 0
 
   /**
    * @param statePath  Path to the state JSON file (default: `.pantheon/board/state.json`)
+   * @param ops        Filesystem operations (defaults to real Node.js fs; injectable for tests)
    */
-  constructor(statePath?: string) {
+  constructor(statePath?: string, ops: PersistenceFsOps = defaultFsOps) {
     this.statePath = statePath ?? DEFAULT_STATE_PATH
     this.dir = dirname(this.statePath)
+    this.ops = ops
+    this.lockKey = resolve(this.statePath)
   }
 
   /** Ensure the parent directory exists. */
   private async ensureDir(): Promise<void> {
-    await mkdir(this.dir, { recursive: true })
+    await this.ops.mkdir(this.dir)
   }
 
-  /** Path to the atomic-write temp file. */
-  private get tmpPath(): string {
-    return this.statePath + '.tmp'
+  /** Unique temp path per write — prevents two writers racing the same tmp. */
+  private makeTmpPath(): string {
+    this.tmpCounter += 1
+    const unique = `${process.pid}.${this.tmpCounter}.${Math.random().toString(36).slice(2, 8)}`
+    return `${this.statePath}.${unique}.tmp`
   }
 
   /**
    * Read all jobs from the state file.
-   * Returns `null` if the file doesn't exist (first run / no jobs yet).
+   *
+   * Return contract distinguishes three failure modes:
+   * - absent file (ENOENT) → `[]` (first run / no jobs yet);
+   * - corrupt content → quarantine + `salvageRecords()` (best-effort recovery);
+   * - non-ENOENT IO error (e.g. EIO) → `null`, signalling the read failed.
+   *
+   * Callers doing read-modify-write MUST abort on `null` so a failed read
+   * cannot overwrite the on-disk state with a partial snapshot.
    */
   private async readState(): Promise<BackgroundJobRecord[] | null> {
+    let content: string
     try {
-      const content = await readFile(this.statePath, 'utf-8')
-      return JSON.parse(content) as BackgroundJobRecord[]
+      content = await this.ops.readFile(this.statePath, 'utf-8')
     } catch (err: unknown) {
-      if (
-        err instanceof Error &&
-        'code' in err &&
-        (err as NodeJS.ErrnoException).code === 'ENOENT'
-      ) {
-        return null
+      if (isEnoent(err)) return []
+      log.error(`[FilePersistence] Failed to read ${this.statePath}:`, err)
+      return null
+    }
+
+    try {
+      const parsed: unknown = JSON.parse(content)
+      if (!Array.isArray(parsed)) {
+        throw new Error('state.json is not a JSON array')
       }
-      throw err
+      return parsed as BackgroundJobRecord[]
+    } catch (err: unknown) {
+      await this.quarantineCorrupt(err)
+      const salvaged = salvageRecords(content)
+      log.warn(
+        `[FilePersistence] Corrupt ${this.statePath} — recovered ${salvaged.length} record(s)`,
+      )
+      return salvaged
+    }
+  }
+
+  /** Move a corrupt state.json aside so the next write starts from a clean file. */
+  private async quarantineCorrupt(cause: unknown): Promise<void> {
+    const backupPath = `${this.statePath}.corrupt-${Date.now()}`
+    try {
+      await this.ops.rename(this.statePath, backupPath)
+      log.error(`[FilePersistence] Corrupt ${this.statePath} backed up to ${backupPath}:`, cause)
+    } catch (err: unknown) {
+      log.error(
+        `[FilePersistence] Could not back up corrupt ${this.statePath} — continuing with salvaged state:`,
+        err,
+      )
     }
   }
 
-  /** Write the full state array atomically (tmp + rename). */
+  /** Write the full state array: unique tmp + fsync + rename (with ENOENT retry). */
   private async writeState(records: BackgroundJobRecord[]): Promise<void> {
-    await this.ensureDir()
     const content = JSON.stringify(records, null, 2)
-    await writeFile(this.tmpPath, content, 'utf-8')
-    await rename(this.tmpPath, this.statePath)
+    const tmpPath = this.makeTmpPath()
+    let lastError: unknown
+
+    for (let attempt = 1; attempt <= RENAME_MAX_ATTEMPTS; attempt++) {
+      try {
+        await this.ensureDir()
+        const handle = await this.ops.openForWrite(tmpPath)
+        try {
+          await handle.writeFile(content, 'utf-8')
+          await handle.sync()
+        } finally {
+          await handle.close()
+        }
+        await this.ops.rename(tmpPath, this.statePath)
+        return
+      } catch (err: unknown) {
+        lastError = err
+        if (!isEnoent(err)) break
+        log.warn(
+          `[FilePersistence] rename ENOENT for ${this.statePath} ` +
+            `(attempt ${attempt}/${RENAME_MAX_ATTEMPTS}) — recreating dir and retrying`,
+        )
+        await this.safeUnlink(tmpPath)
+      }
+    }
+
+    await this.safeUnlink(tmpPath)
+    throw lastError instanceof Error ? lastError : new Error(String(lastError))
   }
 
-  async saveJob(record: BackgroundJobRecord): Promise<void> {
-    const records = (await this.readState()) ?? []
-    const idx = records.findIndex((r) => r.taskID === record.taskID)
-    if (idx >= 0) {
-      records[idx] = record
-    } else {
-      records.push(record)
+  private async safeUnlink(path: string): Promise<void> {
+    try {
+      await this.ops.unlink(path)
+    } catch {
+      // Best-effort temp cleanup — absent file is fine.
     }
-    await this.writeState(records)
+  }
+
+  async saveJob(record: BackgroundJobRecord): Promise<void> {
+    await enqueueWrite(this.lockKey, async () => {
+      const records = await this.readState()
+      if (records === null) {
+        log.error(
+          `[FilePersistence] Aborting saveJob(${record.taskID}): could not read ` +
+            `${this.statePath} — refusing to overwrite state with a partial snapshot`,
+        )
+        return
+      }
+      const idx = records.findIndex((r) => r.taskID === record.taskID)
+      if (idx >= 0) {
+        records[idx] = record
+      } else {
+        records.push(record)
+      }
+      await this.writeState(records)
+    })
   }
 
   async loadAllJobs(): Promise<BackgroundJobRecord[]> {
@@ -93,11 +240,13 @@ export class FilePersistenceAdapter implements PersistenceAdapter {
   }
 
   async deleteJob(taskID: string): Promise<void> {
-    const records = await this.readState()
-    if (!records) return
-    const idx = records.findIndex((r) => r.taskID === taskID)
-    if (idx < 0) return
-    records.splice(idx, 1)
-    await this.writeState(records)
+    await enqueueWrite(this.lockKey, async () => {
+      const records = await this.readState()
+      if (!records) return
+      const idx = records.findIndex((r) => r.taskID === taskID)
+      if (idx < 0) return
+      records.splice(idx, 1)
+      await this.writeState(records)
+    })
   }
 }

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

@@ -171,7 +171,7 @@ 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;
@@ -190,7 +190,7 @@ 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;
@@ -202,7 +202,9 @@ type ParsedDelegationToolPart = {
 };
 /** 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 `[native]`),
+ *  or is missing its callID. */
 declare function parseDelegationToolPart(part: DelegationToolPart, now?: number): ParsedDelegationToolPart | null;
 /** Apply one tool part to the live map. Returns true when the map changed.
  *  Pure w.r.t. I/O — only mutates `map`. */
@@ -210,11 +212,14 @@ declare function reduceDelegationToolPart(map: Map<string, LiveDelegationEntry>,
 /** Remove a live entry by part id (message.part.removed) or call id.
  *  Returns true when something was removed. */
 declare function removeDelegationEntry(map: Map<string, LiveDelegationEntry>, partIDOrCallID: string): boolean;
-/** 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 `[native]` 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. */
 declare function collectDelegationToolParts(messages: readonly {
   id?: string;
   parts?: unknown[];
@@ -318,6 +323,18 @@ declare function childStatusToState(status: string | undefined): 'running' | 'co
  *  panel renders the tag with a distinct style so native task() children are
  *  visually separable from pantheon_delegate jobs. */
 declare function delegationTag(entry: DelegationEntry): string;
+/** 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. */
+declare function countDelegationSources(entries: readonly DelegationEntry[]): {
+  native: number;
+  pantheon: number;
+  total: number;
+};
+/** 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. */
+declare function formatPanelLogLine(children: number, pantheon: number, native: number, md: number, events: number): string;
 /** Turn child sessions (PRIMARY) enriched with md reports into the display
  *  list. One entry per child id (duplicates across re-fetches collapse).
  *  The md report is matched by `Task ID` (== child.id) and supplies alias,
@@ -326,10 +343,14 @@ declare 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 `[native]` 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. */
 declare function childrenToDelegationEntries(children: readonly ChildDelegationLike[] | undefined, md: readonly DelegationEntry[], now?: number): DelegationEntry[];
 /** Navigate the TUI to a child session (click/Enter on a delegation row).
@@ -356,5 +377,5 @@ declare const plugin: TuiPluginModule & {
   setup: () => Promise<void>;
 };
 //#endregion
-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 };
+export { ChildDelegationLike, DelegationActivity, DelegationEntry, DelegationToolPart, IDLE_SILENCE_MS, LiveDelegationEntry, LiveDelegationStore, ParsedDelegationToolPart, STALE_RUNNING_THRESHOLD_MS, ToolActivity, TuiSessionSources, buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, countDelegationSources, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, extractToolActivity, fmtElapsed, formatPanelLogLine, 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;;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"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAu7BY;;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;;KAqFS;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;;;;;;;iBAec,wBACd,MAAM,oBACN,eACC;;;iBAgGa,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;iBAiGc,sBACd,KAAK,YAAY,sBACjB;;;;;;;;;iBAoBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;iBA6Ba,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;;;;iBAOrB,uBAAuB,kBAAkB;EACvD;EACA;EACA;;;;;iBAUc,mBACd,kBACA,kBACA,gBACA,YACA;;;;;;;;;;;;;;;;;;iBAsBc,4BACd,mBAAmB,mCACnB,aAAa,mBACb,eACC;;;;;;iBA4Ca,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KAiMU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAugBI,QAAQ;EAAoB;EAAY,aAAa"}

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

@@ -164,7 +164,7 @@ async function detectVersion(api) {
 			if (ver) return ver;
 		}
 	} catch {}
-	return "1.5.0-beta.7";
+	return "1.5.0-beta.9";
 }
 /**
 * usage-bar — AI subscription usage gauge for the opencode TUI.
@@ -1095,10 +1095,12 @@ const DELEGATE_TASKID_PATTERN = /\(task\s+([a-z0-9_]+)\)/i;
 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 `[native]`),
+*  or is missing its callID. */
 function parseDelegationToolPart(part, now = Date.now()) {
 	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 === void 0 || callID === "") return null;
 	const sessionID = part.sessionID ?? "";
@@ -1130,8 +1132,8 @@ function parseDelegationToolPart(part, now = Date.now()) {
 			endAt
 		};
 	}
-	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 : "agent";
+	const description = typeof input.description === "string" ? input.description : typeof input.prompt === "string" ? input.prompt.slice(0, 120) : "";
 	let alias = null;
 	let taskID = null;
 	if (status === "completed") {
@@ -1143,7 +1145,7 @@ function parseDelegationToolPart(part, now = Date.now()) {
 		callID,
 		partID: part.id ?? "",
 		sessionID,
-		tool: "pantheon_delegate",
+		tool: part.tool === "task" ? "task" : "pantheon_delegate",
 		agent,
 		description,
 		status,
@@ -1192,7 +1194,7 @@ function reduceDelegationToolPart(map, part, now = Date.now()) {
 			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,
@@ -1209,7 +1211,7 @@ function reduceDelegationToolPart(map, part, now = Date.now()) {
 			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,
@@ -1254,11 +1256,14 @@ function removeDelegationEntry(map, partIDOrCallID) {
 	}
 	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 `[native]` 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. */
 function collectDelegationToolParts(messages, getParts) {
 	const out = [];
 	for (const msg of messages ?? []) {
@@ -1268,7 +1273,7 @@ function collectDelegationToolParts(messages, getParts) {
 		if (!parts) continue;
 		for (const raw of parts) {
 			const part = raw;
-			if (part?.type === "tool" && (part.tool === "pantheon_delegate" || part.tool === "pantheon_delegation_read")) out.push(part);
+			if (part?.type === "tool" && (part.tool === "pantheon_delegate" || part.tool === "pantheon_delegation_read" || part.tool === "task")) out.push(part);
 		}
 	}
 	return out;
@@ -1393,6 +1398,24 @@ function childStatusToState(status) {
 function delegationTag(entry) {
 	return entry.source === "children-only" ? "[native]" : `[pantheon:${entry.alias}]`;
 }
+/** 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. */
+function countDelegationSources(entries) {
+	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. */
+function formatPanelLogLine(children, pantheon, native, md, events) {
+	return `panel: children=${children}(pantheon=${pantheon} native=${native}) md=${md} events=${events}`;
+}
 /** Turn child sessions (PRIMARY) enriched with md reports into the display
 *  list. One entry per child id (duplicates across re-fetches collapse).
 *  The md report is matched by `Task ID` (== child.id) and supplies alias,
@@ -1401,10 +1424,14 @@ function delegationTag(entry) {
 *  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 `[native]` 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. */
 function childrenToDelegationEntries(children, md, now = Date.now()) {
 	const byTaskID = /* @__PURE__ */ new Map();
@@ -1417,7 +1444,7 @@ function childrenToDelegationEntries(children, md, now = Date.now()) {
 		const mdEntry = byTaskID.get(child.id);
 		const state = mdEntry !== void 0 && mdEntry.state !== "running" ? 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",
@@ -1425,7 +1452,7 @@ function childrenToDelegationEntries(children, md, now = Date.now()) {
 			startedAt: mdEntry?.startedAt ?? child.time?.created ?? now,
 			updatedAt: mdEntry?.updatedAt ?? (state === "running" || state === "stale-running" ? null : child.time?.updated ?? null),
 			timedOut: mdEntry?.timedOut ?? false,
-			description: mdEntry !== void 0 && mdEntry.description !== "" ? mdEntry.description : child.title ?? "",
+			description: mdEntry !== void 0 && mdEntry.description !== "" ? mdEntry.description : child.title !== void 0 && child.title !== "" ? child.title : "task nativa",
 			source: mdEntry !== void 0 ? "md" : "children-only"
 		});
 	}
@@ -1549,7 +1576,7 @@ function DelegationRow(props) {
 			},
 			children: (a) => (() => {
 				var _el$19 = createElement("text");
-				insert(_el$19, () => `  \u21b3 ${a().tool}${a().summary !== "" ? " " + a().summary : ""}`);
+				insert(_el$19, () => `  \u21b3 ${a().tool}${a().summary !== "" ? ` ${a().summary}` : ""}`);
 				effect((_$p) => setProp(_el$19, "fg", theme().textMuted, _$p));
 				return _el$19;
 			})()
@@ -1647,7 +1674,7 @@ function View(props) {
 				});
 				if (sessionID === null) {
 					setChildDelegations(md);
-					panelLog.info(`panel: children=0 md=${md.length} events=${eventRefreshCount} (no sessionID — history shown)`);
+					panelLog.info(`${formatPanelLogLine(0, 0, 0, md.length, eventRefreshCount)} (no sessionID — history shown)`);
 					return;
 				}
 				let children = [];
@@ -1674,7 +1701,8 @@ function View(props) {
 				for (const [k, v] of props.liveStore.map) if (v.alias === null && v.taskID === null && Date.now() - v.startedAt > 3e4) props.liveStore.map.delete(k);
 				const liveEntries = [...props.liveStore.map.values()].filter((entry) => entry.sessionID === sessionID);
 				setChildDelegations(mergeChildDelegationSources(childEntries, liveEntries));
-				panelLog.info(`panel: children=${children.length} md=${md.length} events=${eventRefreshCount}`);
+				const counts = countDelegationSources(childEntries);
+				panelLog.info(formatPanelLogLine(children.length, counts.pantheon, counts.native, md.length, eventRefreshCount));
 			} finally {
 				delegationsInflight = null;
 			}
@@ -1683,6 +1711,7 @@ function View(props) {
 	};
 	const delegationSplit = createMemo(() => splitDelegationList(childDelegations()));
 	const visibleDelegations = createMemo(() => [...delegationSplit().active, ...delegationSplit().recent]);
+	const delegationCounts = createMemo(() => countDelegationSources(visibleDelegations()));
 	const [archivedPage, setArchivedPage] = createSignal(archivedUiState.page);
 	const clampArchivedPage = (page, pages) => {
 		const clamped = Math.max(0, Math.min(page, Math.max(0, pages - 1)));
@@ -1852,7 +1881,7 @@ function View(props) {
 		setProp(_el$28, "onMouseDown", () => setShowDelegations((x) => !x));
 		setProp(_el$29, "attributes", 1);
 		insert(_el$29, () => `${showDelegations() ? "▼" : "▶"} Delegations`);
-		insert(_el$30, () => ` (${String(visibleDelegations().length)})`);
+		insert(_el$30, () => ` (${String(delegationCounts().native)} native + ${String(delegationCounts().pantheon)} pantheon)`);
 		insert(_el$22, createComponent(Show, {
 			get when() {
 				return showDelegations();
@@ -2033,6 +2062,6 @@ const plugin = {
 	setup: async () => {}
 };
 //#endregion
-export { IDLE_SILENCE_MS, STALE_RUNNING_THRESHOLD_MS, 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 };
+export { IDLE_SILENCE_MS, STALE_RUNNING_THRESHOLD_MS, buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, countDelegationSources, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, extractToolActivity, fmtElapsed, formatPanelLogLine, isValidSessionId, latestToolActivityFor, markStaleIfRunning, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, safeSessionPath, seedLiveDelegationMap, splitDelegationList, toDelegationEntry, trackToolActivity, tuiLogPath, visibleDelegationList };
 
 //# sourceMappingURL=tui.js.map