pantheon-opencode 1.4.3 → 1.5.0-beta.2

package/src/plugin.ts

@@ -1,3 +1,5 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
 import type { Plugin, PluginInput } from '@opencode-ai/plugin'
 import type { PluginConfig } from 'opencode'
 import { BackgroundJobBoard } from './pantheon/background-job-board.ts'
@@ -10,6 +12,15 @@ import {
   DEFAULT_LIMITS as SANDBOX_DEFAULT_LIMITS,
 } from './pantheon/context-sandbox.ts'
 import { createCostCommand } from './pantheon/cost-command.ts'
+import { buildPluginNativeDelegation, resolveDelegateMode } from './pantheon/delegate-manager.ts'
+import {
+  collectRootSessionIDs,
+  createDelegationTools,
+  type DelegationClient,
+  resolveDelegationBudgets,
+  resolveDelegationTimeoutMs,
+  startIdleChildScan,
+} from './pantheon/delegation.ts'
 import { buildCompactionContext } from './pantheon/delegation-compaction.ts'
 import {
   createEnforcementGuard,
@@ -17,6 +28,8 @@ import {
   SessionHierarchyRegistry,
   zeusReadGuard,
 } from './pantheon/delegation-enforce.ts'
+import { handleDelegationEvent } from './pantheon/delegation-notify.ts'
+import { showDelegationTerminalToast, type ToastClient } from './pantheon/delegation-toast.ts'
 import { FilePersistenceAdapter } from './pantheon/file-persistence.ts'
 import { GOAL_LOOP_DEFAULTS, GoalLoop, GoalStore } from './pantheon/goal-loop.ts'
 import { createReadEnhancer } from './pantheon/hashline/read-enhancer.ts'
@@ -25,8 +38,14 @@ import { createIdleDispatcher } from './pantheon/idle-continuation.ts'
 import { createPantheonLogger } from './pantheon/logger.ts'
 import { createModelCommand } from './pantheon/model-command.ts'
 import { pantheonPluginOnce } from './pantheon/plugin-once.ts'
-import { applyActivePresetToConfig } from './pantheon/presets.mjs'
+import {
+  applyActivePresetToConfig,
+  loadRoutingAgentModels,
+  loadRoutingMaxSteps,
+  loadRoutingPermissionTask,
+} from './pantheon/presets.mjs'
 import { safeSessionPath } from './pantheon/session-guard.ts'
+import { StepCapTracker } from './pantheon/step-cap.ts'
 import {
   TODO_ENFORCER_DEFAULTS,
   TodoEnforcer,
@@ -45,12 +64,24 @@ import { activePresetCandidates, createVisionHandler } from './pantheon/vision.t
 // .pantheon/logs/hooks.log; the console echo is opt-in via PANTHEON_HOOKS_LOG=1.
 const log = createPantheonLogger({ module: 'pantheon-plugin' })
 
+// R4: per-agent step caps from routing.yml `agents.<name>.max_steps`
+// (fail-open → {} = no agent capped). R1 retry_policy/cooldown are NOT
+// wired here — the plugin has no retry path (opencode cannot intercept task
+// completion); zeus waves load them via presets.mjs loaders and pass them
+// to zeusDelegateWithRetry explicitly.
+const stepCapTracker = new StepCapTracker(loadRoutingMaxSteps({ logger: log }))
+
+// O5: permission.task glob rules from routing.yml `permission.task`
+// (fail-open → undefined = existing runtime matrix only).
+const routingPermissionTask = loadRoutingPermissionTask({ logger: log })
+
 const board = new BackgroundJobBoard({
   maxConcurrentPerAgent: 3,
   signalDir: '.pantheon/deepwork/board-signals',
 })
 const persistence = new FilePersistenceAdapter('.pantheon/board/state.json')
 board.setPersistence(persistence)
+let terminalToastClient: ToastClient = {}
 board
   .recoverRunningJobs()
   .catch((err) => log.error('[Pantheon Plugin] Failed to recover running jobs:', err))
@@ -60,13 +91,17 @@ board
 // file-only log line (console echo opt-in via PANTHEON_HOOKS_LOG). There is
 // deliberately NO chat delivery — the user policy is zero delegation
 // notifications in the transcript. Completion visibility lives in the board
-// `[unread]` marker and compaction carry-forward.
+// `[unread]` marker (pantheon_delegation_list), pantheon_delegation_read,
+// TUI toasts (pantheon-hooks, PANTHEON_TOASTS gate) and compaction
+// carry-forward.
 board.onTerminal((taskID: string) => {
   const job = board.get(taskID)
   if (!job) return
   log.info(
     `[Pantheon Plugin] Board terminal: [${job.alias}] ${job.description} → ${job.state}${job.resultSummary ? ` — ${job.resultSummary}` : ''}`,
   )
+  // Deliberately direct-to-TUI: onTerminal must not inject chat/transcript text.
+  void showDelegationTerminalToast(terminalToastClient, job)
 })
 
 // Periodically prune terminal/reconciled jobs (24h TTL, every 30 min).
@@ -84,15 +119,23 @@ setInterval(
 
 // ─── Phase 4: Read-Only Enforcement + Compaction Context ───────────────
 
-// The read-only registry is populated when a child session is launched
-// read-only (explicit flag or agent ∈ readOnlyAgents). The guard denies
-// edit/write/bash/task inside those sessions by throwing from
-// tool.execute.before; unknown sessions are allowed (safe default).
+// WS1 (PR #94): root-session predicate shared by the Phase 4 enforcement
+// guard and the native delegate toolset — both must agree on what a root is.
+// (Hoisted function: `rootSessions`/`sessionHierarchy` below are resolved at
+// call time, after module init.)
+function isRootSession(sessionID: string): boolean {
+  return rootSessions.has(sessionID) || sessionHierarchy.isRoot(sessionID)
+}
+
+// The read-only registry is populated by createDelegationTools (delegation.ts)
+// when a delegate is read-only (explicit flag or agent ∈ readOnlyAgents).
+// The guard denies edit/write/bash/task inside those sessions by throwing
+// from tool.execute.before; unknown sessions are allowed (safe default).
 const enforcementGuard = createEnforcementGuard({
   getReadOnlySessions: () => readOnlyRegistry.sessionIDs(),
   options: {
     getSessionAgent: (sessionID) => sessionAgents.get(sessionID),
-    isRootSession: (sessionID) => rootSessions.has(sessionID) || sessionHierarchy.isRoot(sessionID),
+    isRootSession,
     isChildSession: (sessionID) => sessionHierarchy.isChild(sessionID),
     logger: log,
   },
@@ -108,7 +151,7 @@ const commandNormalizer = createCommandNormalizer({ logger: log })
 // Mirrors routing.yml background_delegation.max_compaction_items.
 const COMPACTION_MAX_ITEMS = 10
 
-// Root-session registry for the child-session depth guard: sessions created
+// Root-session registry for the delegation depth guard: sessions created
 // without a parentID are roots. Populated from TWO sources:
 //   1. the `session.created` event hook (live roots — fires for sessions
 //      created while the plugin runs);
@@ -116,9 +159,9 @@ const COMPACTION_MAX_ITEMS = 10
 //      hook (compaction-134) — opencode does NOT replay session.created
 //      events for sessions that exist before plugin load, so without the
 //      seed a resumed root would never enter this set after a restart.
-// The hierarchy registry additionally falls back to known children ("any
-// session WE created is a sub-session; unknown sessions are roots") so the
-// depth guard works even when this set is incomplete.
+// delegation.ts additionally falls back to knownChildren ("any session WE
+// created is a sub-session; unknown sessions are roots") so the depth guard
+// works even when this set is incomplete.
 const rootSessions = new Set<string>()
 const sessionHierarchy = new SessionHierarchyRegistry()
 const sessionAgents = new Map<string, string>()
@@ -127,14 +170,14 @@ const sessionAgents = new Map<string, string>()
  * Seed resumed root sessions without making OpenCode startup depend on the
  * session API responding. Some OpenCode environments do not have the API
  * ready while plugin config hooks run; awaiting session.list() there leaves
- * the TUI stuck before it can open. The hierarchy registry already treats an
+ * the TUI stuck before it can open. The delegation layer already treats an
  * unknown session as a root, so this enrichment is deliberately best-effort.
  */
 function seedRootSessionsInBackground(input: PluginInput): void {
   // Fail-open: environments without the session API (client.session absent or
   // not yet wired while config hooks run) must NOT break startup. `session`
   // is captured and the method invoked on it so `this` stays bound; the
-  // hierarchy registry already treats unknown sessions as roots, so skipping
+  // delegation layer already treats unknown sessions as roots, so skipping
   // the seed is always safe.
   const session = input.client.session
   if (typeof session?.list !== 'function') return
@@ -144,15 +187,10 @@ function seedRootSessionsInBackground(input: PluginInput): void {
     .then((result) => {
       if (!result.error && Array.isArray(result.data)) {
         sessionHierarchy.completeSeed(result.data)
-        let seeded = 0
-        for (const info of result.data) {
-          if (info.parentID === undefined) {
-            rootSessions.add(info.id)
-            seeded += 1
-          }
-        }
-        if (seeded > 0) {
-          log.info(`[Pantheon Plugin] Seeded ${seeded} root session(s) from session.list`)
+        const seeded = collectRootSessionIDs(result.data)
+        if (seeded.size > 0) {
+          for (const id of seeded) rootSessions.add(id)
+          log.info(`[Pantheon Plugin] Seeded ${seeded.size} root session(s) from session.list`)
         }
       } else {
         sessionHierarchy.failSeed()
@@ -170,6 +208,62 @@ function sdkErrorMessage(error: { data?: { message?: string } } | null | undefin
   return typeof message === 'string' && message.trim() !== '' ? message : 'request failed'
 }
 
+/**
+ * Adapt the opencode SDK client to the structural DelegationClient the
+ * delegation toolset expects: the SDK wraps every call in a
+ * `{data, error, request, response}` result while delegation.ts uses direct
+ * returns. Errors surface as throws so the toolset's own error handling
+ * (tool errors returned as TEXT) keeps working.
+ */
+function adaptDelegationClient(client: PluginInput['client']): DelegationClient {
+  return {
+    session: {
+      create: async (input) => {
+        const body: {
+          parentID?: string
+          title?: string
+          model?: { id: string; providerID: string }
+        } = { parentID: input.body.parentID }
+        if (input.body.title !== undefined) body.title = input.body.title
+        // Forward a model only when the active routing profile supplied one.
+        if (input.body.model !== undefined) body.model = input.body.model
+        const result = await client.session.create({ body })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return { id: result.data.id }
+      },
+      promptAsync: async (input) => {
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] promptAsync skipped: invalid sessionID "${input.path.id}"`)
+          throw new Error(`invalid sessionID: ${input.path.id}`)
+        }
+        const result = await client.session.promptAsync({
+          path: path.path,
+          body: {
+            agent: input.body.agent,
+            ...(input.body.model !== undefined
+              ? { model: { providerID: input.body.model.providerID, modelID: input.body.model.id } }
+              : {}),
+            parts: input.body.parts,
+          },
+        })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+      messages: async (input) => {
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] messages skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.messages({ path: path.path })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+    },
+  }
+}
+
 /**
  * Adapt the opencode SDK client to the structural TodoEnforcerClient the
  * todo enforcer expects: unwraps the SDK `{data, error, request, response}`
@@ -250,6 +344,7 @@ function adaptTodoEnforcerClient(client: PluginInput['client']): TodoEnforcerCli
  * Helpers live in src/pantheon/vision.ts and are imported from there directly.
  */
 const plugin: Plugin = async (input: PluginInput) => {
+  terminalToastClient = input.client as unknown as ToastClient
   // release-134: runtime guard against DOUBLE registration (duplicate toasts +
   // duplicate task_ids in one process — 2026-08-12 live logs). opencode
   // merges the global config (npm-package plugin paths) with the project
@@ -264,12 +359,100 @@ const plugin: Plugin = async (input: PluginInput) => {
   // is older than the installed package. Runs once, fail-open, no auto-sync.
   checkTuiVersionStaleness((msg) => log.warn(msg))
   const vision = createVisionHandler(input)
+  // Phase 2/3: background delegation toolset + the bound finalize lifecycle
+  // hook. Completion is observed through the event hook below
+  // (session.idle / session.error on a child) → finalizeDelegation.
+  // Fase B3: runtime controls for the two read-only exceptions and the real
+  // per-child wall-clock timer. No task_budget field is injected into the
+  // plugin/frontmatter; these are enforced by delegation.ts itself.
+  const delegationBudgets = resolveDelegationBudgets()
+  const wallClockTimeoutMs = resolveDelegationTimeoutMs()
+
+  // WS1 (PR #94): delegation backend gate. Default = legacy (the V1
+  // fire-and-forget toolset, intact); PANTHEON_DELEGATE_MODE=native selects
+  // the thin manager over native task() semantics. Kill-switch
+  // PANTHEON_DELEGATION=off covers the native manager; finalizeDelegation stays on
+  // the legacy observer: it works on the shared board in both modes and must
+  // never be kill-switched, so children never orphan. The idle hook below is
+  // untouched.
+  const delegationClient = adaptDelegationClient(input.client)
+  // Only an explicitly active routing profile may provide child models.
+  // An empty map deliberately lets OpenCode inherit the parent model.
+  const routingAgentModels = loadRoutingAgentModels({
+    candidates: activePresetCandidates(),
+    logger: log,
+  })
+  const readOnlyAgents = new Set(['apollo', 'gaia'])
+  const legacyDelegation = createDelegationTools({
+    board,
+    client: delegationClient,
+    options: {
+      rootSessions,
+      isChildSession: (sessionID) => sessionHierarchy.isChild(sessionID),
+      registerChildSession: (sessionID, parentID) => {
+        sessionHierarchy.register({ id: sessionID, parentID })
+      },
+      enforceRuntimeMatrix: true,
+      readOnlyAgents,
+      agentModels: routingAgentModels,
+      delegationBudgets,
+      stepCapTracker,
+      ...(routingPermissionTask != null ? { permissionTask: routingPermissionTask } : {}),
+      ...(wallClockTimeoutMs !== undefined ? { wallClockTimeoutMs } : {}),
+    },
+  })
+  const delegateMode = resolveDelegateMode()
+  if (delegateMode === 'native') {
+    log.info('[Pantheon Plugin] Delegation mode: native (PANTHEON_DELEGATE_MODE=native)')
+  }
+  const delegation =
+    delegateMode === 'native'
+      ? buildPluginNativeDelegation({
+          board,
+          client: delegationClient,
+          isRootSession,
+          registerChildSession: (sessionID, parentID) => {
+            sessionHierarchy.register({ id: sessionID, parentID })
+          },
+          registerReadOnlySession: (sessionID, info) => {
+            readOnlyRegistry.register(sessionID, info)
+          },
+          readOnlyAgents,
+          agentModels: routingAgentModels,
+          stepCap: stepCapTracker,
+          ...(wallClockTimeoutMs !== undefined ? { wallClockTimeoutMs } : {}),
+          finalizeDelegation: legacyDelegation.finalizeDelegation,
+        })
+      : legacyDelegation
+
+  // Proactive idle-child scan (Fix 2): finalize children that are idle on the
+  // board but have no MD report on disk — eliminates the phantom "running"
+  // window. Runs every 30s (configurable via PANTHEON_IDLE_SCAN_INTERVAL_MS),
+  // unref'd so it never holds the process open. Fail-open by design.
+  const idleScanIntervalMs = Number(process.env.PANTHEON_IDLE_SCAN_INTERVAL_MS) || undefined
+  startIdleChildScan(
+    {
+      board,
+      finalize: (childSessionID, opts) => delegation.finalizeDelegation(childSessionID, opts),
+      hasReport: (job) => {
+        try {
+          const filePath = join('.pantheon/delegations', job.parentSessionID, `${job.alias}.md`)
+          return existsSync(filePath)
+        } catch {
+          return false
+        }
+      },
+      logger: log,
+    },
+    idleScanIntervalMs,
+  )
+
   // Wave 1 (PR #46): TODO continuation enforcer for root/non-board sessions.
   // Mirrors routing.yml `todo_enforcer` (plugin scope has no routing.yml
-  // access — COMPACTION_MAX_ITEMS pattern). The event hook routes all
-  // session.idle events here. Runtime kill-switch: PANTHEON_TODO_ENFORCER=off
-  // (routing.yml is a doc mirror only — the env var is the real switch,
-  // PANTHEON_TOASTS pattern).
+  // access — COMPACTION_MAX_ITEMS pattern). The event hook routes non-board
+  // session.idle events here; board-child idles go to finalizeDelegation.
+  // Runtime kill-switch: PANTHEON_TODO_ENFORCER=off (routing.yml is a doc
+  // mirror only — the env var is the real switch, PANTHEON_TOASTS pattern).
   const todoEnforcer = new TodoEnforcer({
     client: adaptTodoEnforcerClient(input.client),
     board,
@@ -326,7 +509,7 @@ const plugin: Plugin = async (input: PluginInput) => {
     await readEnhancer(input, output)
   }
 
-  // Wave 4 (PR #46): /cost — cost + token visibility by agent. Reads
+  // Wave 4 (PR #46): /cost — delegation cost + token visibility. Reads
   // opencode.db read-only (node:sqlite, falls back to scripts/cost.mjs).
   // Fully wired (unlike dispatch-guard, which is manual-orchestration-only
   // because opencode 1.18.x cannot intercept task completion via hooks).
@@ -338,11 +521,11 @@ const plugin: Plugin = async (input: PluginInput) => {
       // compaction-134 seed: opencode does NOT replay `session.created`
       // events for sessions that exist before plugin load, so after a
       // restart the resumed ROOT session never enters rootSessions and the
-      // depth guard would treat it as a child. Seed the registry from
-      // session.list() in the background — every session WITHOUT a parentID
-      // is a root. Fail-open: a failed/throttled list leaves the set
-      // untouched (the hierarchy registry treats unknown sessions as roots),
-      // and config setup must never wait for the session API.
+      // depth guard would reject its pantheon_delegate calls. Seed the
+      // registry from session.list() in the background — every session
+      // WITHOUT a parentID is a root. Fail-open: a failed/throttled list
+      // leaves the set untouched (delegation.ts treats unknown sessions as
+      // roots), and config setup must never wait for the session API.
       // Context sandbox config — opencode.json → context_sandbox: {enabled, limits}
       try {
         const raw = (config as unknown as Record<string, unknown>).context_sandbox
@@ -387,16 +570,18 @@ const plugin: Plugin = async (input: PluginInput) => {
         log.warn('[plugin] preset application failed (see logs for details)')
       }
     },
-    // Phase 2: structural tool registrations (matches the `tool` hook field
-    // shape). Native task() owns orchestration; the plugin registers the
-    // deterministic /pantheon-model, /cost and full-auto goal tools.
+    // Phase 2: background delegation tools (structural — matches the `tool`
+    // hook field shape; read_only sessions feed the Phase 4 registry).
     tool: {
+      pantheon_delegate: delegation.pantheon_delegate,
+      pantheon_delegation_read: delegation.pantheon_delegation_read,
+      pantheon_delegation_list: delegation.pantheon_delegation_list,
       hashline_edit: hashlineEdit,
       // Wave 3 (PR #46): full-auto goal tools (single active goal/session).
       pantheon_goal_create: goalTools.pantheon_goal_create,
       pantheon_goal_update: goalTools.pantheon_goal_update,
       pantheon_goal_get: goalTools.pantheon_goal_get,
-      // Wave 4 (PR #46): /cost — cost report by agent from opencode.db.
+      // Wave 4 (PR #46): /cost — delegation cost report from opencode.db.
       pantheon_cost: costCommand.pantheon_cost,
       // Deterministic /pantheon-model management of top-level model fields.
       pantheon_model: modelCommand.pantheon_model,
@@ -430,13 +615,22 @@ const plugin: Plugin = async (input: PluginInput) => {
       if (ev.type === 'session.compacted') {
         await todoPreserver.onCompacted(ev.properties.sessionID)
       }
-      // Native task() children are owned by OpenCode. Idle routing for
-      // generic root/non-board sessions remains priority ordered: an active
-      // goal owns the idle (goal loop), otherwise the todo enforcer
-      // re-injects. Neither onIdle ever throws (internal failures are logged
-      // + swallowed), so the session is safe.
+      // Phase 3: observe completion on child sessions → finalizeDelegation.
+      // The board transition fires onTerminal → the file-only audit log (no
+      // chat delivery — see the onTerminal listener above). Unknown sessions
+      // are a no-op.
       try {
-        if (ev.type === 'session.idle') {
+        const delegated = await handleDelegationEvent(ev, {
+          board,
+          finalize: (childSessionID, opts) => delegation.finalizeDelegation(childSessionID, opts),
+        })
+        // Wave 1/3: non-board idle → idle dispatcher. Board children are
+        // handled by handleDelegationEvent above; everything else (roots,
+        // non-board sessions) is routed by priority: an active goal owns the
+        // idle (goal loop), otherwise the todo enforcer re-injects. Neither
+        // onIdle ever throws (internal failures are logged + swallowed), so
+        // the session is safe.
+        if (!delegated && ev.type === 'session.idle') {
           await idleDispatcher.onIdle(ev.properties.sessionID)
         }
       } catch (err) {

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

@@ -14,4 +14,4 @@
 declare function server(): {};
 //#endregion
 export { server as default };
-//# sourceMappingURL=server.d.ts.map
+//# sourceMappingURL=server.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"mappings":";;;;;;;;;;;;;iBAYwB"}
+{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"mappings":";;;;;;;;;;;;;iBAYwB"}

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

@@ -17,4 +17,4 @@ function server() {
 //#endregion
 export { server as default };
 
-//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"server.js","names":[],"sources":["../src/server.ts"],"sourcesContent":["/**\n * No-op server stub for the opencode plugin loader.\n *\n * The opencode plugin host requires every plugin (TUI included) to expose a\n * `server()` entry via `exports[\"./server\"]` (or package.json `main`). When\n * that entry is missing the host fails to attach the plugin's server half and\n * the TUI runtime never wires the reactive channel — the initial JSX mounts\n * but effects/refresh/events stay dead (the \"mudo panel\" symptom).\n *\n * This stub satisfies the loader contract; pantheon-tui is TUI-only and has\n * no background server work of its own.\n */\nexport default function server() {\n  return {}\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAwB,SAAS;CAC/B,OAAO,CAAC;AACV"}
+{"version":3,"file":"server.js","names":[],"sources":["../src/server.ts"],"sourcesContent":["/**\n * No-op server stub for the opencode plugin loader.\n *\n * The opencode plugin host requires every plugin (TUI included) to expose a\n * `server()` entry via `exports[\"./server\"]` (or package.json `main`). When\n * that entry is missing the host fails to attach the plugin's server half and\n * the TUI runtime never wires the reactive channel — the initial JSX mounts\n * but effects/refresh/events stay dead (the \"mudo panel\" symptom).\n *\n * This stub satisfies the loader contract; pantheon-tui is TUI-only and has\n * no background server work of its own.\n */\nexport default function server() {\n  return {}\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAwB,SAAS;CAC/B,OAAO,CAAC;AACV"}

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

@@ -22,7 +22,7 @@ type DelegationEntry = {
   read?: boolean;
   /** 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 `[task]` tag); 'md' = board report wins. */
+   *  (rendered with the distinct `[native]` tag); 'md' = board report wins. */
   source?: 'child' | 'live' | 'md' | 'children-only';
 };
 /** Parse one delegation report md header into a structured entry.
@@ -59,7 +59,7 @@ declare function readAllDelegationEntries(root: string): Promise<DelegationEntry
 declare function resolveDelegationsDir(state: {
   directory?: string;
   worktree?: string;
-} | undefined, cwd?: string): string;
+} | undefined, cwd?: any): string;
 /** Project root derived from the delegations dir: `<root>/.pantheon/delegations`
  *  → `<root>`. Used to point the panel logger at the REAL hooks.log — passing
  *  the delegations dir (or its dirname) directly made createTuiLogger append
@@ -279,10 +279,12 @@ type ChildDelegationLike = {
  *  (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';
-/** Row tag for a delegation entry: `[task]` for native task() children
- *  (source 'children-only' — no board report), `[<alias>]` for board rows
- *  ([apo-1]). The panel renders the tag with a distinct style so native
- *  task() children are visually separable from pantheon_delegate jobs. */
+/** 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. */
 declare function delegationTag(entry: DelegationEntry): string;
 /** Turn child sessions (PRIMARY) enriched with md reports into the display
  *  list. One entry per child id (duplicates across re-fetches collapse).
@@ -293,7 +295,7 @@ declare function delegationTag(entry: DelegationEntry): string;
  *  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 `[task]` tag instead of a board alias.
+ *  and the `[native]` tag instead of a board alias.
  *  Terminal md state wins over the derived state; a running md defers to
  *  the child's live status. Sorted running-first (compareDelegationEntries).
  *  Pure — no I/O. */
@@ -319,6 +321,7 @@ type LiveDelegationStore = {
 };
 declare const plugin: TuiPluginModule & {
   id: string;
+  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 };

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;;;;;iBASnB,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"}
+{"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"}

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

@@ -164,7 +164,7 @@ async function detectVersion(api) {
 			if (ver) return ver;
 		}
 	} catch {}
-	return "1.4.2";
+	return "1.5.0";
 }
 /**
 * usage-bar — AI subscription usage gauge for the opencode TUI.
@@ -1311,12 +1311,14 @@ function childStatusToState(status) {
 	if (status === "idle") return "completed";
 	return "running";
 }
-/** Row tag for a delegation entry: `[task]` for native task() children
-*  (source 'children-only' — no board report), `[<alias>]` for board rows
-*  ([apo-1]). The panel renders the tag with a distinct style so native
-*  task() children are visually separable from pantheon_delegate jobs. */
+/** 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. */
 function delegationTag(entry) {
-	return entry.source === "children-only" ? "[task]" : `[${entry.alias}]`;
+	return entry.source === "children-only" ? "[native]" : `[pantheon:${entry.alias}]`;
 }
 /** Turn child sessions (PRIMARY) enriched with md reports into the display
 *  list. One entry per child id (duplicates across re-fetches collapse).
@@ -1327,7 +1329,7 @@ function delegationTag(entry) {
 *  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 `[task]` tag instead of a board alias.
+*  and the `[native]` tag instead of a board alias.
 *  Terminal md state wins over the derived state; a running md defers to
 *  the child's live status. Sorted running-first (compareDelegationEntries).
 *  Pure — no I/O. */
@@ -1871,7 +1873,8 @@ const tui = (api, _options, _meta) => {
 };
 const plugin = {
 	id: "pantheon.tui",
-	tui
+	tui,
+	setup: async () => {}
 };
 //#endregion
 export { IDLE_SILENCE_MS, STALE_RUNNING_THRESHOLD_MS, 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 };

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

@@ -1 +1 @@
-{"version":3,"file":"tui.js","names":[],"sources":[],"mappings":""}
+{"version":3,"file":"tui.js","names":[],"sources":[],"mappings":""}