pantheon-opencode 1.3.7 → 1.4.1

package/src/plugins/pantheon-hooks.ts

@@ -79,7 +79,7 @@
  *       PANTHEON_TOASTS=council       → {errors, council}
  *       PANTHEON_TOASTS=all           → {errors, delegations, council}
  *     Unknown values fall back to the default. The gate controls the TUI
- *     display + chat-reminder fallback ONLY — every fired toast is also
+ *     display only — every fired toast is also
  *     recorded to the structured log + hooks.log (script 'toast', level
  *     'info') so the toast trail stays auditable at any setting.
  *   - Severity priority (2026-08-06): errors/blockers — hook failures
@@ -96,15 +96,9 @@
  *     One group buffer at a time (groups rarely overlap); a task call more
  *     than OLYMPIANS_DETECT_WINDOW_MS after the previous one starts a fresh
  *     group.
- *   - session.idle flush (2026-08-06): the `event` hook additionally handles
- *     `session.idle`. When the orchestrator goes idle, pending completion
- *     reminders are flushed as ONE aggregated chat reminder (individual
- *     "✅ <agent> concluiu" lines collapse into "✅ N agentes concluídos (...)")
- *     and re-armed with a fresh timestamp — so the completion summary
- *     survives until the next user message (delivered via chat.message) instead
- *     of expiring after CHAT_REMINDER_TTL_MS while the user reads the reply.
- *     Partial groups (some members completed, some never reported) and
- *     interrupted council counters are also flushed/reset here.
+ *   - session.idle handling (2026-08-06): the `event` hook additionally handles
+ *     `session.idle` to reset partial aggregation state and interrupted council
+ *     counters. Completion visibility remains in the board and TUI only.
  *   - Council notifications (new category 2026-08-06): a `task` whose prompt/
  *     description matches "council"/"conselho"/"synthesi" is treated as council
  *     activity — "🏛️ Council: especialistas consultados" on start and
@@ -122,11 +116,8 @@
  *     with wrk"). The upstream fix (server-side workspace tagging) only exists
  *     in NEWER opencode versions. THEREFORE on 1.18.13 the toast path below is
  *     a documented TUI no-op and agent-lifecycle feedback is surfaced via the
- *     oh-my-openagent fallback pattern: a `chat.message` hook injects queued
- *     signals (see pendingChatReminders / enqueueChatReminder below) as ONE
- *     <system-reminder> text part into the next user message. Toasts stay in
- *     place for future opencode versions that render them — upgrade opencode
- *     for real TUI toasts.
+ *     no transcript fallback is used. Toasts stay in place for future opencode
+ *     versions that render them — upgrade opencode for real TUI toasts.
  *   - tool.execute.after payload fix (P1-1 follow-up, 2026-08-06): the after
  *     hook receives `(input, output)` where `output` = {title, output,
  *     metadata} — the REAL tool result. It is now merged into the payload
@@ -185,13 +176,6 @@
 import { appendFile, mkdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import type { Plugin, PluginInput } from '@opencode-ai/plugin'
-import type { Part } from '@opencode-ai/sdk'
-import {
-  CHAT_REMINDER_TTL_MS,
-  drainFreshChatReminders,
-  enqueueChatReminder,
-  pendingChatReminders,
-} from '../pantheon/chat-reminders.ts'
 import { pantheonPluginOnce } from '../pantheon/plugin-once.ts'
 import { type HookPayload, type HookResult, runHook } from './hook-runner.ts'
 
@@ -231,7 +215,7 @@ type ToastCategory = 'errors' | 'delegations' | 'council'
  * of enabled categories; every notification declares its category and is
  * skipped unless enabled. "off" = empty set, "all" = every category. Unknown
  * values fall back to the default. The gate controls the TUI display +
- * chat-reminder fallback ONLY — the structured log + hooks.log channels
+ * display only — the structured log + hooks.log channels
  * always write (every fired toast is recorded via reportFailure with script
  * 'toast').
  */
@@ -427,26 +411,8 @@ const BACKGROUND_DISPATCH_TEXT_RE =
 const TASK_ID_TEXT_RE = /\btask\s+id="(ses_[^"]+)"/i
 
 /**
- * 1.18.13 chat.message fallback buffer (oh-my-openagent pattern — see header):
- * opencode 1.18.13 drops tui.toast.show events (untagged), so every signal
- * that would fire a toast is ALSO queued here and injected into the next user
- * message by the 'chat.message' hook as a single <system-reminder> text part.
- *
- * The buffer itself lives in the SHARED chat-reminders.ts module: this plugin
- * file must export EXACTLY ONE function-valued export (legacy loader —
- * see the IMPORTANT note at the top), so the enqueue API cannot be exported
- * from here. Importing the shared module instead gives src/plugin.ts (a
- * separate plugin file, loaded via plain dynamic import) the SAME buffer
- * instance — release-134 Phase 4 (compaction-assert.ts) enqueues
- * post-compaction state re-assertions here and this hook delivers them.
- *
- * Bounded: at most CHAT_REMINDER_MAX entries, each expiring
- * CHAT_REMINDER_TTL_MS after its tool event. Consumed (and cleared) by the
- * chat.message hook. Full-buffer enqueues are SKIPPED, never unbounded — the
- * olympians/3-in-6s aggregates still cover delegation groups, matching the
- * "throttled toasts are skipped, never backlogged" anti-spam philosophy.
- * session.idle flushes the buffer into ONE fresh aggregated entry (see
- * flushIdleReminders) so completions survive until the next user message.
+ * Delegation lifecycle state is intentionally not mirrored into the transcript.
+ * The board/list/read tools and TUI toasts are the supported visibility channels.
  */
 
 /** Variants accepted by the opencode TUI showToast (TuiShowToastData.body.variant). */
@@ -462,11 +428,6 @@ type ToastOptions = {
   dedupeKey?: string
   /** Optional TUI toast headline (opencode showToast body.title). */
   title?: string
-  /**
-   * Optional text for the 1.18.13 chat.message <system-reminder> fallback.
-   * Defaults to `message` when omitted — the reminder mirrors the toast.
-   */
-  reminder?: string
 }
 
 /** Logging context threaded through safeRun — provided by the plugin input. */
@@ -757,10 +718,6 @@ async function notifyToast(ctx: HookContext, opts: ToastOptions): Promise<void>
       toastShown.add(opts.dedupeKey)
     }
     if (!toastCategoryEnabled(opts.category)) return
-    // 1.18.13 fallback: queue the same signal for the chat.message hook (the
-    // TUI drops tui.toast.show on 1.18.13 — see header). Enqueued even if
-    // showToast fails, so headless/no-TUI servers still surface feedback.
-    enqueueChatReminder(opts.reminder ?? opts.message)
     await ctx.client.tui.showToast({
       body: {
         ...(opts.title !== undefined ? { title: opts.title } : {}),
@@ -907,7 +864,7 @@ async function agentFailedToast(
 ): Promise<void> {
   const raw = result?.output ?? result?.title ?? ''
   // Fix 1: the failure reason echoes tool RESULT content — mask any token so
-  // the toast/chat-reminder/hooks.log trail never exposes a raw secret.
+  // the toast/hooks.log trail never exposes a raw secret.
   const reason = maskSecret(
     trim(typeof raw === 'string' && raw.trim() !== '' ? raw : 'tool failed', 120),
   )
@@ -1057,40 +1014,7 @@ function onCouncilDone(ctx: HookContext): void {
   }
 }
 
-/**
- * session.idle flush (see header): aggregate any pending chat reminders into
- * ONE fresh <system-reminder> entry (individual ✅ completions collapse into
- * "✅ N agentes concluídos (...)"), report partial groups whose members never
- * all completed, and reset interrupted council counters. The chat.message
- * hook remains the delivery path — the flushed entry has a fresh timestamp so
- * it survives until the next user message instead of expiring while the user
- * reads the reply.
- */
 function flushIdleReminders(ctx: HookContext): void {
-  if (ENABLED_TOAST_CATEGORIES.size === 0) {
-    pendingChatReminders.length = 0
-    activeOlympians = null
-    return
-  }
-  const now = Date.now()
-  const fresh = pendingChatReminders.filter((r) => now - r.at <= CHAT_REMINDER_TTL_MS)
-  pendingChatReminders.length = 0
-
-  // Partial group: some members completed but the group never finished (their
-  // completion was suppressed waiting for the aggregate). Report the subset.
-  const partialGroup = activeOlympians
-  if (partialGroup !== null) {
-    const done = [...partialGroup.agents].filter((a) => !partialGroup.pendingCompletions.has(a))
-    if (partialGroup.detected && partialGroup.doneCount > 0 && done.length > 0) {
-      fresh.push({
-        text:
-          done.length === 1
-            ? `✅ ${done[0]} concluiu`
-            : `✅ ${done.length} agentes concluídos (${done.sort().join(', ')})`,
-        at: now,
-      })
-    }
-  }
   activeOlympians = null
 
   // Interrupted council counters must not block a later council's verdict —
@@ -1105,34 +1029,12 @@ function flushIdleReminders(ctx: HookContext): void {
     councilStartNotified = false
   }
 
-  // Collapse individual ✅ completions into one aggregate line.
-  const doneAgents: string[] = []
-  const others: string[] = []
-  for (const r of fresh) {
-    const m = /^✅ (.+?) concluiu$/.exec(r.text)
-    if (m?.[1] !== undefined) doneAgents.push(m[1])
-    else others.push(r.text)
-  }
-  const lines: string[] = []
-  if (doneAgents.length > 0) {
-    lines.push(
-      doneAgents.length === 1
-        ? `✅ ${doneAgents[0]} concluiu`
-        : `✅ ${doneAgents.length} agentes concluídos (${doneAgents.sort().join(', ')})`,
-    )
-  }
-  lines.push(...others)
-  if (lines.length === 0) return
-
-  // ONE aggregated entry, fresh timestamp — chat.message delivers it next.
-  enqueueChatReminder(lines.join('\n'))
-  // 1.3.4 dedup: log a SUMMARY here (count only), never the joined body — the
-  // SAME lines used to be echoed twice (idle-flush with " | ", chat-reminder
-  // delivery with "\n"). The content is logged exactly once, at delivery.
   void reportFailure(
     ctx,
-    `[pantheon-hooks:idle-flush] ${fresh.length} reminder(s) flushed into the chat buffer (${lines.length} line(s) after aggregation)`,
-    { script: 'idle-flush', count: fresh.length, lineCount: lines.length },
+    '[pantheon-hooks:idle-flush] delegation state reset',
+    {
+      script: 'idle-flush',
+    },
     'info',
   )
 }
@@ -1213,7 +1115,7 @@ const plugin: Plugin = async ({ client, directory }) => {
   // merges the global config (npm-package plugin paths) with the project
   // config (repo source paths), so this module loads from TWO filesystem
   // paths in the same process and the factory would otherwise run twice —
-  // every hook (tool.execute.before/after, chat.message, event) firing
+  // every lifecycle hook (tool.execute.before/after and event) firing
   // TWICE. The second invocation becomes a no-op (empty hooks object) so
   // hooks register exactly once.
   if (pantheonPluginOnce('pantheon:hooks')) {
@@ -1439,51 +1341,6 @@ const plugin: Plugin = async ({ client, directory }) => {
         // Never let a hook take down the opencode session.
       }
     },
-    // 1.18.13 fallback (Path C, oh-my-openagent pattern): the TUI drops
-    // tui.toast.show events on opencode 1.18.13 (untagged — see header), so
-    // queued agent-lifecycle signals (delegation start/done, hook failures,
-    // olympians/council summaries) are injected here as ONE <system-reminder> text
-    // part into the next user message, then cleared.
-    // P0 (2026-08-11, live E2E — release blocker): this hook ALSO fires for the
-    // child session's client.session.promptAsync (the old "subagent prompts use
-    // a different path" claim is FALSE on 1.18.13), where input.messageID is
-    // EMPTY/undefined. Injecting there with `?? ''` produced a part opencode's
-    // schema rejects (SchemaError: Expected a string starting with "msg", got
-    // "") → prompt_async failed → every delegation died in ~20ms. The guard
-    // below skips injection ENTIRELY on that path WITHOUT draining the buffer,
-    // so the reminder still lands on the parent's next real message.
-    'chat.message': async (input, output) => {
-      try {
-        if (ENABLED_TOAST_CATEGORIES.size === 0) return
-        if (pendingChatReminders.length === 0) return
-        // Subagent promptAsync fires have no messageID — injecting any part
-        // with an empty messageID crashes the child session (schema reject).
-        // Early return BEFORE the buffer drain keeps the reminder queued for
-        // the parent's next real (msg_-ID'd) message.
-        if (!input.messageID) return
-        const body = drainFreshChatReminders()
-        if (body === undefined) return
-        // Minimal TextPart — the core backfills messageID/sessionID for
-        // hook-injected parts (see opencode chat.message trigger pipeline).
-        // The guard above guarantees input.messageID is a non-empty string,
-        // so no `?? ''` fallback is needed (an explicit "" is schema-rejected).
-        output.parts.push({
-          id: `prt_${crypto.randomUUID()}`,
-          sessionID: input.sessionID,
-          messageID: input.messageID,
-          type: 'text',
-          text: `<system-reminder>\n${body}\n</system-reminder>`,
-        } satisfies Part)
-        await reportFailure(
-          ctx,
-          `[pantheon-hooks:chat-reminder] ${body}`,
-          { script: 'chat-reminder' },
-          'info',
-        )
-      } catch {
-        // Never let a hook take down the opencode session.
-      }
-    },
     event: async ({ event: ev }) => {
       try {
         if (ev.type === 'session.created') {

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';
+  state: 'running' | '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. */
@@ -77,7 +77,22 @@ declare function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry
  *  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. */
-declare function visibleDelegationList(all: readonly DelegationEntry[], maxTerminal?: number): DelegationEntry[];
+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;
+/** Idle silence window: if no updatedAt change in this window, the entry is
+ *  considered stale. Combined with the stale-running threshold to produce the
+ *  display-only `stale-running` state. */
+declare const IDLE_SILENCE_MS: number;
+/**
+ * Mark a running entry as `stale-running` if it has been running longer than
+ * the threshold AND has no recent activity (no `updatedAt` change in the last
+ * `IDLE_SILENCE_MS`). This is DISPLAY-ONLY — the board state is unchanged.
+ *
+ * A `stale-running` entry renders with a warning indicator but the underlying
+ * delegation is still treated as running by the backend.
+ */
+declare function markStaleIfRunning(entry: DelegationEntry, now: number, thresholdMs?: number): DelegationEntry;
 /** Compact elapsed-time label: "5m 12s", "1h 30m", "2d 4h" — ticks every
  *  second for running jobs. */
 declare function fmtElapsed(ms: number): string;
@@ -306,5 +321,5 @@ declare const plugin: TuiPluginModule & {
   id: string;
 };
 //#endregion
-export { ChildDelegationLike, DelegationActivity, DelegationEntry, DelegationToolPart, LiveDelegationEntry, LiveDelegationStore, ParsedDelegationToolPart, TuiSessionSources, buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, fmtElapsed, isValidSessionId, 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, 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 };
 //# 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":";;KAq6BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBAgHmB,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,uBACC;;;iBAQa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAO9C;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;;;;;;iBAwCa,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KA8KU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAucI,QAAQ;EAAoB"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAy6BY;;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"}

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

@@ -120,8 +120,14 @@ async function resolvePresetForTui(env, cwd) {
 }
 async function detectVersion(api) {
 	try {
-		const match = (await readFile(fileURLToPath(new URL("../../../../package.json", import.meta.url)), "utf8")).match(/"version":\s*"([^"]+)"/);
-		if (match?.[1]) return match[1];
+		const pkgContent = await readFile(fileURLToPath(new URL("../../package.json", import.meta.url)), "utf8");
+		const pkg = JSON.parse(pkgContent);
+		if (pkg.version) return pkg.version;
+	} catch {}
+	try {
+		const pkgContent = await readFile(fileURLToPath(new URL("../../../../package.json", import.meta.url)), "utf8");
+		const pkg = JSON.parse(pkgContent);
+		if (pkg.version) return pkg.version;
 	} catch {}
 	try {
 		const wt = api.state.path?.worktree ?? "";
@@ -765,7 +771,8 @@ function parseDelegationMarkdown(raw, fileAlias, sessionID = "") {
 	const startedAt = started !== void 0 ? Date.parse(started) : NaN;
 	if (agent === void 0 || state === void 0 || Number.isNaN(startedAt)) return null;
 	const normalized = state.toLowerCase();
-	if (normalized !== "running" && normalized !== "completed" && normalized !== "error" && normalized !== "startup_failed" && normalized !== "startup_unknown" && normalized !== "cancelled") return null;
+	if (normalized === "running") return null;
+	if (normalized !== "completed" && normalized !== "error" && normalized !== "startup_failed" && normalized !== "startup_unknown" && normalized !== "cancelled") return null;
 	const finalizedAt = finalized !== void 0 ? Date.parse(finalized) : NaN;
 	return {
 		alias: title ?? (fileAlias !== void 0 ? stripMdSuffix(fileAlias) : "unknown"),
@@ -861,8 +868,8 @@ function tuiLogPath(projectRoot) {
 *  falling back to startedAt, descending). Shared by the md reader and
 *  mergeDelegationSources. */
 function compareDelegationEntries(a, b) {
-	const aRun = a.state === "running" ? 1 : 0;
-	const bRun = b.state === "running" ? 1 : 0;
+	const aRun = a.state === "running" || a.state === "stale-running" ? 1 : 0;
+	const bRun = b.state === "running" || b.state === "stale-running" ? 1 : 0;
 	if (aRun !== bRun) return bRun - aRun;
 	return (b.updatedAt ?? b.startedAt) - (a.updatedAt ?? a.startedAt);
 }
@@ -870,11 +877,34 @@ function compareDelegationEntries(a, b) {
 *  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. */
-function visibleDelegationList(all, maxTerminal = 8) {
-	const running = all.filter((d) => d.state === "running");
+function visibleDelegationList(all, maxTerminal = 8, now = Date.now(), staleThresholdMs = 1800 * 1e3) {
+	const running = all.filter((d) => d.state === "running").map((d) => markStaleIfRunning(d, now, staleThresholdMs));
 	const terminal = all.filter((d) => d.state !== "running").slice(0, maxTerminal);
 	return [...running, ...terminal];
 }
+/** Default stale-running threshold: 30 minutes. */
+const STALE_RUNNING_THRESHOLD_MS = 1800 * 1e3;
+/** Idle silence window: if no updatedAt change in this window, the entry is
+*  considered stale. Combined with the stale-running threshold to produce the
+*  display-only `stale-running` state. */
+const IDLE_SILENCE_MS = 60 * 1e3;
+/**
+* Mark a running entry as `stale-running` if it has been running longer than
+* the threshold AND has no recent activity (no `updatedAt` change in the last
+* `IDLE_SILENCE_MS`). This is DISPLAY-ONLY — the board state is unchanged.
+*
+* A `stale-running` entry renders with a warning indicator but the underlying
+* delegation is still treated as running by the backend.
+*/
+function markStaleIfRunning(entry, now, thresholdMs = STALE_RUNNING_THRESHOLD_MS) {
+	if (entry.state !== "running") return entry;
+	if (now - entry.startedAt < thresholdMs) return entry;
+	if (entry.updatedAt !== null && now - entry.updatedAt < 6e4) return entry;
+	return {
+		...entry,
+		state: "stale-running"
+	};
+}
 /** Compact elapsed-time label: "5m 12s", "1h 30m", "2d 4h" — ticks every
 *  second for running jobs. */
 function fmtElapsed(ms) {
@@ -891,7 +921,7 @@ function fmtElapsed(ms) {
 /** Elapsed label for one entry: running → ticks `now - startedAt`, terminal
 *  → fixed `updatedAt - startedAt` (em dash when no finalized timestamp). */
 function delegationElapsed(entry, now) {
-	if (entry.state === "running") return fmtElapsed(now - entry.startedAt);
+	if (entry.state === "running" || entry.state === "stale-running") return fmtElapsed(now - entry.startedAt);
 	return entry.updatedAt !== null ? fmtElapsed(entry.updatedAt - entry.startedAt) : "—";
 }
 /** The activity labels shown by the animated row. Keeping this pure makes the
@@ -1318,7 +1348,7 @@ function childrenToDelegationEntries(children, md, now = Date.now()) {
 			agent: mdEntry?.agent ?? child.agent ?? "agent",
 			state,
 			startedAt: mdEntry?.startedAt ?? child.time?.created ?? now,
-			updatedAt: mdEntry?.updatedAt ?? (state === "running" ? null : child.time?.updated ?? null),
+			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 ?? "",
 			source: mdEntry !== void 0 ? "md" : "children-only"
@@ -1399,6 +1429,7 @@ function DelegationRow(props) {
 		const t = theme();
 		switch (props.job.state) {
 			case "running": return t.warning;
+			case "stale-running": return t.error;
 			case "completed": return t.success;
 			case "error": return t.error;
 			default: return t.textMuted;
@@ -1406,6 +1437,7 @@ function DelegationRow(props) {
 	});
 	const marker = createMemo(() => {
 		if (props.job.state === "running") return `${delegationSpinnerFrame(props.animationNow)} `;
+		if (props.job.state === "stale-running") return "⚠ ";
 		switch (props.job.state) {
 			case "completed": return "✓ ";
 			case "error": return "✕ ";
@@ -1842,6 +1874,6 @@ const plugin = {
 	tui
 };
 //#endregion
-export { buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, fmtElapsed, isValidSessionId, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, safeSessionPath, seedLiveDelegationMap, toDelegationEntry, tuiLogPath, visibleDelegationList };
+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 };
 
 //# sourceMappingURL=tui.js.map

package/src/plugins/tui/dist/tui.tsx

@@ -154,25 +154,29 @@ async function resolvePresetForTui(
  * Se falhar, retorna null e a View omite a versão.
  *
  * Try order:
+ *   0a. pantheon-tui/package.json (installed: dist/tui.js → 2 níveis)
+ *   0b. pantheon/package.json (dev: src/plugins/tui/dist/tui.tsx → 4 níveis)
  *   1. api.client.file.read package.json
  *   2. git describe --tags
  *   3. opencode --version
  *   4. null                                                      */
 
 async function detectVersion(api: TuiPluginApi): Promise<string | null> {
-  // Try 0: package.json do PACOTE PANTHEON instalado. O TUI é carregado de
-  // <pacote>/src/plugins/tui/dist/tui.tsx (fix #32 garante esse path) →
-  // 4 níveis acima (dist → tui → plugins → src → raiz) está o package.json
-  // do pacote. Funciona em QUALQUER cwd (ex: sandbox sem package.json/git) e
-  // também em dev (source no repo). Se falhar, cai para os tries abaixo.
+  // Try 0a: installed location (2 levels: dist/tui.js → pantheon-tui/package.json)
+  try {
+    const pkgUrl = new URL('../../package.json', import.meta.url)
+    const pkgContent = await readFile(fileURLToPath(pkgUrl), 'utf8')
+    const pkg = JSON.parse(pkgContent)
+    if (pkg.version) return pkg.version
+  } catch {}
+
+  // Try 0b: dev location (4 levels: src/plugins/tui/dist/tui.tsx → package.json)
   try {
     const pkgUrl = new URL('../../../../package.json', import.meta.url)
     const pkgContent = await readFile(fileURLToPath(pkgUrl), 'utf8')
-    const match = pkgContent.match(/"version":\s*"([^"]+)"/)
-    if (match?.[1]) return match[1]
-  } catch {
-    /* fall through */
-  }
+    const pkg = JSON.parse(pkgContent)
+    if (pkg.version) return pkg.version
+  } catch {}
 
   // Try 1: package.json do projeto (via worktree path)
   try {
@@ -942,7 +946,14 @@ export type DelegationEntry = {
   taskID?: string
   /** Agent name, e.g. "apollo". */
   agent: string
-  state: 'running' | 'completed' | 'error' | 'startup_failed' | 'startup_unknown' | 'cancelled'
+  state:
+    | 'running'
+    | '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. */
@@ -1048,8 +1059,10 @@ export function parseDelegationMarkdown(
   const startedAt = started !== undefined ? Date.parse(started) : NaN
   if (agent === undefined || state === undefined || Number.isNaN(startedAt)) return null
   const normalized = state.toLowerCase()
+  // Running state should only come from live channels, never from persisted
+  // reports. A stale "running" MD artifact contaminates the panel — skip it.
+  if (normalized === 'running') return null
   if (
-    normalized !== 'running' &&
     normalized !== 'completed' &&
     normalized !== 'error' &&
     normalized !== 'startup_failed' &&
@@ -1171,8 +1184,8 @@ export function tuiLogPath(projectRoot: string): string {
  *  falling back to startedAt, descending). Shared by the md reader and
  *  mergeDelegationSources. */
 export function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry): number {
-  const aRun = a.state === 'running' ? 1 : 0
-  const bRun = b.state === 'running' ? 1 : 0
+  const aRun = a.state === 'running' || a.state === 'stale-running' ? 1 : 0
+  const bRun = b.state === 'running' || b.state === 'stale-running' ? 1 : 0
   if (aRun !== bRun) return bRun - aRun
   return (b.updatedAt ?? b.startedAt) - (a.updatedAt ?? a.startedAt)
 }
@@ -1184,12 +1197,45 @@ export function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry)
 export function visibleDelegationList(
   all: readonly DelegationEntry[],
   maxTerminal = 8,
+  now = Date.now(),
+  staleThresholdMs = 30 * 60 * 1000, // 30 minutes
 ): DelegationEntry[] {
-  const running = all.filter((d) => d.state === 'running')
+  const running = all
+    .filter((d) => d.state === 'running')
+    .map((d) => markStaleIfRunning(d, now, staleThresholdMs))
   const terminal = all.filter((d) => d.state !== 'running').slice(0, maxTerminal)
   return [...running, ...terminal]
 }
 
+/** Default stale-running threshold: 30 minutes. */
+export const STALE_RUNNING_THRESHOLD_MS = 30 * 60 * 1000
+
+/** Idle silence window: if no updatedAt change in this window, the entry is
+ *  considered stale. Combined with the stale-running threshold to produce the
+ *  display-only `stale-running` state. */
+export const IDLE_SILENCE_MS = 60 * 1000
+
+/**
+ * Mark a running entry as `stale-running` if it has been running longer than
+ * the threshold AND has no recent activity (no `updatedAt` change in the last
+ * `IDLE_SILENCE_MS`). This is DISPLAY-ONLY — the board state is unchanged.
+ *
+ * A `stale-running` entry renders with a warning indicator but the underlying
+ * delegation is still treated as running by the backend.
+ */
+export function markStaleIfRunning(
+  entry: DelegationEntry,
+  now: number,
+  thresholdMs = STALE_RUNNING_THRESHOLD_MS,
+): DelegationEntry {
+  if (entry.state !== 'running') return entry
+  const elapsed = now - entry.startedAt
+  if (elapsed < thresholdMs) return entry
+  // If updatedAt exists and is recent, entry is still active — not stale.
+  if (entry.updatedAt !== null && now - entry.updatedAt < IDLE_SILENCE_MS) return entry
+  return { ...entry, state: 'stale-running' as const }
+}
+
 /** Compact elapsed-time label: "5m 12s", "1h 30m", "2d 4h" — ticks every
  *  second for running jobs. */
 export function fmtElapsed(ms: number): string {
@@ -1207,7 +1253,8 @@ export function fmtElapsed(ms: number): string {
 /** Elapsed label for one entry: running → ticks `now - startedAt`, terminal
  *  → fixed `updatedAt - startedAt` (em dash when no finalized timestamp). */
 export function delegationElapsed(entry: DelegationEntry, now: number): string {
-  if (entry.state === 'running') return fmtElapsed(now - entry.startedAt)
+  if (entry.state === 'running' || entry.state === 'stale-running')
+    return fmtElapsed(now - entry.startedAt)
   return entry.updatedAt !== null ? fmtElapsed(entry.updatedAt - entry.startedAt) : '\u2014'
 }
 
@@ -1874,7 +1921,9 @@ export function childrenToDelegationEntries(
       agent: mdEntry?.agent ?? child.agent ?? 'agent',
       state,
       startedAt: mdEntry?.startedAt ?? child.time?.created ?? now,
-      updatedAt: mdEntry?.updatedAt ?? (state === 'running' ? null : (child.time?.updated ?? null)),
+      updatedAt:
+        mdEntry?.updatedAt ??
+        (state === 'running' || state === 'stale-running' ? null : (child.time?.updated ?? null)),
       timedOut: mdEntry?.timedOut ?? false,
       description:
         mdEntry !== undefined && mdEntry.description !== ''
@@ -2008,6 +2057,8 @@ function DelegationRow(props: {
     switch (props.job.state) {
       case 'running':
         return t.warning
+      case 'stale-running':
+        return t.error // warning color for stale delegations
       case 'completed':
         return t.success
       case 'error':
@@ -2019,6 +2070,7 @@ function DelegationRow(props: {
 
   const marker = createMemo(() => {
     if (props.job.state === 'running') return `${delegationSpinnerFrame(props.animationNow)} `
+    if (props.job.state === 'stale-running') return '\u26a0 ' // warning triangle
     switch (props.job.state) {
       case 'completed':
         return '\u2713 '

package/src/plugins/tui/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pantheon-tui",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pantheon-tui",
-      "version": "1.3.2",
+      "version": "1.4.1",
       "license": "MIT",
       "dependencies": {
         "@opencode-ai/plugin": ">=1.14.0",

package/src/plugins/tui/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pantheon-tui",
   "type": "module",
-  "version": "1.3.7",
+  "version": "1.4.1",
   "description": "Pantheon TUI plugin — sidebar (version, preset, sessions, real-time delegations) + AI subscription usage gauges incl. OpenCode Go/Zen dollar limits (vendored, MIT)",
   "license": "MIT",
   "exports": {