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

package/src/plugins/pantheon-hooks.ts

@@ -4,13 +4,14 @@
  * Re-created per Council Synthesis 2026-08-05 (P0): the previous hook plugin
  * was removed on 24-25/07 because it used the Bun Shell `$` from the plugin
  * API, whose interface has NO `.timeout()` method — every hook crashed with
- * `TypeError: $.quiet().nothrow().timeout is not a function`. The remaining
+ * `TypeError: $.quiet().nothrow().timeout is not a function`. The 10 functional
  * scripts in scripts/hooks/ (gitleaks covers only staged files, NOT tool
  * calls) were left orphaned. This plugin wires them back into the opencode
  * runtime via `node:child_process` (version-proof — see hook-runner.ts).
  *
- * Hook mapping:
- *   - tool.execute.before → in-process secret scan, validate-talos-scope.sh,
+ * Hook mapping (Claude Code protocol payload {tool_name, tool_input,
+ * agent_id, session_id} delivered on the script stdin):
+ *   - tool.execute.before → validate-talos-scope.sh, scan-secrets.sh,
  *     validate-tool-safety.sh + on-subagent-delegation-start.sh (only when the
  *     tool is a delegation tool such as `task`, to keep the audit log honest)
  *   - tool.execute.after  → format-multi-language.sh, log-session-start.sh +
@@ -22,7 +23,7 @@
  *     ({tool, sessionID, callID}). P0-4 (2026-08-06): a `chat.params` hook
  *     records the active agent per session (sessionAgent map), so payloadFor()
  *     now resolves the real agent_id — validate-talos-scope.sh enforces the
- *     Talos file-count boundary; the agent-agnostic secret scanner and
+ *     Talos file-count boundary; the agent-agnostic scan-secrets and
  *     validate-tool-safety protections remain fully active.
  *   - tool.execute.before CAN hard-deny — the old "cannot hard-deny" claim
  *     below this line is OUTDATED for 1.18.x (verified 2026-08-06 on the
@@ -33,15 +34,15 @@
  *     the tool body runs (the docs' .env-protection example relies on this).
  *     The permission system remains the primary deny path, but a thrown
  *     hook error is now a supported hard block (hybrid blocking, Fix 2
- *     2026-08-06): high-confidence token matches → the plugin logs via
- *     reportFailure (non-TUI channels) and THEN throws
+ *     2026-08-06): scan-secrets.sh exits 2 on high-confidence token matches
+ *     → the plugin logs via reportFailure (non-TUI channels) and THEN throws
  *     the DELIBERATE block error — the ONLY throw in this plugin. Exit 1
  *     (low-confidence header/KEY names) stays advisory: toast + logs, no
  *     block.
  *   - Logging policy (P0 fix 2026-08-06): NON-ZERO exit → NEVER console.
  *     `console.error` in a plugin writes to the process stderr, which the
  *     opencode TUI renders directly into the terminal — that polluted the
- *     chat with noisy nonzero hook output
+ *     chat with `[pantheon-hooks:scan-secrets.sh] exit 1: [SECRET SCAN]...`
  *     spam on every tool call. Non-zero exits now go to THREE non-TUI channels:
  *       1. client.tui.showToast() — one short, deduped TUI toast (per
  *          (script, exit code, masked match) per session) so the user gets a
@@ -59,8 +60,8 @@
  *   - Hooks NEVER throw: every body is try/catch'd and only logs. All three
  *     reporting channels (toast, app.log, file append) are individually
  *     try/catch'd so a failure in one can never take down the session.
- *     EXCEPTION (Fix 2, 2026-08-06): the deliberate high-confidence secret
- *     block — when the in-process scanner finds a token, the hook awaits
+ *     EXCEPTION (Fix 2, 2026-08-06): the deliberate scan-secrets high-
+ *     confidence block — when scan-secrets.sh exits 2, the hook awaits
  *     reportFailure FIRST (app.log + hooks.log) and only then throws. The
  *     throw is deliberately NOT swallowed by the surrounding try/catch
  *     (handled via a blockError variable thrown after it), because that
@@ -176,7 +177,6 @@ import { appendFile, mkdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import type { Plugin, PluginInput } from '@opencode-ai/plugin'
 import { pantheonPluginOnce } from '../pantheon/plugin-once.ts'
-import { scanSecretPayload } from '../pantheon/secret-scanner.ts'
 import { getSharedBoard } from '../pantheon/shared-board.ts'
 import { type HookPayload, type HookResult, runHook } from './hook-runner.ts'
 
@@ -320,7 +320,8 @@ const sessionAgent = new Map<string, { agent: string; at: number }>()
 const RISKY_PATH_RE = /migration|schema\.sql|alembic|models\/|auth|password|token|secret/i
 
 /**
- * Fix 1 (2026-08-06): high-confidence secret token formats. Used by maskSecret()
+ * Fix 1 (2026-08-06): high-confidence secret token formats — mirrors
+ * scripts/hooks/scan-secrets.sh HIGH_CONFIDENCE_PATTERNS. Used by maskSecret()
  * to REDACT secret VALUES from any plugin log line: the talos-guard must
  * never write a raw credential to hooks.log (a real `sk-bf-...` token leaked
  * in plain text there on 2026-08-06). Header/KEY names (the Bifrost header alone,
@@ -340,8 +341,8 @@ function maskSecret(text: string): string {
 }
 
 /**
- * Fix 2 (2026-08-06): message thrown on a high-confidence token match.
- * This is the ONLY deliberate throw in the
+ * Fix 2 (2026-08-06): message thrown when scan-secrets.sh exits 2
+ * (HIGH_CONFIDENCE token match). This is the ONLY deliberate throw in the
  * plugin — it is thrown AFTER reportFailure so the log channels always write
  * first, and it is NOT swallowed by the hook's try/catch: opencode's
  * Plugin.trigger has no catch around hook invocations, so the rejection
@@ -1092,8 +1093,9 @@ function flushIdleReminders(ctx: HookContext): void {
  *               (echo routed to structured log + hooks.log, never the TUI).
  * No console.error / console.log anywhere in this path — the TUI stays clean.
  *
- * Returns the underlying HookResult (or null on unexpected failure) for the
- * non-scanner script hooks.
+ * Returns the underlying HookResult (or null on unexpected failure) so the
+ * tool.execute.before handler can inspect scan-secrets.sh's exit code for the
+ * Fix-2 hybrid block (code 2 = high-confidence token → throw after logging).
  */
 async function safeRun(
   ctx: HookContext,
@@ -1175,26 +1177,15 @@ const plugin: Plugin = async ({ client, directory }) => {
       // catch: opencode propagates the rejection to fail the tool call.
       let blockError: Error | null = null
       try {
-        const hooks = ['validate-talos-scope.sh', 'validate-tool-safety.sh']
+        const hooks = ['validate-talos-scope.sh', 'scan-secrets.sh', 'validate-tool-safety.sh']
         // P0-2: the delegation record must exist BEFORE the payload is built
         // so the start hook receives the delegation_id the stop hook joins on.
-        const args = output?.args ?? (input as { args?: unknown }).args
-        let payload = payloadFor(input, args)
-        // Validate and scan before touching delegation args or launching any
-        // hook subprocess. The shared scanner catches malformed serialization
-        // and returns a fixed fail-closed result.
-        const scan = scanSecretPayload({ ...payload, tool_input: args })
-        if (scan.status === 'invalid') {
-          blockError = new Error(
-            '[pantheon-hooks] Bloqueado: o scanner de segredos não validou a entrada da ferramenta (fail-closed)',
-          )
-        } else if (scan.status === 'block') {
-          blockError = new Error(SECRET_BLOCK_MESSAGE)
-        }
-        if (blockError === null && DELEGATION_TOOL_RE.test(input.tool)) {
+        let payload = payloadFor(input, output?.args ?? {})
+        if (DELEGATION_TOOL_RE.test(input.tool)) {
           hooks.push('on-subagent-delegation-start.sh')
           // tool.execute.before carries args on `output` (typed); `input.args`
           // also exists at runtime — read from whichever is present.
+          const args = output?.args ?? (input as { args?: unknown }).args
           const start: DelegationStart = {
             delegation_id: crypto.randomUUID(),
             agent: delegationAgent(input.tool, args),
@@ -1231,7 +1222,7 @@ const plugin: Plugin = async ({ client, directory }) => {
         const isWriteIntent =
           WRITE_INTENT_TOOLS.has(input.tool) ||
           (input.tool === 'bash' && BASH_WRITE_INTENT_RE.test(bashCommand))
-        if (blockError === null && isWriteIntent) {
+        if (isWriteIntent) {
           try {
             const values: string[] = []
             const scan = (v: unknown): void => {
@@ -1282,63 +1273,25 @@ const plugin: Plugin = async ({ client, directory }) => {
             // Advisory only — a failure here must never take down the hook.
           }
         }
-        // Scan the same serialized hook payload the removed stdin protocol
-        // delivered, but in-process and without logging untrusted input.
-        if (scan.status === 'invalid') {
-          const message =
-            '[pantheon-hooks] Bloqueado: o scanner de segredos não validou a entrada da ferramenta (fail-closed)'
-          await reportFailure(
-            ctx,
-            message,
-            { script: 'secret-scan', tool: input.tool, blocked: true, reason: 'invalid-input' },
-            'error',
-          )
-          blockError = new Error(message)
-        } else if (scan.status === 'block') {
-          for (const finding of scan.findings) {
-            await reportFailure(
-              ctx,
-              `[SECRET SCAN] High-confidence secret detected: ${finding.masked} (pattern: ${finding.pattern})`,
-              { script: 'secret-scan', tool: input.tool, pattern: finding.pattern },
-              'error',
-            )
-          }
+        // Fix 2 hybrid blocking: safeRun returns each script's HookResult;
+        // scan-secrets.sh exits 2 on HIGH_CONFIDENCE token matches
+        // (sk-bf-*, AKIA..., ghp_..., glpat-..., JWT, bearer...) → BLOCK the
+        // tool call. Exit 1 (low-confidence header/KEY names) stays advisory
+        // — safeRun already logged + toasted it, no block. The toast for
+        // code 1/2 fires inside safeRun BEFORE we reach the throw, and the
+        // reportFailure below is awaited first — log channels always write.
+        const results = await Promise.all(
+          hooks.map(async (script) => ({ script, result: await safeRun(ctx, script, payload) })),
+        )
+        const scan = results.find((r) => r.script === 'scan-secrets.sh')
+        if (scan?.result?.code === 2) {
           await reportFailure(
             ctx,
             SECRET_BLOCK_MESSAGE,
-            { script: 'secret-scan', tool: input.tool, blocked: true },
+            { script: 'scan-secrets', tool: input.tool, blocked: true, code: 2 },
             'error',
           )
-          void notifyToast(ctx, {
-            title: 'Pantheon Hook',
-            message: '⚠️ High-confidence secret detected — tool call blocked',
-            variant: 'error',
-            duration: 4000,
-            category: 'errors',
-            dedupeKey: `secret-scan|block|${input.sessionID}`,
-          })
           blockError = new Error(SECRET_BLOCK_MESSAGE)
-        } else if (scan.status === 'advisory') {
-          for (const finding of scan.findings) {
-            await reportFailure(
-              ctx,
-              `[SECRET SCAN] Potential secret detected (low confidence): ${finding.masked} (pattern: ${finding.pattern})`,
-              { script: 'secret-scan', tool: input.tool, pattern: finding.pattern },
-              'warn',
-            )
-          }
-          void notifyToast(ctx, {
-            title: 'Pantheon Hook',
-            message: '⚠️ Possible secret detected — see log',
-            variant: 'warning',
-            duration: 4000,
-            category: 'errors',
-            dedupeKey: `secret-scan|advisory|${input.sessionID}`,
-          })
-        }
-
-        if (blockError === null) {
-          await Promise.all(hooks.map(async (script) => safeRun(ctx, script, payload)))
         }
       } catch {
         // Never let a hook take down the opencode session — except the

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":";;YAi7BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EAUA;;EAEA;EACA;EACA;;;;;;EAUA;;;;;;;;;;;wBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;wBAkHmB,sBAAsB,cAAc,QAAQ;;;;;;;;;wBAyC5C,yBAAyB,eAAe,QAAQ;;;;;;;wBAUtD,oBACd;EAAS;EAAoB;eAC7B;;;;wBAUc,sBACd;EAAS;EAAoB;eAC7B;;;;;;wBAUc,YAAY;;;wBAMZ,WAAW;;;;wBAOX,yBAAyB,GAAG,iBAAiB,GAAG;;;;;wBAahD,oBACd,cAAc,mBACd,oBACA,cACA;EACG,QAAQ;EAAmB,QAAQ;;;;;wBAmCxB,sBACd,cAAc,mBACd,sBACA,cACA,4BACC;;qBAMU;;;;qBAKA;;;qBAIA;qBACA;;;;;;;;;;qBAWA;;;;;;;;qBASA;;;;;qBAMA;;;;;;;;;wBAUG,mBACd,OAAO,iBACP,aACA,uBACC;;;wBAWa,WAAW;;;;wBAeX,kBAAkB,OAAO,iBAAiB;;;YAQ9C;wBAEI,mBAAmB,OAAO,kBAAkB;wBAa5C,wBAAwB,OAAO;;;;wBAqB/B,uBAAuB;;;;;;;YAW3B,yBAAyB;;;;;YAMzB;;;;wBAKI,oBAAoB,OAAO,yBAAyB;YAuBxD;EACV;EACA;EACA;;;;;wBAsBc,oBACd;EACE;EACA;EACA;EACA;IAAU;IAAiB,QAAQ;;GAErC;EACG;EAAmB,UAAU;;;wBAYlB,kBACd,KAAK,YAAY,eACjB,mBACA,UAAU;;wBAWI,sBACd,KAAK,YAAY,eACjB,+BACA,cACA,iBACC;;;;;;;wBAca,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;YAiGS;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA,QAAQ;IACR;IACA;IACA;MAAS;MAAgB;;;;;YAKjB;;EAEV;;EAEA;;EAEA;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;;YAIU;EACV;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;wBAYc,wBACd,MAAM,oBACN,eACC;;;wBAsDa,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;wBAwEc,sBACd,KAAK,YAAY,sBACjB;;;;;;;;;wBAoBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;wBAwBa,sBACd,KAAK,YAAY,sBACjB,gBAAgB,sBAChB;;;wBAWc,kBAAkB,MAAM,sBAAsB;;;;;;wBAoB9C,uBACd,eAAe,uBACf,aAAa,oBACZ;;;;;;;;;;;;;;;;;wBA0Ca,2BACd,kBAAkB,mBAClB,6CACC;;;;;;;;;wBAyCa,iBAAiB,cAAc;;;;YAOnC;;EAEV;EACA;;IAEE;MAAU;;;IAEV;MAAU;QAAY;QAAe,SAAS;;;;;;;;;;wBASlC,wBAAwB,SAAS;;;;;;;;;;;;wBAuBjC,gBAAgB;EAAgB;;;;;;;wBAUhC,kBAAkB;EAAkC;;;YAKxD;;EAEV;;EAEA;;;EAGA;;;EAGA;EACA;IACE;IACA;;;;;;;;;;;;;;;;;;;;wBAqBY,mBACd,4BACA;EAAS;EAAkB;GAC3B,cACA;;;;;;;YA6BU;;;;;wBAMI,oBAAoB,OAAO,yBAAyB;;;qBAmBvD,uBAAuB,SAAS,OAAO;wBAOpC,mBAAmB,QAAQ;;;;wBAO3B,oBAAoB,OAAO,wBAAwB;;;;;wBAUnD,sBAAsB,OAAO;;;qBAShC;wBAEG,sBAAsB,kBAAkB;;;qBAO3C;;;;wBAoBG,8BACd,cACA;;;;qBAUW;wBAEG,wBACd,OAAO,iBACP,aACA;;;;wBAUc,wBAAwB,OAAO,iBAAiB;;;;qBAYnD;;;;;wBAMG,uBAAuB,kBAAkB;;;;wBAyBzC,sBACd,cAAc,mBACd,qBACA;EACG,SAAS;EAAmB;EAAgB;EAAsB;;;;;wBAevD,uBAAuB,kBAAkB;EACvD;EACA;EACA;;;;;wBAUc,mBACd,kBACA,kBACA,gBACA,YACA;wBA8Cc,4BACd,mBAAmB,mCACnB,aAAa,mBACb,cACA,2BACC;;;;;;wBA4Da,4BACd;EAEM,YAAY,cAAc,SAAS,mCAAmC;eAG5E;;wBAmBc,+BACd;EAEM,YAAY,cAAc,SAAS,mCAAmC;eAG5E;;;;YAuLU;EACV,KAAK,YAAY;;EAEjB,YAAY;;EAEZ;;;wBAIc,6BAA6B;;wBAe7B,6BACd,KAAK,cACL,WAAW;cAggBP,QAAQ;EAAoB;EAAY,aAAa"}

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

@@ -167,7 +167,7 @@ async function detectVersion(api) {
 			if (ver) return ver;
 		}
 	} catch {}
-	return "1.6.0-beta.7";
+	return "1.6.0-beta.8";
 }
 /**
 * usage-bar — AI subscription usage gauge for the opencode TUI.
@@ -509,22 +509,12 @@ async function loadConfig(configPath) {
 		return defaultConfig();
 	}
 }
-/** Vendored usage-bar plugin init: reads config, seeds the kv cache, registers
-*  the `app_bottom` slot, then starts the poll loop. Skips everything (and
+/** Vendored usage-bar plugin init: reads config, seeds the kv cache, starts
+*  the poll loop and registers the `app_bottom` slot. Skips everything (and
 *  registers nothing) when no provider is enabled — mirrors the standalone
 *  plugin's early return. */
 async function setupUsageBar(api) {
-	let disposed = false;
-	let clockInterval;
-	const pollTimeouts = /* @__PURE__ */ new Set();
-	api.lifecycle.onDispose(() => {
-		disposed = true;
-		if (clockInterval !== void 0) clearInterval(clockInterval);
-		for (const timeout of pollTimeouts) clearTimeout(timeout);
-		pollTimeouts.clear();
-	});
 	const config = await loadConfig(api.state.path?.config);
-	if (disposed) return;
 	if (api.state.path?.state) opencodeAuthFile = join(api.state.path.state, "auth.json");
 	const enabled = providers.filter((p) => config.providers[p.id].enabled);
 	if (enabled.length === 0) return;
@@ -536,6 +526,28 @@ async function setupUsageBar(api) {
 	const [byProvider, setByProvider] = createSignal(seed);
 	const [byStatus, setByStatus] = createSignal({});
 	const [now, setNow] = createSignal(Date.now());
+	setInterval(() => setNow(Date.now()), 1e3);
+	for (const p of enabled) {
+		const cfg = config.providers[p.id];
+		const poll = async () => {
+			const statusP = config.showStatus && p.statusUrl ? fetchStatus(p.statusUrl) : null;
+			const [all, status] = await Promise.all([p.fetchUsage(cfg), statusP]);
+			if (all) {
+				const windows = all.filter((w) => cfg.show[w.category] && w.resetsAt > Date.now());
+				setByProvider((prev) => ({
+					...prev,
+					[p.id]: windows
+				}));
+				api.kv.set(`usage-bar.${p.id}.windows`, windows);
+			}
+			if (status !== null) setByStatus((prev) => ({
+				...prev,
+				[p.id]: status
+			}));
+			setTimeout(poll, all ? POLL_MS : POLL_MS * 3);
+		};
+		poll();
+	}
 	api.slots.register({
 		order: 60,
 		slots: { app_bottom() {
@@ -684,42 +696,6 @@ async function setupUsageBar(api) {
 			});
 		} }
 	});
-	clockInterval = setInterval(() => setNow(Date.now()), 1e3);
-	const schedulePoll = (run, delay) => {
-		if (disposed) return;
-		const timeout = setTimeout(() => {
-			pollTimeouts.delete(timeout);
-			if (!disposed) run();
-		}, delay);
-		pollTimeouts.add(timeout);
-	};
-	for (const p of enabled) {
-		const cfg = config.providers[p.id];
-		const poll = async () => {
-			if (disposed) return;
-			const statusP = config.showStatus && p.statusUrl ? fetchStatus(p.statusUrl) : null;
-			const [all, status] = await Promise.all([p.fetchUsage(cfg), statusP]);
-			if (disposed) return;
-			if (all) {
-				const windows = all.filter((w) => cfg.show[w.category] && w.resetsAt > Date.now());
-				setByProvider((prev) => ({
-					...prev,
-					[p.id]: windows
-				}));
-				api.kv.set(`usage-bar.${p.id}.windows`, windows);
-			}
-			if (status !== null) setByStatus((prev) => ({
-				...prev,
-				[p.id]: status
-			}));
-			schedulePoll(runPoll, all ? POLL_MS : POLL_MS * 3);
-		};
-		const runPoll = () => {
-			if (disposed) return;
-			poll().catch(() => schedulePoll(runPoll, POLL_MS * 3));
-		};
-		runPoll();
-	}
 }
 /** True for `\s` characters (space, tab, newline, CR) — plain char checks so
 *  the parser stays regex-free (CodeQL flagged the old `\s*`/`\s+` + `(.+)`
@@ -2232,7 +2208,7 @@ const tui = (api, _options, _meta) => {
 	if (pantheonPluginOnce("pantheon:tui")) return;
 	const [version, setVersion] = createSignal(null);
 	detectVersion(api).then((detected) => setVersion(detected)).catch(() => setVersion(null));
-	setupUsageBar(api).catch(() => void 0);
+	setupUsageBar(api);
 	const liveStore = createLiveDelegationStore();
 	const unsubscribeLive = registerLiveDelegationEvents(api, liveStore);
 	api.lifecycle.onDispose(() => {

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

@@ -1,12 +1,12 @@
 {
   "name": "pantheon-tui",
-  "version": "1.6.0-beta.7",
+  "version": "1.6.0-beta.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pantheon-tui",
-      "version": "1.6.0-beta.7",
+      "version": "1.6.0-beta.8",
       "license": "MIT",
       "dependencies": {
         "@opencode-ai/plugin": "1.18.33",

package/src/plugins/tui/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pantheon-tui",
   "type": "module",
-  "version": "1.6.0-beta.7",
+  "version": "1.6.0-beta.8",
   "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": {

package/src/plugins/tui/src/index.tsx

@@ -740,27 +740,12 @@ async function loadConfig(configPath: string | undefined): Promise<UsageBarConfi
   }
 }
 
-/** Vendored usage-bar plugin init: reads config, seeds the kv cache, registers
- *  the `app_bottom` slot, then starts the poll loop. Skips everything (and
+/** Vendored usage-bar plugin init: reads config, seeds the kv cache, starts
+ *  the poll loop and registers the `app_bottom` slot. Skips everything (and
  *  registers nothing) when no provider is enabled — mirrors the standalone
  *  plugin's early return. */
 async function setupUsageBar(api: TuiPluginApi) {
-  let disposed = false
-  let clockInterval: ReturnType<typeof setInterval> | undefined
-  const pollTimeouts = new Set<ReturnType<typeof setTimeout>>()
-
-  // This optional feature owns timers independently from the sidebar. A slow
-  // config read may finish after shutdown, so register cleanup before awaiting
-  // anything and check the disposed flag at every async boundary.
-  api.lifecycle.onDispose(() => {
-    disposed = true
-    if (clockInterval !== undefined) clearInterval(clockInterval)
-    for (const timeout of pollTimeouts) clearTimeout(timeout)
-    pollTimeouts.clear()
-  })
-
   const config = await loadConfig(api.state.path?.config)
-  if (disposed) return
   if (api.state.path?.state) opencodeAuthFile = join(api.state.path.state, 'auth.json')
 
   const enabled = providers.filter((p) => config.providers[p.id].enabled)
@@ -777,6 +762,28 @@ async function setupUsageBar(api: TuiPluginApi) {
   const [byStatus, setByStatus] = createSignal<Record<string, StatusIndicator>>({})
   const [now, setNow] = createSignal(Date.now())
 
+  setInterval(() => setNow(Date.now()), 1_000)
+
+  for (const p of enabled) {
+    const cfg = config.providers[p.id]
+    const poll = async () => {
+      // Fetch usage and status concurrently; status pages are CDN-backed and
+      // never throttle, so we poll them on the same cadence as usage.
+      const statusP = config.showStatus && p.statusUrl ? fetchStatus(p.statusUrl) : null
+      const [all, status] = await Promise.all([p.fetchUsage(cfg), statusP])
+      if (all) {
+        const windows = all.filter((w) => cfg.show[w.category] && w.resetsAt > Date.now())
+        setByProvider((prev) => ({ ...prev, [p.id]: windows }))
+        api.kv.set(`usage-bar.${p.id}.windows`, windows)
+      }
+      // `null` means the status fetch failed — keep the last known indicator.
+      if (status !== null) setByStatus((prev) => ({ ...prev, [p.id]: status }))
+      // Back off when the usage fetch failed (e.g. 429 — these endpoints throttle).
+      setTimeout(poll, all ? POLL_MS : POLL_MS * 3)
+    }
+    void poll()
+  }
+
   api.slots.register({
     order: 60,
     slots: {
@@ -864,46 +871,6 @@ async function setupUsageBar(api: TuiPluginApi) {
       },
     },
   })
-
-  // Start background work only once the optional UI slot was accepted. If
-  // registration fails, the outer fail-open handler can suppress it without
-  // leaving a timer or provider request running in the background.
-  clockInterval = setInterval(() => setNow(Date.now()), 1_000)
-
-  const schedulePoll = (run: () => void, delay: number) => {
-    if (disposed) return
-    const timeout = setTimeout(() => {
-      pollTimeouts.delete(timeout)
-      if (!disposed) run()
-    }, delay)
-    pollTimeouts.add(timeout)
-  }
-
-  for (const p of enabled) {
-    const cfg = config.providers[p.id]
-    const poll = async () => {
-      if (disposed) return
-      // Fetch usage and status concurrently; status pages are CDN-backed and
-      // never throttle, so we poll them on the same cadence as usage.
-      const statusP = config.showStatus && p.statusUrl ? fetchStatus(p.statusUrl) : null
-      const [all, status] = await Promise.all([p.fetchUsage(cfg), statusP])
-      if (disposed) return
-      if (all) {
-        const windows = all.filter((w) => cfg.show[w.category] && w.resetsAt > Date.now())
-        setByProvider((prev) => ({ ...prev, [p.id]: windows }))
-        api.kv.set(`usage-bar.${p.id}.windows`, windows)
-      }
-      // `null` means the status fetch failed — keep the last known indicator.
-      if (status !== null) setByStatus((prev) => ({ ...prev, [p.id]: status }))
-      // Back off when the usage fetch failed (e.g. 429 — these endpoints throttle).
-      schedulePoll(runPoll, all ? POLL_MS : POLL_MS * 3)
-    }
-    const runPoll = () => {
-      if (disposed) return
-      void poll().catch(() => schedulePoll(runPoll, POLL_MS * 3))
-    }
-    runPoll()
-  }
 }
 
 /* ─── Delegations (real-time panel) ────────────────────────
@@ -3167,9 +3134,7 @@ const tui: TuiPlugin = (api, _options, _meta) => {
     .catch(() => setVersion(null))
 
   // Vendored feature (MIT): AI subscription usage gauges.
-  // Usage indicators are optional: a config, storage, or slot failure must
-  // never turn an otherwise healthy TUI startup into an unhandled rejection.
-  void setupUsageBar(api).catch(() => undefined)
+  void setupUsageBar(api) // async init — never blocks sidebar registration
 
   // ── Live delegation store (tool-part tracker + sidebar invalidation) ──
   // The Delegations panel's PRIMARY source is `api.client.session.children`

package/src/routing.yml

@@ -133,7 +133,7 @@ agents:
     - artifact-management
     - context-compression
     - auto-continue
-    - council-synthesis
+    - incremental-implementation
   athena:
     role: Strategic planner
     reasoning_effort: high
@@ -188,6 +188,8 @@ agents:
     - pantheon_code_mode
     skills:
     - tdd-with-agents
+    - file-prompts
+    - streaming-patterns
     - git-workflow-and-versioning
     - incremental-implementation
   aphrodite:
@@ -209,7 +211,7 @@ agents:
     skills:
     - tdd-with-agents
     - visual-review-pipeline
-    - incremental-implementation
+    - file-prompts
   demeter:
     role: Database specialist
     reasoning_effort: medium

package/src/skills/README.md

@@ -4,14 +4,14 @@
 
 Skills are reference modules loaded on demand by agents. Each skill provides domain-specific knowledge — architecture patterns, security checklists, optimization strategies, and implementation guides. Agents load skills when their task matches the skill's description, keeping context focused and token-efficient.
 
-There are **21 skills** divided into **5 domains**.
+There are **20 skills** divided into **5 domains**.
 
 ## Skills by Domain
 
 ### Domain 1: Orchestration & Workflow
 
 1. **agent-coordination** — `agent-coordination/SKILL.md`
-   - Lightweight coordination for substantial tasks with multiple independent specialists.
+   - Multi-agent orchestration with model routing, category delegation, and sprint management.
    - Used by: Zeus
 
 2. **artifact-management** — `artifact-management/SKILL.md`
@@ -23,8 +23,8 @@ There are **21 skills** divided into **5 domains**.
    - Used by: Zeus, Apollo, Hephaestus, Nyx, Gaia
 
 4. **context-compression** — `context-compression/SKILL.md`
-   - Level 2 — Pantheon-native context compression with priority scoring, semantic summarization, budget allocation, and cross-references.
-   - Used by: Zeus, Mnemosyne, Themis
+   - Native compaction guidance and explicit checkpoint rules; no automatic compression MCP calls.
+   - Used by: Zeus, Mnemosyne
 
 5. **memory-bank** — `memory-bank/SKILL.md`
    - Memory bank rules, structure, and optimization — complete guide to Pantheon memory management.
@@ -34,10 +34,6 @@ There are **21 skills** divided into **5 domains**.
    - Pin session objectives to prevent scope creep across long multi-agent sessions.
    - Used by: Zeus, Mnemosyne
 
-- **council-synthesis** — `council-synthesis/SKILL.md`
-  - Full structured council workflow, loaded only for `/pantheon` or a material multi-perspective decision.
-  - Used by: Zeus
-
 ### Domain 2: Development Tools
 
 7. **clonedeps** — `clonedeps/SKILL.md`
@@ -50,7 +46,7 @@ There are **21 skills** divided into **5 domains**.
 
 9. **incremental-implementation** — `incremental-implementation/SKILL.md`
     - Implement in thin vertical slices — one commit per task, testable, rollback-safe.
-    - Used by: Hermes, Aphrodite, Demeter, Prometheus, Talos
+    - Used by: Zeus, Hermes, Aphrodite, Demeter, Prometheus, Talos
 
 10. **loop-engineering** — `loop-engineering/SKILL.md`
     - Iterative refinement pattern for complex problems — solve, review, improve, repeat in controlled cycles.
@@ -128,12 +124,12 @@ The `SKILL.md` file contains YAML frontmatter with `name`, `description`, and pl
 | 1 | agent-coordination | Orchestration & Workflow | Zeus |
 | 2 | artifact-management | Orchestration & Workflow | Zeus, Mnemosyne, Iris |
 | 3 | auto-continue | Orchestration & Workflow | Zeus, Apollo, Hephaestus, Nyx, Gaia |
-| 4 | context-compression | Orchestration & Workflow | Zeus, Mnemosyne, Themis |
+| 4 | context-compression | Orchestration & Workflow | Zeus, Mnemosyne |
 | 5 | memory-bank | Orchestration & Workflow | Mnemosyne, Athena |
 | 6 | session-goal | Orchestration & Workflow | Zeus, Mnemosyne |
 | 7 | clonedeps | Development Tools | Hermes, Hephaestus |
 | 8 | git-workflow-and-versioning | Development Tools | Hermes, Prometheus, Iris |
-| 9 | incremental-implementation | Development Tools | Hermes, Aphrodite, Demeter, Prometheus, Talos |
+| 9 | incremental-implementation | Development Tools | Zeus, Hermes, Aphrodite, Demeter, Prometheus, Talos |
 | 10 | loop-engineering | Development Tools | All agents |
 | 11 | reflect | Development Tools | All agents |
 | 12 | simplify | Development Tools | All agents |
@@ -145,7 +141,6 @@ The `SKILL.md` file contains YAML frontmatter with `name`, `description`, and pl
 | 18 | spec-driven-development | Planning | Athena |
 | 19 | verification-planning | Planning | Athena, Zeus |
 | 20 | visual-review-pipeline | Frontend Development | Aphrodite |
-| 21 | council-synthesis | Orchestration & Workflow | Zeus |
 
 ---