pantheon-opencode 1.5.0 → 1.5.2

package/src/mcp/memory_mcp_server.py

@@ -6,6 +6,10 @@ for semantic memory with hybrid search (vector cosine + FTS5 BM25).
 
 Total footprint: ~50MB (sqlite-vec + fastembed) vs ~1.4GB (old chromadb).
 
+Both embedding backends are optional: if either fails to import the server
+still starts and serves FTS5-only search (``PANTHEON_MEMORY_EMBED=off``
+disables the vector pipeline explicitly).
+
 Tools:
     memory_store   — Store with automatic embedding
     memory_search  — Hybrid vector + FTS5 keyword search
@@ -30,9 +34,21 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
-import sqlite_vec
+# Embedding backends are optional (issue #159): a failed fastembed/sqlite_vec
+# install (network error, incompatible wheel) must not kill the server — it
+# degrades to FTS-only search instead of crashing before the MCP handshake.
+try:
+    import sqlite_vec
+except ImportError:  # pragma: no cover - degraded mode
+    sqlite_vec = None  # type: ignore[assignment]
+
 from _pantheon_paths import pantheon_home
-from fastembed import TextEmbedding
+
+try:
+    from fastembed import TextEmbedding
+except ImportError:  # pragma: no cover - degraded mode
+    TextEmbedding = None  # type: ignore[assignment]
+
 from mcp.server.fastmcp import FastMCP
 
 try:
@@ -52,6 +68,12 @@ except ImportError:  # pragma: no cover - deployed runtime may need path fix
 DB_PATH = pantheon_home() / "memory" / "memory.db"
 EMBED_CACHE = Path.home() / ".cache" / "fastembed"
 
+# PANTHEON_MEMORY_EMBED=off disables the embedding/vector pipeline so the
+# server serves FTS-only search (issue #159). Default "on" keeps the current
+# hybrid vector + FTS behavior. The flag is also forced off automatically
+# when fastembed failed to import.
+_EMBED_DISABLED = frozenset({"off", "0", "false", "no"})
+
 
 _BYTE_UNIT = 1024
 
@@ -81,11 +103,6 @@ CREATE TABLE IF NOT EXISTS memories (
 CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_ns_key
     ON memories(namespace, key);
 
-CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
-    id INTEGER PRIMARY KEY,
-    embedding float[384]
-);
-
 CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
     namespace, key, value, metadata,
     content='memories', content_rowid='id',
@@ -113,6 +130,14 @@ CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
 END;
 """
 
+# Vector store requires the sqlite-vec extension; created only when available.
+VEC_SCHEMA_SQL = """
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
+    id INTEGER PRIMARY KEY,
+    embedding float[384]
+);
+"""
+
 # ── FastMCP App ───────────────────────────────────────────────────────────────
 
 mcp = FastMCP(
@@ -129,7 +154,8 @@ def _get_db() -> sqlite3.Connection:
     """Get or create the SQLite connection singleton.
 
     Creates DB directory, applies WAL/performance pragmas, registers
-    the sqlite-vec extension, and runs schema init.
+    the sqlite-vec extension, and runs schema init. When sqlite-vec is
+    unavailable the vector table is skipped — search degrades to FTS-only.
     """
     DB_PATH.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(DB_PATH), check_same_thread=False)
@@ -137,9 +163,10 @@ def _get_db() -> sqlite3.Connection:
     conn.execute("PRAGMA journal_mode=WAL")
     conn.execute("PRAGMA busy_timeout=5000")
     conn.execute("PRAGMA foreign_keys=ON")
-    # Register sqlite-vec extension
-
-    sqlite_vec.load(conn)
+    # Register sqlite-vec extension (optional; enables vector search)
+    if sqlite_vec is not None:
+        sqlite_vec.load(conn)
+        conn.executescript(VEC_SCHEMA_SQL)
     conn.executescript(SCHEMA_SQL)
     if _codemap is not None:
         with contextlib.suppress(Exception):
@@ -155,13 +182,30 @@ def _get_conn() -> sqlite3.Connection:
 # ── Embedding ─────────────────────────────────────────────────────────────────
 
 
+def _embeddings_enabled() -> bool:
+    """Whether the embedding/vector pipeline is active.
+
+    Controlled by ``PANTHEON_MEMORY_EMBED`` (``on`` by default; ``off``,
+    ``0``, ``false`` or ``no`` disable it). Automatically disabled when
+    ``fastembed`` failed to import, so the server degrades to FTS-only
+    search instead of crashing at startup (issue #159).
+    """
+    if TextEmbedding is None:
+        return False
+    flag = os.environ.get("PANTHEON_MEMORY_EMBED", "on").strip().lower()
+    return flag not in _EMBED_DISABLED
+
+
 @functools.cache
-def _get_embedder() -> TextEmbedding:
+def _get_embedder() -> TextEmbedding | None:
     """Lazy-load fastembed model (auto-downloads on first call, ~30MB).
 
     Uses BAAI/bge-small-en-v1.5 (384-dim, CPU, ONNX) — no PyTorch needed.
-    Model is cached in ~/.cache/fastembed/.
+    Model is cached in ~/.cache/fastembed/. Returns None when fastembed is
+    unavailable.
     """
+    if TextEmbedding is None:
+        return None
     os.environ.setdefault("TQDM_DISABLE", "1")
     return TextEmbedding(
         model_name="BAAI/bge-small-en-v1.5",
@@ -169,9 +213,18 @@ def _get_embedder() -> TextEmbedding:
     )
 
 
-def _embed(text: str) -> list[float]:
-    """Generate a 384-dim embedding vector for the given text."""
-    return next(iter(_get_embedder().embed(text))).tolist()
+def _embed(text: str) -> list[float] | None:
+    """Generate a 384-dim embedding vector for the given text.
+
+    Returns None when embeddings are disabled (``PANTHEON_MEMORY_EMBED=off``
+    or fastembed missing) — callers fall back to FTS-only search.
+    """
+    if not _embeddings_enabled():
+        return None
+    embedder = _get_embedder()
+    if embedder is None:
+        return None
+    return next(iter(embedder.embed(text))).tolist()
 
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
@@ -341,14 +394,14 @@ def memory_store(
         )
         entry_id = cur.lastrowid
 
-        # Generate embedding
+        # Generate embedding (None when disabled → FTS-only mode)
         embedding = _embed(value)
-        embedding_json = json.dumps(embedding)
-
-        db.execute(
-            "INSERT INTO vec_memories(id, embedding) VALUES (?, ?)",
-            [entry_id, embedding_json],
-        )
+        if embedding is not None and sqlite_vec is not None:
+            embedding_json = json.dumps(embedding)
+            db.execute(
+                "INSERT INTO vec_memories(id, embedding) VALUES (?, ?)",
+                [entry_id, embedding_json],
+            )
         db.commit()
     except sqlite3.IntegrityError as e:
         db.rollback()
@@ -406,8 +459,8 @@ def memory_search(  # noqa: C901, PLR0912
     vec_ids: list[int] = []
     fts_ids: list[int] = []
 
-    # 2. Vector search
-    if query_vec is not None:
+    # 2. Vector search (skipped when embeddings or sqlite-vec are unavailable)
+    if query_vec is not None and sqlite_vec is not None:
         nvec = top_k * 2
         try:
             if namespace:
@@ -564,8 +617,9 @@ def memory_forget(
     db = _get_conn()
     try:
         if col == "id":
-            # Vec table cascade
-            db.execute("DELETE FROM vec_memories WHERE id = ?", [id])
+            # Vec table cascade (absent when sqlite-vec is unavailable)
+            if sqlite_vec is not None:
+                db.execute("DELETE FROM vec_memories WHERE id = ?", [id])
             cur = db.execute("DELETE FROM memories WHERE id = ?", [id])
         else:
             cur = db.execute(sql, params)

package/src/plugins/pantheon-hooks.ts

@@ -181,7 +181,7 @@ import { getSharedBoard } from '../pantheon/shared-board.ts'
 import { type HookPayload, type HookResult, runHook } from './hook-runner.ts'
 
 /** Tools that represent a subagent delegation (opencode `task` tool etc.). */
-const DELEGATION_TOOL_RE = /^(task|.*delegate.*|.*subagent.*)$/i
+const DELEGATION_TOOL_RE = /^(task|.*subagent.*)$/i
 
 /**
  * When set to a truthy value ("1" or "debug"), zero-exit audit-hook output is

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

@@ -18,8 +18,6 @@ type DelegationEntry = {
   updatedAt: number | null;
   timedOut: boolean;
   description: string;
-  /** True while the panel is waiting for pantheon_delegation_read. */
-  read?: boolean;
   /** Internal provenance used to keep a finalized md report authoritative.
    *  'children-only' = a native task() child session with NO delegate report
    *  (a native child row); 'md' = the child has a matching report;
@@ -145,7 +143,7 @@ declare function fmtElapsed(ms: number): string;
 declare function delegationElapsed(entry: DelegationEntry, now: number): string;
 /** The activity labels shown by the animated row. Keeping this pure makes the
  * state machine testable without booting OpenCode's renderer. */
-type DelegationActivity = 'delegating' | 'working' | 'reading' | 'completed' | 'error' | 'cancelled';
+type DelegationActivity = 'delegating' | 'working' | 'completed' | 'error' | 'cancelled';
 declare function delegationActivity(entry: DelegationEntry): DelegationActivity;
 declare function delegationActivityLabel(entry: DelegationEntry): string;
 /** Return the spinner glyph for the given frame counter. The frame counter
@@ -217,36 +215,34 @@ type DelegationToolPart = {
     };
   };
 };
-/** One live delegation tracked in-memory, keyed by the delegate callID. */
+/** One live delegation tracked in-memory, keyed by the task callID. */
 type LiveDelegationEntry = {
-  /** Tool call id of the pantheon_delegate part (stable across events). */
+  /** Tool call id of the task part (stable across events). */
   callID: string;
   /** Part id (for message.part.removed cleanup). */
   partID: string;
   /** Parent session the delegation was launched from. */
   sessionID: string;
-  tool: 'pantheon_delegate' | 'pantheon_delegation_read' | 'task';
-  /** Agent name (from the delegate input args). */
+  tool: 'task';
+  /** Agent name (from the task input args). */
   agent: string;
   description: string;
-  /** Known after the delegate tool completes (parsed from its output). */
+  /** Known once the task completes and its output carries a marker. */
   alias: string | null;
-  /** Child session id (parsed from the delegate output). */
+  /** Child session id (parsed from the task output, when present). */
   taskID: string | null;
   state: 'running' | 'completed' | 'error' | 'cancelled';
   startedAt: number;
   updatedAt: number | null;
-  /** True once a pantheon_delegation_read for this job has been observed. */
-  read: boolean;
 };
 /** Result of parsing one tool part into lifecycle-relevant fields. */
 type ParsedDelegationToolPart = {
   callID: string;
   partID: string;
   sessionID: string;
-  tool: 'pantheon_delegate' | 'pantheon_delegation_read' | 'task';
-  /** null for read parts (no agent arg — the id targets an existing job). */
-  agent: string | null;
+  tool: 'task';
+  /** Agent name from the task input args ('agent' fallback when absent). */
+  agent: string;
   description: string;
   status: 'pending' | 'running' | 'completed' | 'error';
   alias: string | null;
@@ -256,9 +252,8 @@ 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, the native `task` subagent tool
- *  (same parentID === caller mechanism — its children render `nat:`),
- *  or is missing its callID. */
+ *  not the native `task` subagent tool (parentID === caller mechanism —
+ *  its children render `nat:`), 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`. */
@@ -266,14 +261,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 + native task tool parts from a session's messages.
+/** Collect 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)`). 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 come from the children channel). Pure w.r.t. I/O — used
- *  by the mount re-scan to re-seed the live map after compaction/attach. */
+ *  child session with parentID = caller, so its parts feed the live-map as
+ *  the refresh signal (rows come from 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[];
@@ -284,7 +279,7 @@ declare function collectDelegationToolParts(messages: readonly {
  *  the map (0 on the second identical seed — idempotent, no extra bumps). */
 declare function seedLiveDelegationMap(map: Map<string, LiveDelegationEntry>, parts: readonly DelegationToolPart[], now?: number): number;
 /** Convert a live entry into the shared display shape. Alias falls back to
- *  a `live-<callID>` prefix while the delegate tool has not completed yet. */
+ *  a `live-<callID>` prefix while the task call has not completed yet. */
 declare function toDelegationEntry(live: LiveDelegationEntry): DelegationEntry;
 /** Combine the live channel with the md (historical) channel into one
  *  display list. Dedupes by (sessionID, alias) — aliases are per-parent-
@@ -467,7 +462,7 @@ declare function ceilingDelegationList(all: readonly DelegationEntry[], maxVisib
   hiddenActive: number;
   hiddenTerminal: number;
 };
-/** Split a display list into native task() rows vs pantheon_delegate rows.
+/** Split a display list into native task() rows vs pantheon report rows.
  *  Native = source 'children-only' (no delegate report); everything else counts
  *  as pantheon. Pure — powers the hooks.log line. */
 declare function countDelegationSources(entries: readonly DelegationEntry[]): {

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

@@ -1 +1 @@
-{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":"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"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":"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"}

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

@@ -165,7 +165,7 @@ async function detectVersion(api) {
 			if (ver) return ver;
 		}
 	} catch {}
-	return "1.5.0";
+	return "1.5.2";
 }
 /**
 * usage-bar — AI subscription usage gauge for the opencode TUI.
@@ -980,7 +980,6 @@ function delegationActivity(entry) {
 	if (entry.state === "completed") return "completed";
 	if (entry.state === "error" || entry.state === "startup_failed" || entry.state === "startup_unknown") return "error";
 	if (entry.state === "cancelled") return "cancelled";
-	if (entry.read) return "reading";
 	if (entry.alias.startsWith("live-") && entry.taskID === void 0) return "delegating";
 	return "working";
 }
@@ -989,7 +988,6 @@ function delegationActivityLabel(entry) {
 	switch (delegationActivity(entry)) {
 		case "delegating": return "DELEGATING";
 		case "working": return "WORKING";
-		case "reading": return "READING RESULT";
 		case "completed": return entry.timedOut ? "DONE (TIMED OUT)" : "DONE";
 		case "error": return "ERROR";
 		default: return "CANCELLED";
@@ -1129,7 +1127,6 @@ function mergeChildDelegationSources(children, live) {
 		if (existing.state !== "running") {
 			if (liveEntry.alias !== null && existing.alias !== incoming.alias) existing.alias = incoming.alias;
 			if (incoming.agent !== "agent" && existing.agent !== incoming.agent) existing.agent = incoming.agent;
-			if (incoming.read && !existing.read) existing.read = true;
 			continue;
 		}
 		result[index] = {
@@ -1142,7 +1139,6 @@ function mergeChildDelegationSources(children, live) {
 			state: incoming.state,
 			startedAt: Math.min(existing.startedAt, incoming.startedAt),
 			updatedAt: incoming.updatedAt,
-			read: incoming.read,
 			source: isNativeLive ? existing.source : "live"
 		};
 	}
@@ -1150,22 +1146,19 @@ function mergeChildDelegationSources(children, live) {
 	return result;
 }
 /** Duck-typed subset of a tool part (SDK v2 `ToolPart` / `ToolState`). */
-/** One live delegation tracked in-memory, keyed by the delegate callID. */
+/** One live delegation tracked in-memory, keyed by the task callID. */
 /** Result of parsing one tool part into lifecycle-relevant fields. */
-/** Alias in the delegate output: "Delegated to apollo: [apo-1] (task …)". */
+/** Alias in the task output: "Delegated to apollo: [apo-1] (task …)". */
 const DELEGATE_ALIAS_PATTERN = /\[([a-z]{2,8}-\d+)\]/i;
-/** Child task id in the delegate output: "(task ses_child_9)". */
+/** Child task id in the task output: "(task ses_child_9)". */
 const DELEGATE_TASKID_PATTERN = /\(task\s+([a-z0-9_]+)\)/i;
-/** Plain alias, as passed to pantheon_delegation_read input.id: "apo-1". */
-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, the native `task` subagent tool
-*  (same parentID === caller mechanism — its children render `nat:`),
-*  or is missing its callID. */
+*  not the native `task` subagent tool (parentID === caller mechanism —
+*  its children render `nat:`), 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" && part.tool !== "task") return null;
+	if (part.tool !== "task") return null;
 	const callID = part.callID;
 	if (callID === void 0 || callID === "") return null;
 	const sessionID = part.sessionID ?? "";
@@ -1175,28 +1168,6 @@ function parseDelegationToolPart(part, now = Date.now()) {
 	const input = state.input ?? {};
 	const startedAt = state.time?.start ?? now;
 	const endAt = state.time?.end ?? null;
-	if (part.tool === "pantheon_delegation_read") {
-		const target = typeof input.id === "string" ? input.id : null;
-		let alias = null;
-		let taskID = null;
-		if (target !== null) {
-			if (READ_ALIAS_PATTERN.test(target)) alias = target;
-			else if (target.startsWith("ses_")) taskID = target;
-		}
-		return {
-			callID,
-			partID: part.id ?? "",
-			sessionID,
-			tool: "pantheon_delegation_read",
-			agent: null,
-			description: "",
-			status,
-			alias,
-			taskID,
-			startedAt,
-			endAt
-		};
-	}
 	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;
@@ -1210,7 +1181,7 @@ function parseDelegationToolPart(part, now = Date.now()) {
 		callID,
 		partID: part.id ?? "",
 		sessionID,
-		tool: part.tool === "task" ? "task" : "pantheon_delegate",
+		tool: "task",
 		agent,
 		description,
 		status,
@@ -1220,38 +1191,11 @@ function parseDelegationToolPart(part, now = Date.now()) {
 		endAt
 	};
 }
-/** Find a live entry by alias or taskID (read parts resolve by id). */
-function findLiveByTarget(map, alias, taskID) {
-	if (alias === null && taskID === null) return void 0;
-	for (const entry of map.values()) {
-		if (alias !== null && entry.alias === alias) return entry;
-		if (taskID !== null && entry.taskID === taskID) return entry;
-	}
-}
 /** Apply one tool part to the live map. Returns true when the map changed.
 *  Pure w.r.t. I/O — only mutates `map`. */
 function reduceDelegationToolPart(map, part, now = Date.now()) {
 	const parsed = parseDelegationToolPart(part, now);
 	if (parsed === null) return false;
-	if (parsed.tool === "pantheon_delegation_read") {
-		const target = findLiveByTarget(map, parsed.alias, parsed.taskID);
-		if (target === void 0) return false;
-		let changed = false;
-		if (!target.read) {
-			target.read = true;
-			changed = true;
-		}
-		if (parsed.status === "completed" && target.state === "running") {
-			target.state = "completed";
-			target.updatedAt = parsed.endAt ?? now;
-			changed = true;
-		} else if (parsed.status === "error" && target.state === "running") {
-			target.state = "error";
-			target.updatedAt = parsed.endAt ?? now;
-			changed = true;
-		}
-		return changed;
-	}
 	const existing = map.get(parsed.callID);
 	if (parsed.status === "error") {
 		if (existing !== void 0 && existing.state === "error" && existing.updatedAt === parsed.endAt) return false;
@@ -1260,14 +1204,13 @@ function reduceDelegationToolPart(map, part, now = Date.now()) {
 			partID: parsed.partID,
 			sessionID: parsed.sessionID,
 			tool: parsed.tool,
-			agent: parsed.agent ?? "agent",
+			agent: parsed.agent,
 			description: parsed.description,
 			alias: existing?.alias ?? null,
 			taskID: existing?.taskID ?? null,
 			state: "error",
 			startedAt: existing?.startedAt ?? parsed.startedAt,
-			updatedAt: parsed.endAt ?? now,
-			read: existing?.read ?? false
+			updatedAt: parsed.endAt ?? now
 		});
 		return true;
 	}
@@ -1277,14 +1220,13 @@ function reduceDelegationToolPart(map, part, now = Date.now()) {
 			partID: parsed.partID,
 			sessionID: parsed.sessionID,
 			tool: parsed.tool,
-			agent: parsed.agent ?? "agent",
+			agent: parsed.agent,
 			description: parsed.description,
 			alias: parsed.alias,
 			taskID: parsed.taskID,
 			state: "running",
 			startedAt: parsed.startedAt,
-			updatedAt: null,
-			read: false
+			updatedAt: null
 		});
 		return true;
 	}
@@ -1321,14 +1263,14 @@ function removeDelegationEntry(map, partIDOrCallID) {
 	}
 	return false;
 }
-/** Collect pantheon delegation + native task tool parts from a session's messages.
+/** Collect 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)`). 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 come from the children channel). Pure w.r.t. I/O — used
-*  by the mount re-scan to re-seed the live map after compaction/attach. */
+*  child session with parentID = caller, so its parts feed the live-map as
+*  the refresh signal (rows come from 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 ?? []) {
@@ -1338,7 +1280,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" || part.tool === "task")) out.push(part);
+			if (part?.type === "tool" && part.tool === "task") out.push(part);
 		}
 	}
 	return out;
@@ -1353,7 +1295,7 @@ function seedLiveDelegationMap(map, parts, now = Date.now()) {
 	return changed;
 }
 /** Convert a live entry into the shared display shape. Alias falls back to
-*  a `live-<callID>` prefix while the delegate tool has not completed yet. */
+*  a `live-<callID>` prefix while the task call has not completed yet. */
 function toDelegationEntry(live) {
 	return {
 		alias: live.alias ?? `live-${live.callID.slice(0, 8)}`,
@@ -1365,7 +1307,6 @@ function toDelegationEntry(live) {
 		updatedAt: live.updatedAt,
 		timedOut: false,
 		description: live.description,
-		read: live.read,
 		source: "live"
 	};
 }
@@ -1640,7 +1581,7 @@ function ceilingDelegationList(all, maxVisible = 8, now = Date.now()) {
 		hiddenTerminal
 	};
 }
-/** Split a display list into native task() rows vs pantheon_delegate rows.
+/** Split a display list into native task() rows vs pantheon report rows.
 *  Native = source 'children-only' (no delegate report); everything else counts
 *  as pantheon. Pure — powers the hooks.log line. */
 function countDelegationSources(entries) {
@@ -1665,8 +1606,8 @@ function formatPanelLogLine(children, pantheon, native, md, events) {
 *  report still renders: description from its title, agent from the child
 *  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', a
+*  child of the current session — the native `task()` tool — carries
+*  parentID = caller), so it gets source 'children-only', a
 *  per-child alias 'native-<last4 of the child id>' (one identity per native
 *  row) instead of a report alias. The 'task nativa' description fallback
 *  keeps the row non-empty when the child carries no title.

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

@@ -1,12 +1,12 @@
 {
   "name": "pantheon-tui",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pantheon-tui",
-      "version": "1.5.0",
+      "version": "1.5.2",
       "license": "MIT",
       "dependencies": {
         "@opencode-ai/plugin": ">=1.14.0",
@@ -18,6 +18,9 @@
         "rolldown-plugin-solid": "^0.2.1",
         "tsdown": "^0.22.14"
       },
+      "engines": {
+        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+      },
       "peerDependencies": {
         "@opencode-ai/plugin": ">=1.14.0",
         "@opencode-ai/sdk": ">=1.14.0",

package/src/plugins/tui/package.json

@@ -1,9 +1,12 @@
 {
   "name": "pantheon-tui",
   "type": "module",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "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",
+  "engines": {
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+  },
   "exports": {
     "./tui": "./dist/tui.js",
     "./server": "./dist/server.js"