pantheon-opencode 1.6.0-beta.6 → 1.6.0-beta.8

package/src/plugin-v2.ts

@@ -19,8 +19,8 @@
  *   `src/plugin-v2` in `plugins`, so the V1 plugin never loads on a V2-only
  *   install and V1's identical block was inert by construction.
 
- * - A tool `execute.after` hook and a permission hook, registered as
- *   registration points with no V2-side behaviour
+ * - A tool `execute.after` hook and a permission hook, with permission
+ *   evaluation enforcing the caller/target matrix for Pantheon agents
  *
  * Every tool registered through `draft.add` MUST declare `output`, and its
  * `execute` MUST resolve to a value carrying `output`. The host enforces the
@@ -93,9 +93,17 @@ import {
   type PantheonV2Bridge,
   type V2ContextLike,
 } from './pantheon/v2-bridge.ts'
+import {
+  type AuthoritativeSession,
+  evaluateV2Delegation,
+  PANTHEON_AGENTS,
+  type V2PermissionEvent,
+  v2ResourceTarget,
+} from './pantheon/v2-delegation-enforce.ts'
+import { createV2ExecuteAfter, resolveV2SandboxConfig } from './pantheon/v2-execute-after.ts'
 import { createV2ToolDefinitions, type V2ToolResult } from './pantheon/v2-tools.ts'
 import { V2_UNSUPPORTED_FEATURE_SEED } from './pantheon/v2-unsupported.mjs'
-import { type HookPayload, runHook } from './plugins/hook-runner.ts'
+import { type HookPayload, type HookResult, runHook } from './plugins/hook-runner.ts'
 
 // ─── Unsupported Features Registry ───────────────────────────────────────
 
@@ -220,23 +228,26 @@ interface V2EventDomain {
 /**
  * The minimal shape of `ctx.permission`.
  *
- * Only a hook name and a handler: the plugin registers `evaluate` as a
- * registration point and deliberately runs no V2-side permission logic, so no
- * richer payload type is claimed here.
+ * The V2.0.25 live contract supplies an `evaluate` event with `resources`;
+ * runtime validation remains defensive because SDK declarations omit this
+ * domain and the host may evolve independently.
  */
 interface V2PermissionDomain {
-  hook?: (name: string, handler: (event: unknown) => void | Promise<void>) => Promise<unknown>
+  hook?: (
+    name: string,
+    handler: (event: unknown, output?: unknown) => void | Promise<void>,
+  ) => Promise<unknown>
 }
 
 /**
- * The minimal shape of `ctx.session`.
- *
- * Only `hook(name, handler)`. The host accepts any string and silently drops an
- * unknown one — which is why the hook names below were a live defect once and
- * why the host-backed hook canary exists.
+ * The minimal shape of `ctx.session` used by this module. `get` follows the V2
+ * Promise API's object input (`{ sessionID }`); session hooks accept any string
+ * and silently drop an unknown one, which is why the host-backed hook canary
+ * exists.
  */
 interface V2SessionDomain {
   hook?: (name: string, handler: (event: unknown) => void | Promise<void>) => Promise<unknown>
+  get?: (input: { sessionID: string }) => Promise<unknown>
 }
 
 /** `PluginContext` plus the four domains 1.18.x omits. See the module header. */
@@ -760,6 +771,26 @@ function maskSecret(text: string): string {
 const SECRET_BLOCK_MESSAGE =
   '[plugin-v2] Blocked: high-confidence secret detected in tool input — see .pantheon/logs/hooks.log'
 
+/**
+ * Message thrown when the secret scanner cannot produce a trustworthy verdict —
+ * the script is missing/unexecutable, the child timed out or was killed, the
+ * payload could not be serialized, the report was malformed, or the exit status
+ * was unexpected.
+ *
+ * This is a deliberate fail-CLOSED denial. The previous handler blocked only
+ * `code === 2` and treated every other outcome as advisory — but the runner
+ * reports a missing script, a spawn failure and a payload-serialization failure
+ * as `code: 1` too (src/plugins/hook-runner.ts), so a broken scanner read as a
+ * clean advisory and the tool ran, silently disabling the only hard secret block
+ * on the V2 surface.
+ *
+ * English and user-facing, like {@link SECRET_BLOCK_MESSAGE}. It carries no
+ * scanner output on purpose: a scan that failed mid-flight may still be holding
+ * the raw payload, and the denial must not become the leak it exists to prevent.
+ */
+const SECRET_SCAN_UNAVAILABLE_MESSAGE =
+  '[plugin-v2] Blocked: the secret scanner could not complete, so this tool call was denied (fail-closed) — see .pantheon/logs/hooks.log'
+
 /**
  * Append one masked, ISO-stamped line to .pantheon/logs/hooks.log under the
  * working directory, and return whether it landed.
@@ -795,6 +826,98 @@ function appendV2HookLog(line: string): boolean {
   }
 }
 
+// ─── V2 Secret-Scan Verdict ─────────────────────────────────────────────
+
+/**
+ * The scanner's own report marker, written to stderr on every non-clean run
+ * (exit 1 advisory, exit 2 block). It is the discriminator between a genuine
+ * low-confidence advisory and a runner infrastructure failure, BOTH of which
+ * surface as `code === 1`: the runner's own failures (missing/unexecutable
+ * script, spawn error, payload-serialization error) resolve a structured
+ * `HookResult` with `code: 1` and no scan report, while the real scanner's
+ * advisory always carries this marker. Requiring it means a scanner that stops
+ * reporting fails toward a denial, never toward a silent allow.
+ */
+const SECRET_SCAN_MARKER = '[SECRET SCAN]'
+
+/** Sanitized failure classes — logged in place of raw scanner output. */
+type SecretScanFailureReason =
+  | 'scanner-timeout'
+  | 'scanner-signal'
+  | 'scanner-spawn-failure'
+  | 'scanner-serialization-failure'
+  | 'scanner-malformed-output'
+  | 'scanner-unexpected-exit'
+
+type SecretScanDecision =
+  | { action: 'allow' }
+  | { action: 'advisory' }
+  | { action: 'block' }
+  | { action: 'fail-closed'; reason: SecretScanFailureReason }
+
+/**
+ * The runner's own infrastructure-failure messages (see hook-runner.ts), matched
+ * at the start of stderr where the runner is the only writer. Matching a prefix
+ * rather than a substring keeps a scan report that merely happens to quote one
+ * of these phrases from flipping a valid advisory into a denial.
+ */
+const SCANNER_INFRA_FAILURES: ReadonlyArray<[string, SecretScanFailureReason]> = [
+  ['payload serialization failed:', 'scanner-serialization-failure'],
+  ['spawn failed:', 'scanner-spawn-failure'],
+  ['hook script failed to spawn:', 'scanner-spawn-failure'],
+]
+
+/**
+ * Classify one secret-scan {@link HookResult} into an enforcement decision.
+ *
+ * fail-closed by construction: `allow` and `advisory` are reachable only from a
+ * result that is unambiguously a completed scanner run. Everything else —
+ * timeout, signal, spawn/serialization failure, missing report, unknown or
+ * unexpected exit status — denies. `advisory` additionally requires the
+ * scanner's own report marker, which is what separates an exit-1 advisory from
+ * the runner's exit-1 infrastructure failure.
+ *
+ * `block` covers the high-confidence match (exit 2); the caller turns it into
+ * the user-facing block.
+ */
+function evaluateSecretScanResult(scan: HookResult): SecretScanDecision {
+  if (scan.timedOut) return { action: 'fail-closed', reason: 'scanner-timeout' }
+  if (scan.signal !== null) return { action: 'fail-closed', reason: 'scanner-signal' }
+  if (!Number.isInteger(scan.code)) {
+    return { action: 'fail-closed', reason: 'scanner-malformed-output' }
+  }
+  for (const [signature, reason] of SCANNER_INFRA_FAILURES) {
+    if (scan.stderr.startsWith(signature)) return { action: 'fail-closed', reason }
+  }
+  if (scan.code === 0) return { action: 'allow' }
+  if (scan.code === 2) return { action: 'block' }
+  if (scan.code === 1) {
+    return scan.stderr.includes(SECRET_SCAN_MARKER)
+      ? { action: 'advisory' }
+      : { action: 'fail-closed', reason: 'scanner-malformed-output' }
+  }
+  return { action: 'fail-closed', reason: 'scanner-unexpected-exit' }
+}
+
+/** Invocation of scripts/hooks/scan-secrets.sh used by the tool guard. */
+type SecretScanRunner = (payload: HookPayload) => Promise<HookResult>
+
+const defaultSecretScanRunner: SecretScanRunner = (payload) => runHook('scan-secrets.sh', payload)
+
+let secretScanRunner: SecretScanRunner = defaultSecretScanRunner
+
+/**
+ * Test seam — override (or, with `null`, restore) the V2 secret-scan runner.
+ *
+ * Exported only for tests/pantheon/plugin-v2-contract.test.ts, which injects
+ * structured {@link HookResult}s (missing scanner, timeout, malformed output)
+ * that the real script cannot be made to produce on demand. There is no
+ * production caller; the shipped handler always uses `defaultSecretScanRunner`.
+ */
+export function setV2SecretScanRunnerForTests(runner: SecretScanRunner | null): void {
+  secretScanRunner = runner ?? defaultSecretScanRunner
+}
+
 // ─── V2 Tool Hooks ──────────────────────────────────────────────────────
 
 /**
@@ -952,10 +1075,13 @@ async function registerV2ToolHooks(context: PluginContext): Promise<boolean> {
       // `plugins` declares only `src/plugin-v2`. V1's scan-secrets block was
       // therefore inert by construction, not by misconfiguration.
       //
-      // exit 2 → block. exit 1 (low-confidence header/KEY names) → advisory,
-      // logged only. A scanner failure (missing script, timeout) is fail-OPEN:
-      // runHook never rejects, and an infrastructure error must not deny
-      // unrelated tool calls.
+      // exit 0 → allow. exit 1 with a valid scanner report → advisory, logged
+      // only. exit 2 (high-confidence match) → deny. A scanner that does NOT
+      // produce a trustworthy verdict — missing/unexecutable script, timeout,
+      // killed child, spawn/serialization failure, malformed or unexpected
+      // output — is fail-CLOSED: this pending tool call is denied, the session
+      // is not. (runHook resolves a structured result instead of rejecting, so
+      // the exit-code-only reading below cannot lean on an exception.)
       let blockError: Error | null = null
       try {
         const payload: HookPayload = {
@@ -964,18 +1090,29 @@ async function registerV2ToolHooks(context: PluginContext): Promise<boolean> {
           agent_id: typeof agent === 'string' ? agent : '',
           session_id: input.sessionID,
         }
-        const scan = await runHook('scan-secrets.sh', payload)
-        if (scan.code === 2) {
+        const scan = await secretScanRunner(payload)
+        const decision = evaluateSecretScanResult(scan)
+        if (decision.action === 'block') {
           appendV2HookLog(SECRET_BLOCK_MESSAGE)
           appendV2HookLog(scan.stderr)
           blockError = new Error(SECRET_BLOCK_MESSAGE)
-        } else if (scan.code === 1) {
+        } else if (decision.action === 'advisory') {
           // Advisory: log only, never block.
           appendV2HookLog(scan.stderr)
+        } else if (decision.action === 'fail-closed') {
+          // Sanitized failure category only — never the scanner's raw stderr,
+          // which on a failure path is unverified and may carry the very
+          // payload the scan exists to keep out of logs.
+          appendV2HookLog(`${SECRET_SCAN_UNAVAILABLE_MESSAGE} (${decision.reason})`)
+          blockError = new Error(SECRET_SCAN_UNAVAILABLE_MESSAGE)
         }
       } catch {
-        // Never let the scanner take down the session — runHook resolves a
-        // structured result instead of rejecting, so this is belt-and-braces.
+        // The runner is contracted to resolve a structured result, so this only
+        // guards an unexpected throw (including a future change to the runner).
+        // A scanner that cannot run is fail-CLOSED: deny this call rather than
+        // let it through with no scan at all.
+        appendV2HookLog(SECRET_SCAN_UNAVAILABLE_MESSAGE)
+        blockError = new Error(SECRET_SCAN_UNAVAILABLE_MESSAGE)
       }
       if (blockError !== null) throw blockError
     })
@@ -985,15 +1122,19 @@ async function registerV2ToolHooks(context: PluginContext): Promise<boolean> {
   }
 
   try {
-    // "execute.after" — hashline read enhance + context sandbox.
+    // "execute.after" — the V1 parity chain (task-result-guard →
+    // context-sandbox → read-enhancer) rebuilt on the V2 event shape.
     //
-    // Registration point only: there is no V2-side behaviour here. The
-    // enhancer/sandbox live in the V1 path (`pantheon-hooks.ts` +
-    // `context-sandbox.ts`), a separate plugin instance that is not loaded when
-    // only `plugin-v2` is configured.
-    await toolCtx.hook('execute.after', (_event: unknown) => {
-      // Intentionally empty.
+    // This IS behaviour, not a registration point: on a V2-only install the V1
+    // `pantheon-hooks` plugin is not loaded, so this handler is the only thing
+    // that truncates oversized output and tags `read` with hashline refs.
+    // The sandbox config comes from `ctx.options.context_sandbox` (the V2 copy
+    // the installer writes — V2.0.25 drops the V1 top-level key), resolved with
+    // the same resolver V1 uses.
+    const v2ExecuteAfter = createV2ExecuteAfter({
+      sandbox: resolveV2SandboxConfig(context.options),
     })
+    await toolCtx.hook('execute.after', (event: unknown) => v2ExecuteAfter(event))
     registered = true
   } catch {
     // Tool after-hook not supported
@@ -1008,12 +1149,15 @@ async function registerV2ToolHooks(context: PluginContext): Promise<boolean> {
  * Register permission hook via V2 ctx.permission.hook.
  *
  * The V2 permission.hook API (when available) provides:
- *   ctx.permission.hook("evaluate", handler) — custom permission logic
+ *   ctx.permission.hook("evaluate", handler) — host permission evaluation
+ * The handler receives one mutable PermissionEvaluation event; decisions are
+ * written to event.effect/event.message (there is no separate V1-style output).
  *
  * Returns true if the hook was registered.
  */
 async function registerV2PermissionHook(context: PluginContext): Promise<boolean> {
-  const permCtx = hostDomains(context).permission
+  const domains = hostDomains(context)
+  const permCtx = domains.permission
 
   if (!permCtx?.hook) {
     markUnsupported('permission-hook')
@@ -1021,12 +1165,103 @@ async function registerV2PermissionHook(context: PluginContext): Promise<boolean
   }
 
   try {
-    await permCtx.hook('evaluate', (_event: unknown) => {
-      // Registration point only — no V2-side permission logic. Read-only
-      // enforcement does NOT run here: it runs in the `execute.before` handler
-      // above, which is the hook the host consults before a tool executes. Do
-      // not read this as "the V1 guards cover it": V1 is a different plugin
-      // instance and is not loaded when only `plugin-v2` is configured.
+    await permCtx.hook('evaluate', async (rawEvent: unknown) => {
+      const event = rawEvent as V2PermissionEvent | null
+      const effectBefore = event?.effect
+      const writeProof = (): void => {
+        const proofPath = process.env.PANTHEON_HOOK_CANARY_PERMISSION_PROOF
+        if (!proofPath || !event || !Array.isArray(event.resources)) return
+        try {
+          appendFileSync(
+            proofPath,
+            `permission.evaluate ${JSON.stringify({
+              resources: event.resources,
+              agent: event.agent,
+              sessionID: event.sessionID,
+              effect: event.effect,
+              message: event.message,
+              eventFields: ['resources', 'agent', 'sessionID', 'effect'].filter((key) =>
+                Object.hasOwn(event, key),
+              ),
+              effectBefore: effectBefore ?? null,
+              effectAfter: event.effect ?? null,
+            })}\n`,
+          )
+        } catch {
+          // Instrumentation is best-effort and must not affect permission flow.
+        }
+      }
+      const deny = (reason: string): void => {
+        if (event === null || typeof event !== 'object') {
+          throw new Error(
+            `permission event is unavailable; denying V2 permission evaluation (${reason})`,
+          )
+        }
+        event.effect = 'deny'
+        event.message = `Pantheon delegation denied: ${reason}`
+        if (event.effect !== 'deny') {
+          throw new Error(
+            `permission event is not mutable; denying V2 permission evaluation (${reason})`,
+          )
+        }
+        writeProof()
+      }
+
+      if (event?.effect === 'deny') {
+        writeProof()
+        return // explicit host deny is final
+      }
+      if (event == null) {
+        deny('permission event is missing')
+        return
+      }
+      if (!Array.isArray(event.resources) || event.resources.length === 0) {
+        deny('permission resources are missing or malformed')
+        return
+      }
+      const targets = event.resources.map(v2ResourceTarget)
+      if (targets.some((target) => target === undefined)) {
+        deny('permission resource target is malformed')
+        return
+      }
+      const hasPantheonTarget = targets.some((target) => PANTHEON_AGENTS.has(target ?? ''))
+      let session: AuthoritativeSession | undefined
+      if (hasPantheonTarget) {
+        const sessionID = typeof event.sessionID === 'string' ? event.sessionID.trim() : ''
+        if (!sessionID) {
+          deny('caller session ID is missing')
+          return
+        }
+
+        const sessionDomain = domains.session
+        if (!sessionDomain || typeof sessionDomain.get !== 'function') {
+          deny('session lookup API is unavailable')
+          return
+        }
+
+        let retrieved: unknown
+        try {
+          retrieved = await sessionDomain.get({ sessionID })
+        } catch {
+          deny('caller session lookup failed')
+          return
+        }
+        if (retrieved === null || retrieved === undefined) {
+          deny('caller session was not found')
+          return
+        }
+        if (typeof retrieved !== 'object' || Array.isArray(retrieved)) {
+          deny('caller session lookup returned invalid data')
+          return
+        }
+        session = retrieved as AuthoritativeSession
+      }
+
+      // Native-only resources remain under host policy. If a Pantheon target
+      // appears anywhere, the shared policy evaluates the complete resource set.
+      const decision = evaluateV2Delegation(event, session, event.effect)
+      if (decision === 'deny') deny('caller or target is not allowed by delegation policy')
+      else writeProof()
     })
     return true
   } catch {

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

@@ -1,4 +1,4 @@
-import { TuiPluginModule } from "@opencode-ai/plugin/tui";
+import { TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui";
 //#region src/index.d.ts
 export type DelegationEntry = {
   /** Job alias, e.g. "apo-1" (from the H1 title, falling back to filename). */
@@ -487,17 +487,20 @@ export declare function navigateToDelegationSession(route: {
 export declare function createDelegationRowOpenHandler(route: {
   navigate?: (name: string, params?: Record<string, unknown>) => void | PromiseLike<void>;
 } | undefined, taskID: string | undefined): () => void;
-/** Plugin-level live delegation store shared with the event subscriptions
- *  in `tui()`: the map of live entries + a version signal bumped on every
- *  mutation. The View subscribes to the version (in an effect) to refresh the
- *  durable child list and also reads the map as an optimistic live source. */
+/** Plugin-level live delegation store shared by event subscriptions and View.
+ *  Mutations notify subscribers so the View can refresh its durable child
+ *  list while also reading the map as an optimistic live source. */
 export type LiveDelegationStore = {
   map: Map<string, LiveDelegationEntry>;
-  /** Reactive version getter — View reads it inside an effect to re-fetch. */
-  version: () => number;
-  /** Bump the version after a live mutation. */
+  /** Subscribe to invalidations consumed by the sidebar's refresh path. */
+  subscribe: (listener: () => void) => () => void;
+  /** Notify sidebar subscribers after a live mutation. */
   bump: () => void;
 };
+/** Create the observable live store shared by task events and the sidebar. */
+export declare function createLiveDelegationStore(): LiveDelegationStore;
+/** Register the live task-part events that invalidate the sidebar store. */
+export declare function registerLiveDelegationEvents(api: TuiPluginApi, liveStore: LiveDelegationStore): () => void;
 declare const plugin: TuiPluginModule & {
   id: string;
   setup: () => Promise<void>;

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

@@ -4,7 +4,7 @@ import { appendFile, mkdir, readFile, readdir, writeFile } from "node:fs/promise
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { For, Show, createEffect, createMemo, createResource, createSignal, onCleanup, onMount } from "solid-js";
+import { For, Show, createMemo, createResource, createSignal, onCleanup, onMount } from "solid-js";
 //#region src/index.tsx
 /** @jsxImportSource @opentui/solid */
 /**
@@ -167,7 +167,7 @@ async function detectVersion(api) {
 			if (ver) return ver;
 		}
 	} catch {}
-	return "1.6.0-beta.6";
+	return "1.6.0-beta.8";
 }
 /**
 * usage-bar — AI subscription usage gauge for the opencode TUI.
@@ -1805,10 +1805,49 @@ function DelegationRow(props) {
 		return _el$13;
 	})();
 }
-/** Plugin-level live delegation store shared with the event subscriptions
-*  in `tui()`: the map of live entries + a version signal bumped on every
-*  mutation. The View subscribes to the version (in an effect) to refresh the
-*  durable child list and also reads the map as an optimistic live source. */
+/** Plugin-level live delegation store shared by event subscriptions and View.
+*  Mutations notify subscribers so the View can refresh its durable child
+*  list while also reading the map as an optimistic live source. */
+/** Create the observable live store shared by task events and the sidebar. */
+function createLiveDelegationStore() {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		map: /* @__PURE__ */ new Map(),
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		bump() {
+			for (const listener of listeners) listener();
+		}
+	};
+}
+/** Register the live task-part events that invalidate the sidebar store. */
+function registerLiveDelegationEvents(api, liveStore) {
+	const unsubLive = [];
+	try {
+		unsubLive.push(api.event.on("message.part.updated", (event) => {
+			const props = event?.properties ?? {};
+			const part = props.part ?? props.info?.part;
+			if (part === void 0) return;
+			const sample = extractToolActivity(part);
+			if (sample !== null) trackToolActivity(latestToolActivity, sample.sessionID, sample.activity);
+			if (reduceDelegationToolPart(liveStore.map, part)) liveStore.bump();
+		}));
+	} catch {}
+	try {
+		unsubLive.push(api.event.on("message.part.removed", (event) => {
+			const props = event?.properties ?? {};
+			const partID = props.partID ?? props.part?.id;
+			if (partID !== void 0 && removeDelegationEntry(liveStore.map, partID)) liveStore.bump();
+		}));
+	} catch {}
+	return () => {
+		for (const unsub of unsubLive) try {
+			unsub();
+		} catch {}
+	};
+}
 function View(props) {
 	const [showSessions, setShowSessions] = createSignal(false);
 	const [showDelegations, setShowDelegations] = createSignal(true);
@@ -1938,11 +1977,12 @@ function View(props) {
 			cleanup.push(props.api.event.on("session.deleted", eventRefresh));
 			cleanup.push(props.api.event.on("session.status", eventRefresh));
 		} catch {}
-		createEffect(() => {
-			props.liveStore.version();
+		cleanup.push(props.liveStore.subscribe(() => {
 			eventRefreshCount += 1;
 			refreshDelegations();
-		});
+		}));
+		eventRefreshCount += 1;
+		refreshDelegations();
 		const poll = setInterval(() => {
 			setNow(Date.now());
 			refreshDelegations();
@@ -2169,34 +2209,10 @@ const tui = (api, _options, _meta) => {
 	const [version, setVersion] = createSignal(null);
 	detectVersion(api).then((detected) => setVersion(detected)).catch(() => setVersion(null));
 	setupUsageBar(api);
-	const [liveVersion, setLiveVersion] = createSignal(0);
-	const liveStore = {
-		map: /* @__PURE__ */ new Map(),
-		version: liveVersion,
-		bump: () => setLiveVersion((v) => v + 1)
-	};
-	const unsubLive = [];
-	try {
-		unsubLive.push(api.event.on("message.part.updated", (event) => {
-			const props = event?.properties ?? {};
-			const part = props.part ?? props.info?.part;
-			if (part === void 0) return;
-			const sample = extractToolActivity(part);
-			if (sample !== null) trackToolActivity(latestToolActivity, sample.sessionID, sample.activity);
-			if (reduceDelegationToolPart(liveStore.map, part)) liveStore.bump();
-		}));
-	} catch {}
-	try {
-		unsubLive.push(api.event.on("message.part.removed", (event) => {
-			const props = event?.properties ?? {};
-			const partID = props.partID ?? props.part?.id;
-			if (partID !== void 0 && removeDelegationEntry(liveStore.map, partID)) liveStore.bump();
-		}));
-	} catch {}
+	const liveStore = createLiveDelegationStore();
+	const unsubscribeLive = registerLiveDelegationEvents(api, liveStore);
 	api.lifecycle.onDispose(() => {
-		for (const unsub of unsubLive) try {
-			unsub();
-		} catch {}
+		unsubscribeLive();
 		liveStore.map.clear();
 	});
 	api.slots.register({
@@ -2221,6 +2237,6 @@ const plugin = {
 	setup: async () => {}
 };
 //#endregion
-export { DELEGATION_ALIAS_WIDTH, DELEGATION_CHILDREN_RECENCY_MS, DELEGATION_CHILD_STATUS_GRACE_MS, DELEGATION_DESCRIPTION_MAX, DELEGATION_DONE_RETENTION_MS, DELEGATION_ELAPSED_WIDTH, DELEGATION_FAILED_RETENTION_MS, DELEGATION_ROW_GLYPHS, DELEGATION_VISIBLE_CEILING, IDLE_SILENCE_MS, NATIVE_LIVE_ALIASLESS_TTL_MS, STALE_RUNNING_THRESHOLD_MS, buildChildrenPath, ceilingDelegationList, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, countDelegationSources, createDelegationRowOpenHandler, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationRowGlyph, delegationRowIdentity, delegationRowMarker, delegationRowStatus, delegationSpinnerFrame, delegationStateTone, extractToolActivity, filterDelegationsToSession, fmtElapsed, formatDelegationAlias, formatDelegationElapsed, formatDelegationHeader, formatDelegationRowLead, formatPanelLogLine, isValidSessionId, latestToolActivityFor, markStaleIfRunning, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, resolvePantheonRoot, safeSessionPath, seedLiveDelegationMap, splitDelegationList, toDelegationEntry, trackToolActivity, truncateDelegationDescription, tuiLogPath, visibleDelegationList };
+export { DELEGATION_ALIAS_WIDTH, DELEGATION_CHILDREN_RECENCY_MS, DELEGATION_CHILD_STATUS_GRACE_MS, DELEGATION_DESCRIPTION_MAX, DELEGATION_DONE_RETENTION_MS, DELEGATION_ELAPSED_WIDTH, DELEGATION_FAILED_RETENTION_MS, DELEGATION_ROW_GLYPHS, DELEGATION_VISIBLE_CEILING, IDLE_SILENCE_MS, NATIVE_LIVE_ALIASLESS_TTL_MS, STALE_RUNNING_THRESHOLD_MS, buildChildrenPath, ceilingDelegationList, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, countDelegationSources, createDelegationRowOpenHandler, createLiveDelegationStore, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationRowGlyph, delegationRowIdentity, delegationRowMarker, delegationRowStatus, delegationSpinnerFrame, delegationStateTone, extractToolActivity, filterDelegationsToSession, fmtElapsed, formatDelegationAlias, formatDelegationElapsed, formatDelegationHeader, formatDelegationRowLead, formatPanelLogLine, isValidSessionId, latestToolActivityFor, markStaleIfRunning, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, registerLiveDelegationEvents, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, resolvePantheonRoot, safeSessionPath, seedLiveDelegationMap, splitDelegationList, toDelegationEntry, trackToolActivity, truncateDelegationDescription, tuiLogPath, visibleDelegationList };
 
 //# sourceMappingURL=tui.js.map