pantheon-opencode 1.0.6 → 1.1.0

package/bin/pantheon-init.mjs

@@ -64,7 +64,7 @@ async function main() {
       const target = isProject ? process.cwd() : undefined;
       installOpenCode(target, isDryRun, forceReinstall, components);
     } catch (err) {
-      console.error(`❌ Installation failed:\n${err.stack}`);
+      console.error(`❌ Installation failed: ${err.message}\n   Run with --no-mcp to skip Python dependencies:\n     npx pantheon-opencode init --no-mcp\n   Or retry with --force to recreate the venv:\n     npx pantheon-opencode init --force`);
       process.exit(1);
     }
 

package/opencode.json

@@ -4,9 +4,8 @@
   "subagent_depth": 2,
   "agent": {},
   "permission": {
-    "skill": {
-      "*": "allow"
-    },
+    "skill": { "*": "allow" },
+    "websearch": "deny",
     "bash": {
       "git *": "allow",
       "npm *": "allow",
@@ -21,5 +20,14 @@
     "src/instructions/*.instructions.md"
   ],
   "plugin": [],
-  "mcp": {}
-}
+  "mcp": {
+    "bifrost": {
+      "type": "remote",
+      "url": "https://llm.ofertachina.cloud/mcp",
+      "enabled": true,
+      "headers": {
+        "x-bf-vk": "sk-bf-a5a9b5b0-45fc-414d-8e4d-f9beb8c49a6d"
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",

package/scripts/install/opencode.mjs

@@ -3,7 +3,7 @@
  * opencode.mjs — OpenCode platform installer
  */
 
-import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs'
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
 import { healthCheck } from './health-check.mjs'
@@ -687,7 +687,7 @@ export function installOpenCode(
   // -----------------------------------------------------------------------
   if (componentSet.has('runtime')) {
     try {
-      setupVenv(target, { dryRun })
+      setupVenv(target, { dryRun, force: clean })
       const health = healthCheck(target, { dryRun })
 
       // Print health summary
@@ -702,7 +702,7 @@ export function installOpenCode(
       }
     } catch (err) {
       console.error(`  ❌ Setup failed: ${err.message}`)
-      stats.errors++
+      throw err  // Fatal — abort installation
     }
   }
 }

package/scripts/install/venv.mjs

@@ -10,7 +10,7 @@
  */
 
 import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { existsSync, rmSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
@@ -21,14 +21,23 @@ const ROOT = join(__dirname, '..', '..')
  * Set up a Python virtual environment and install MCP dependencies.
  *
  * @param {string} target - Target installation directory (e.g. ~/.config/opencode)
- * @param {{ dryRun?: boolean, skipInstall?: boolean }} [options]
+ * @param {{ dryRun?: boolean, skipInstall?: boolean, force?: boolean }} [options]
  * @returns {{ venvPath: string, python: string }}
  */
-export function setupVenv(target, { dryRun = false, skipInstall = false } = {}) {
+export function setupVenv(target, { dryRun = false, skipInstall = false, force = false } = {}) {
   const venvPath = join(target, '.venv')
   const pythonBin = join(venvPath, 'bin', 'python3')
 
-  // Step 1: Create venv if not exists
+  // Step 1: Force recreate venv if --force
+  if (force && existsSync(venvPath)) {
+    if (!dryRun) {
+      console.log('  Removing existing .venv (--force)...')
+      rmSync(venvPath, { recursive: true })
+    }
+    console.log('  ✅ .venv removed')
+  }
+
+  // Step 1b: Create venv if not exists
   if (!existsSync(pythonBin)) {
     if (!dryRun) {
       console.log('  Creating .venv...')
@@ -58,28 +67,34 @@ export function setupVenv(target, { dryRun = false, skipInstall = false } = {})
 
     if (!dryRun) {
       // Upgrade pip first (avoids resolver warnings)
+      // Ensure PIP_USER=0 to install into venv, not user site-packages
+      const pipEnv = { ...process.env, PIP_USER: '0' }
+
       spawnSync(pip, ['install', '--upgrade', 'pip'], {
         stdio: 'ignore',
         timeout: 30_000,
+        env: pipEnv,
       })
 
-      // Install requirements
+      // Install requirements — attempt 1: normal
       const r = spawnSync(pip, ['install', '-r', reqFile], {
         stdio: 'inherit',
         timeout: 120_000,
+        env: pipEnv,
       })
 
       if (r.status !== 0) {
-        // If failed, try with --break-system-packages (PEP 668 workaround)
+        // Attempt 2: --break-system-packages (PEP 668 / externally-managed)
         console.log('  ⚠️  First attempt failed, retrying with --break-system-packages...')
         const r2 = spawnSync(pip, ['install', '-r', reqFile, '--break-system-packages'], {
           stdio: 'inherit',
           timeout: 120_000,
+          env: pipEnv,
         })
         if (r2.status !== 0) {
           throw new Error(
             'Failed to install MCP dependencies. ' +
-            'Try: pip install -r src/mcp/requirements-mcp.txt --break-system-packages'
+            'Try: PIP_USER=0 ' + pip + ' install -r ' + reqFile + ' --break-system-packages'
           )
         }
       }
@@ -101,9 +116,10 @@ function main() {
   const target = targetIdx !== -1 ? args[targetIdx + 1] : process.cwd()
   const dryRun = args.includes('--dry-run')
   const skipInstall = args.includes('--skip-install')
+  const force = args.includes('--force')
 
   try {
-    const result = setupVenv(target, { dryRun, skipInstall })
+    const result = setupVenv(target, { dryRun, skipInstall, force })
     console.log(`  📍 Python: ${result.python}`)
   } catch (err) {
     console.error(`\n  ❌ ${err.message}`)

package/src/instructions/agent-return-format.instructions.md

@@ -21,6 +21,51 @@ For investigation agents (Apollo, Athena), return structured findings with:
 - File paths with line numbers
 - Relevant code snippets (max 3 lines each)
 
+## Council Specialist Response Format
+
+When responding to a `/pantheon` council synthesis invocation, specialists MUST return this structured format:
+
+```
+## specialist_response
+**position:** <clear one-sentence position answering the question>
+**reasoning:** <2-4 sentences with logical chain>
+**trade_offs:** <what's gained vs lost, specific>
+**risks:** <what could go wrong, max 3 items>
+**confidence:** High | Medium | Low
+**agreement_signals:** agree:@agent1 on <issue>, agree:@agent2 on <issue> | disagree:@agent3 on <issue>
+**specific_claims:** <count of specific factual claims in response>
+```
+
+### Field Rules
+
+| Field | Required | Validation |
+|-------|----------|------------|
+| position | ✅ | Single sentence, must directly answer the question |
+| reasoning | ✅ | 2-4 sentences with logical chain |
+| trade_offs | ✅ | At least one gain and one loss, specific to context |
+| risks | ✅ | Max 3 bullet points |
+| confidence | ✅ | One of: High, Medium, Low |
+| agreement_signals | Optional | Format: `agree:@agent on issue \| disagree:@agent on issue`. Use only when you can reference other specialists expected positions. |
+| specific_claims | ✅ | Integer count of verifiable factual statements in the response |
+
+### Confidence Guidelines
+
+- **High**: Position backed by 3+ specific claims with evidence or direct experience
+- **Medium**: Position backed by 1-2 specific claims
+- **Low**: Position is opinion-based or speculative
+
+### Example
+```
+## specialist_response
+**position:** The BackgroundJobBoard should be used for council crash recovery
+**reasoning:** The board already supports running→completed→reconciled state machine with persistence. Registering council dispatches there adds ~50ms overhead but prevents total session loss on context crash. The WAL pattern ensures no data loss on restart.
+**trade_offs:** Gain: crash recovery for multi-minute council sessions. Lose: ~50ms registration overhead per council.
+**risks:** Board persistence failure could block council start — implement with fire-and-forget error handling
+**confidence:** High
+**agreement_signals:** agree:@themis on persist-before-notify
+**specific_claims:** 3
+```
+
 ## Memory Context
 If this agent used `memory_recall` or `memory_search`, include the relevant memory entries
 used as context for the response.

package/src/instructions/memory-protocol.instructions.md

@@ -65,3 +65,55 @@ Para otimizar decisoes de delegacao e reduzir gasto de tokens:
 5. **kv_get("deleg:<pattern>")** para reusar decisoes ja tomadas
 
 Isso elimina ~300 tokens de reasoning por delegacao quando o cache acerta.
+
+## Council Decisions Namespace
+
+Council synthesis decisions are persisted in a dedicated `council_decisions` namespace for precedent fast-path retrieval:
+
+### Write Path
+After every `/pantheon` council synthesis completes, Zeus stores:
+```
+memory_store({
+  namespace: "council_decisions",
+  key: "council:<yyyy-mm-dd>:<slug>",
+  value: {
+    question: "original question",
+    specialists: ["@agent1", "@agent2"],
+    recommendation: "final recommendation",
+    confidence: "High|Medium|Low",
+    agreements: ["point1", "point2"],
+    divergences: [{"issue": "...", "resolution": "..."}],
+    response_rate: "X of Y",
+    themis_audit: "approved|issues"
+  },
+  metadata: {
+    type: "council_decision",
+    specialist_count: N,
+    model_tier_used: "premium|default|fast"
+  }
+})
+```
+
+### Read Path (Precedent Fast-Path)
+Before dispatching a new council, Zeus runs:
+```
+memory_search(question, top_k=2, namespace="council_decisions")
+```
+
+Result interpretation:
+| Score | Age | Action |
+|-------|-----|--------|
+| > 0.85 | < 30 days | Return precedent as fast-path answer. Skip council dispatch entirely. |
+| > 0.85 | >= 30 days | Return with warning "Reavaliar se contexto mudou" + proceed with council |
+| 0.5 - 0.85 | Any | Include as context for specialists but still dispatch council |
+| < 0.5 | Any | Ignore, proceed with fresh council |
+
+### TTL & Maintenance
+- Council decisions are LONG-TERM (no TTL or TTL = 365 days)
+- Stale decisions (age > 90 days) should be flagged but NOT deleted — they remain as historical record
+- Purge only via explicit namespace cleanup when decisions are superseded by ADRs
+
+### When NOT to Use
+- Routine task summaries → use `default` namespace (auto-store by Zeus)
+- Sprint/progress tracking → use `session` namespace
+- ADR-level architecture decisions → delegate to @mnemosyne for permanent documentation

package/src/instructions/zeus-council-synthesis.instructions.md

@@ -1,5 +1,5 @@
 ---
-description: "Council synthesis — dispatch 2-4 specialists inline for multi-perspective decisions"
+description: "Council synthesis — dispatch 2-4 specialists inline for multi-perspective decisions with precedent fast-path, confidence cross-validation, rebuttal rounds, and Themis audit gate"
 name: "Zeus Council Synthesis"
 applyTo: "agents/zeus.agent.md"
 ---
@@ -26,39 +26,197 @@ config:
 sequenceDiagram
     participant U as User
     participant Z as Zeus
+    participant M as Memory (Precedent)
+    participant A as Apollo (Research)
+    participant B as BackgroundJobBoard
     participant S1 as Specialist 1
     participant S2 as Specialist 2
     participant S3 as Specialist 3
+    participant W as Web Search
+    participant T as Themis (Audit + Moderator)
 
-    U->>Z: /pantheon question
-    Note over Z: Detect multi-perspective trigger
-    Z->>Z: Select 2-4 specialists
-    par Dispatch all specialists
-        Z->>S1: Domain-specific query
-        Z->>S2: Domain-specific query
-        Z->>S3: Domain-specific query
+    U->>Z: /pantheon [--research] question
+    Z->>M: memory_search(council_decisions)
+    alt Precedent found (score > 0.85)
+        M-->>Z: ⚠️ Cached decision
+        Z->>U: Fast-path precedent
+    else No precedent
+        opt --research flag
+            Z->>A: 30s pre-scan
+            A-->>Z: Context brief
+        end
+        Z->>B: registerLaunch({council session})
+        par Dispatch all specialists
+            Z->>S1: Domain query + shared context
+            Z->>S2: Domain query + shared context
+            Z->>S3: Domain query + shared context
+        end
+        par Collect responses
+            S1-->>Z: Structured response
+            S2-->>Z: Structured response
+            S3-->>Z: Structured response
+        end
+        Note over Z: Cross-validate confidence
+        alt Agreement rate < 50%
+            Z->>S1: Rebuttal round
+            Z->>S2: Rebuttal round
+            Z->>S3: Rebuttal round
+            S1-->>Z: Refined response
+            S2-->>Z: Refined response
+            S3-->>Z: Refined response
+            Note over Z: Ainda divergência?
+            alt Agreement rate STILL < 50%
+                Z->>W: browser_search() for each divergence point
+                W-->>Z: Evidence brief with sources
+                Z->>T: Dispatches as moderator
+                Note over T: Reviews evidence + specialist responses
+                T-->>Z: Moderator verdict
+            end
+        end
+        Z->>Z: Synthesize (with evidence if tie-broken)
+        Z->>T: Audit synthesis fidelity
+        T-->>Z: ✅ / ⚠️ Issues
+        Z->>M: Store decision
+        Z->>B: Mark reconciled
+        Z->>U: 🏛️ Council Synthesis
     end
-    par Collect responses
-        S1-->>Z: Position + trade-offs
-        S2-->>Z: Position + trade-offs
-        S3-->>Z: Position + trade-offs
-    end
-    Note over Z: Synthesize agreements + divergences + recommendation
-    Z->>U: 🏛️ Council Synthesis
 ```
 
-## Dispatch with Timeout
+## Dispatch Sequence (9-Step Protocol)
+
+### Step 0 — Precedent Fast-Path (Fase 1)
+Before any dispatch: `memory_search(query, top_k=2, namespace="council_decisions")`
+- Score > 0.85 AND age < 30 days → return precedent verbatim with note "⚠️ Decisão de [data] — reavaliar se contexto mudou". SKIP entire dispatch.
+- Score > 0.85 AND age > 30 days → return precedent with ⚠️ "Reavaliar se contexto mudou — decisão tem mais de 30 dias"
+- Else → proceed to Step 0b
+
+### Step 0b — Apollo Pre-Scan (Fase 2, --research flag)
+If `/pantheon --research <question>`: dispatch @apollo with 30s timeout. Inject findings as `shared_context` into ALL specialist prompts. Skip if flag absent.
+
+### Step 1 — Register on BackgroundJobBoard (Fase 1)
+Before dispatching specialists:
+```
+board.registerLaunch({
+  taskID: "council:<uuid>",
+  parentSessionID: "<session-id>",
+  agent: "zeus",
+  description: "Council: <question>",
+  objective: "Synthesize specialist recommendations"
+})
+```
+Enables crash recovery — if context is lost mid-synthesis, the board preserves session state.
+
+### Step 2 — Select Specialists
+Use domain-to-specialist mapping table (below). Max 3 specialists.
+
+### Step 3 — Dispatch ALL task() calls in ONE message
+Each specialist prompt MUST include:
+- Structured output template (see Specialist Output Format below)
+- `shared_context` if Apollo pre-scan was done
+- Timeout per role: 120s for reviewers, 60s for explorers/implementers
+
+### Step 4 — Collect Responses
+Wait for all responses. Note TIMEOUT agents. Partial results OK only for read-only specialists (@apollo, @gaia).
+
+### Step 5 — Confidence Cross-Validation (Fase 2)
+For each specialist response, validate confidence claims:
 
-Send ALL `task()` calls in a single message. Each specialist must respond concisely (2-4 sentences).
+| Reported | Minimum Required | Action |
+|----------|-----------------|--------|
+| High | ≥ 3 specific claims | If fewer → downgrade to Medium, annotate "(auto-downgraded from High: only N specific claims)" |
+| Medium | ≥ 1 specific claim | Pass |
+| Low | Any response | Pass |
 
-⚠️ **TIMEOUT RULE:** If a specialist does not respond after other specialists have responded, proceed with partial results. Do NOT wait indefinitely.
+"Specific claim" = statement with evidence, data point, or verifiable fact (not opinion).
 
-1. Detect multi-perspective trigger pattern
-2. Select 2-4 specialists based on domain (see tables below)
-3. Dispatch ALL `task()` calls in ONE message
-4. Wait for responses — note any specialists that don't respond as TIMEOUT
-5. Synthesize: include "X of Y specialists responded" in output
-6. Adjust confidence: down if key specialists timed out
+### Step 6 — Divergence-Gated Rebuttal Round (Fase 2, conditional)
+Calculate agreement rate = `min(agreements, divergences) / total_points` from structured `agreement_signals`. If < 50% agreement:
+- Dispatch ONE rebuttal round: specialists see ALL other responses and refine their own
+- Updated responses treated as final
+- Hard cap: MAX 3 total rounds (initial + 2 rebuttals)
+- Skip if any TIMEOUT occurred (can't rebuttal without all voices)
+
+### Step 6b — Modo Desempate com Evidência (Fase 2, conditional)
+
+If after Step 6 the agreement rate is STILL < 50% (rebuttal did not resolve divergence):
+
+1. **Identify divergence points** — Parse all specialist responses (initial + rebuttal) and extract specific issues where positions differ
+2. **Web research** — For EACH divergence point, Zeus calls `browser_search()` or `webfetch()` to find factual evidence:
+   - Benchmarks, documentation, GitHub issues, official sources
+   - At least 2 independent sources per point when possible
+   - Focus on factual data, not opinion
+3. **Compile Evidence Brief** — Structure findings as:
+   ```
+   ## evidence_brief
+   **divergence_point_1:** <description>
+   **evidence_found:** <facts from web, max 3 sentences>
+   **sources:** [URL1, URL2]
+
+   **divergence_point_2:** ...
+   ```
+4. **Dispatch @themis as moderator** — Send ONE task with:
+   - All specialist responses (initial + rebuttal)
+   - The evidence brief
+   - Prompt: "Act as impartial moderator. These specialists disagree on [points]. Here is web evidence on each point. Issue a final verdict for each divergence point, citing specific evidence. Return structured verdict."
+5. **Themis returns moderator verdict** in this format:
+   ```
+   ## moderator_verdict
+   **divergence_points_analyzed:** <count>
+   **verdicts:**
+     - <point 1>: <decision> — evidence: <citation>
+     - <point 2>: <decision> — evidence: <citation>
+   **overall_direction:** <which approach is better supported by evidence>
+   **confidence:** High | Medium | Low
+   **unresolved:** <any points still unclear despite evidence>
+   ```
+6. **Zeus incorporates verdict** into synthesis (Step 7), showing which evidence supported which conclusion
+
+**Rules:**
+- Only triggers when agreement rate < 50% AFTER rebuttal round
+- Skip if NO divergence points are web-researchable (purely subjective/opinion-based disagreements)
+- Max 3 web searches per council (prevents runaway)
+- If Themis confidence is Low or points remain unresolved, note this explicitly in synthesis
+- Themis moderator role is SEPARATE from the Themis Audit Gate (Step 8) — they serve different functions
+
+### Step 7 — Zeus Synthesize
+Use structured `agreement_signals` to auto-detect agreements/divergences. Output synthesis template (see below).
+
+### Step 8 — Themis Audit Gate (Fase 1)
+Post-synthesis, dispatch @themis:
+```
+task(subagent_type: "themis", prompt: "Audit this council synthesis for fidelity. Compare raw specialist responses against the synthesized output. Check: (1) Any specialist misrepresented? (2) Divergences hidden or softened? (3) Confidence claims match response specificity? Return ✅ or list specific issues.")
+```
+- If ✅ → proceed
+- If issues → fix each issue before delivering to user
+
+### Step 9 — Persist & Reconcile (Fase 1)
+```
+memory_store({
+  namespace: "council_decisions",
+  key: "council:<yyyy-mm-dd>:<slug>",
+  value: JSON.stringify({
+    question, specialists, recommendation, confidence,
+    agreements, divergences, precedent_used, timestamp
+  }),
+  metadata: {type: "council_decision", specialist_count: N}
+})
+board.markReconciled("<task-id>")
+```
+
+## Specialist Output Format (Fase 1 — machine-parseable structured fields)
+
+Specialists MUST return these structured fields in their response:
+
+```
+## specialist_response
+**position:** <clear one-sentence position>
+**reasoning:** <2-4 sentences>
+**trade_offs:** <what's gained vs lost>
+**risks:** <what could go wrong>
+**confidence:** High | Medium | Low
+**agreement_signals:** agree: @agent1, @agent2 on [issue] | disagree: @agent3 on [issue]
+**specific_claims:** <count of specific factual claims in response>
+```
 
 ## Domain-to-Specialist Mapping
 
@@ -73,7 +231,7 @@ Send ALL `task()` calls in a single message. Each specialist must respond concis
 | Observability | nyx, hermes |
 | General | athena, themis, hermes |
 
-## Synthesis Output Template
+## Synthesis Output Template (enhanced)
 
 ```
 ## 🏛️ Council Synthesis
@@ -82,6 +240,8 @@ Send ALL `task()` calls in a single message. Each specialist must respond concis
 **Date:** <date>
 **Response rate:** X of Y specialists responded
 **Timed out:** @agent1, @agent2 (if any)
+**Precedent used:** yes/no (which one, date)
+**Research context:** <shared_context summary> (if --research)
 
 ### Specialist Perspectives
 | Agent | Position | Trade-offs | Confidence |
@@ -95,11 +255,70 @@ Send ALL `task()` calls in a single message. Each specialist must respond concis
 | Issue | Side A | Side B | Resolution |
 |-------|--------|--------|------------|
 
+### Evidence & Moderation (if tie-break activated)
+**Divergence points researched:** <list>
+**Evidence summary:** <key findings from web>
+**Moderator verdict:** <Themis final determination>
+**Sources:** <citations>
+
 ### Recommendation
 <decisive conclusion>
 
+### Audit Gate
+**Status:** ✅ Themis approved | ⚠️ Issues corrected
+
 ### Decision Gate
 **Confidence:** High/Medium/Low (adjusted for response rate)
 ```
 
-> **Note**: The user can explicitly invoke this via `/pantheon <question>`. The command dispatches to Zeus who runs the council inline.
+## Themis Audit Gate Rules (Fase 1)
+
+1. Every specialist mentioned in synthesis? → ✅
+2. Divergences from raw responses preserved (not softened/hidden)? → ✅
+3. No specialist attributed a position they didn't state? → ✅
+4. Confidence claims match response specificity? → ✅
+5. If any ❌, list specific issues for Zeus to fix before delivery
+
+## Rebuttal Round Rules (Fase 2)
+
+1. Only triggers when agreement rate < 50%
+2. MAX 3 rounds total (including initial dispatch)
+3. Skip if any TIMEOUT (can't rebuttal without all voices)
+4. Each rebuttal round: specialist sees ALL other responses + current synthesis draft
+5. Refined responses replace originals for the final synthesis
+6. If agreement rate STILL < 50% after rebuttal → Step 6b (Modo Desempate com Evidência)
+
+## Crash Recovery via BackgroundJobBoard (Fase 1)
+
+If Zeus context crashes mid-council:
+1. On restart, `board.recoverRunningJobs()` marks running jobs as error
+2. Check `board.formatForPrompt()` for unreconciled terminal jobs
+3. Re-dispatch council with same question, noting: "⚠️ Retry — previous council session crashed. Using same question."
+
+## Performance Budget
+
+| Step | Latency | Phase |
+|------|---------|-------|
+| Precedent fast-path | < 500ms | Fase 1 |
+| Apollo pre-scan | +30s (optional, --research) | Fase 2 |
+| Specialist dispatch | bounded by slowest (60-120s) | — |
+| Rebuttal round | +60s (conditional, < 50% agreement) | Fase 2 |
+| Web search (tie-break) | +15s (conditional, < 50% after rebuttal) | Fase 2 |
+| Themis moderator | +15s (conditional, tie-break activated) | Fase 2 |
+| Themis audit | +15s | Fase 1 |
+| **Total worst case** (research + rebuttal + tie-break) | ~255s | — |
+| **Total typical** (no research, no rebuttal, no tie-break) | ~45-90s | — |
+
+> **Note**: The user can explicitly invoke this via `/pantheon <question>`. The `--research` flag adds Apollo pre-scan. All decisions are stored in `council_decisions` memory namespace for fast-path retrieval on future councils.
+
+## Modo Desempate Rules (Fase 2)
+
+1. Only triggers when agreement rate < 50% AFTER rebuttal round
+2. If no divergence points are web-researchable (pure opinion disagreement), skip — Zeus synthesizes with lower confidence
+3. Max 3 web searches per council invocation
+4. Themis moderator role is DISTINCT from Themis audit gate:
+   - Moderator: resolves substantive disagreement between specialists (reads evidence, gives verdict)
+   - Audit gate: checks synthesis fidelity against raw responses (quality assurance)
+   Both run in the same council invocation, at different steps
+5. If Themis moderator confidence is Low, mark as "unresolved tie" in the synthesis output
+6. Evidence from web search must be cited with source URL or document reference — no anonymous claims

package/src/plugin.ts

@@ -1,4 +1,42 @@
 import type { PluginConfig } from 'opencode'
+import { BackgroundJobBoard } from './pantheon/background-job-board.ts'
+import { FilePersistenceAdapter } from './pantheon/file-persistence.ts'
+
+// ─── Background Job Board Singleton ────────────────────────────────────
+
+const board = new BackgroundJobBoard({
+  maxConcurrentPerAgent: 3,
+  signalDir: '.pantheon/deepwork/board-signals',
+})
+
+// Wire up file-based persistence and recover orphaned jobs from crashes
+const persistence = new FilePersistenceAdapter('.pantheon/board/state.json')
+board.setPersistence(persistence)
+
+// Recover on startup — any jobs left in "running" state become "error"
+board.recoverRunningJobs().catch((err) =>
+  console.error('[Pantheon Plugin] Failed to recover running jobs:', err),
+)
+
+// Log board state changes to console for observability
+board.onTerminal((taskID: string) => {
+  const job = board.get(taskID)
+  if (job) {
+    console.log(
+      `[Pantheon Plugin] Board terminal: [${job.alias}] ${job.description} → ${job.state}${job.resultSummary ? ` — ${job.resultSummary}` : ''}`,
+    )
+  }
+})
+
+/**
+ * Get the global BackgroundJobBoard singleton.
+ *
+ * All modules (Zeus, auto-wake, etc.) should access the board through this
+ * function to ensure a single consistent state machine across the plugin.
+ */
+export function getBackgroundJobBoard(): BackgroundJobBoard {
+  return board
+}
 
 export default {
   name: 'pantheon',

package/src/routing.yml

@@ -1,251 +1,218 @@
-# routing.yml — Canonical Routing Source for Pantheon
-# Version: 1.0 — Agent routing, delegation rules, and handoff contracts
 version: 1.0
-
-# Primary Delegation Flow
-# ```mermaid
-# flowchart LR
-#     Z[Zeus] --> A[Athena] --> AP[Apollo]
-#     Z --> H[Hermes] --> T[Themis]
-#     Z --> PH[Aphrodite] --> T
-#     Z --> D[Demeter] --> T
-#     Z --> R[Prometheus]
-#     Z --> HE[Hephaestus]
-#     Z --> N[Nyx]
-#     Z --> G[Gaia]
-# #     Z --> I[Iris] --> M[Mnemosyne]
-#     Z --> M
-#     Z -.-> TA[Talos]
-#     T --> I
-#     T --> M
-# ```
-# Removed agents: argus, chiron, echo (merged/deprecated)
-
-# AGENT REGISTRY — 14 active agents
 agents:
   zeus:
-    role: "Central orchestrator"
-    model_tier: default
+    role: Central orchestrator
+    model_tier: code
     reasoning_effort: medium
     user_invocable: true
     can_delegate: true
     can_receive_delegation: true
     capabilities:
-      - orchestration
-      - delegation
-      - context_conservation
-      - context_compression
-      - phase_management
-      - quality_gate_enforcement
-      - memory_recall
-      - pantheon_resources
-      - pantheon_code_mode
-      - pantheon_deepwork
+    - orchestration
+    - delegation
+    - context_conservation
+    - context_compression
+    - phase_management
+    - quality_gate_enforcement
+    - memory_recall
+    - pantheon_resources
+    - pantheon_code_mode
+    - pantheon_deepwork
     subagent_can_delegate_to:
-      - athena
-      - apollo
-      - hermes
-      - aphrodite
-      - demeter
-      - themis
-      - prometheus
-      - hephaestus
-      - nyx
-      - iris
-      - mnemosyne
-      - talos
+    - athena
+    - apollo
+    - hermes
+    - aphrodite
+    - demeter
+    - themis
+    - prometheus
+    - hephaestus
+    - nyx
+    - iris
+    - mnemosyne
+    - talos
     skills:
-      - agent-coordination
-      - session-goal
-      - artifact-management
-      - context-compression
-      - auto-continue
-      - orchestration-workflow
-      - incremental-implementation
-
+    - agent-coordination
+    - session-goal
+    - artifact-management
+    - context-compression
+    - auto-continue
+    - orchestration-workflow
+    - incremental-implementation
   athena:
-    role: "Strategic planner"
+    role: Strategic planner
     model_tier: premium
     reasoning_effort: high
     user_invocable: true
     can_delegate: true
     can_receive_delegation: true
     capabilities:
-      - strategic_planning
-      - tdd_planning
-      - architectural_design
-      - root_cause_analysis
-      - risk_assessment
-      - memory_recall
-      - pantheon_resources
+    - strategic_planning
+    - tdd_planning
+    - architectural_design
+    - root_cause_analysis
+    - risk_assessment
+    - memory_recall
+    - pantheon_resources
     subagent_can_delegate_to:
-      - apollo
+    - apollo
     skills:
-      - spec-driven-development
-      - memory-bank
-
+    - spec-driven-development
+    - memory-bank
   apollo:
-    role: "Investigation scout"
-    model_tier: fast
+    role: Investigation scout
+    model_tier: free
     reasoning_effort: low
     user_invocable: false
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - codebase_discovery
-      - pattern_discovery
-      - dependency_research
-      - parallel_search
-      - codemap_generation
-      - memory_search
-      - pantheon_resources
+    - codebase_discovery
+    - pattern_discovery
+    - dependency_research
+    - parallel_search
+    - codemap_generation
+    - memory_search
+    - pantheon_resources
     subagent_can_delegate_to: []
     skills:
-      - auto-continue
-
+    - auto-continue
   hermes:
-    role: "Backend specialist"
-    model_tier: default
+    role: Backend specialist
+    model_tier: code
     reasoning_effort: medium
     user_invocable: true
     can_delegate: true
     can_receive_delegation: true
     capabilities:
-      - backend_implementation
-      - api_development
-      - service_layer
-      - async_programming
-      - obsolete_lib_detection
-      - memory_store
-      - pantheon_code_mode
+    - backend_implementation
+    - api_development
+    - service_layer
+    - async_programming
+    - obsolete_lib_detection
+    - memory_store
+    - pantheon_code_mode
     skills:
-      - tdd-with-agents
-      - file-prompts
-      - streaming-patterns
-      - git-workflow-and-versioning
-      - incremental-implementation
-
+    - tdd-with-agents
+    - file-prompts
+    - streaming-patterns
+    - git-workflow-and-versioning
+    - incremental-implementation
   aphrodite:
-    role: "Frontend specialist"
-    model_tier: default
+    role: Frontend specialist
+    model_tier: code
     reasoning_effort: medium
     user_invocable: true
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - frontend_implementation
-      - ui_component_design
-      - accessibility_audit
-      - responsive_design
-      - deprecated_npm_detection
-      - memory_store
-      - pantheon_resources_memory_bank
+    - frontend_implementation
+    - ui_component_design
+    - accessibility_audit
+    - responsive_design
+    - deprecated_npm_detection
+    - memory_store
+    - pantheon_resources_memory_bank
     skills:
-      - tdd-with-agents
-      - visual-review-pipeline
-      - file-prompts
-
+    - tdd-with-agents
+    - visual-review-pipeline
+    - file-prompts
   demeter:
-    role: "Database specialist"
-    model_tier: default
+    role: Database specialist
+    model_tier: code
     reasoning_effort: medium
     user_invocable: true
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - database_migration
-      - schema_design
-      - query_optimization
-      - n_plus_one_prevention
-      - index_strategy
-      - memory_store
-      - memory_recall
+    - database_migration
+    - schema_design
+    - query_optimization
+    - n_plus_one_prevention
+    - index_strategy
+    - memory_store
+    - memory_recall
     skills:
-      - tdd-with-agents
-      - incremental-implementation
-
+    - tdd-with-agents
+    - incremental-implementation
   themis:
-    role: "Quality gate"
+    role: Quality gate
     model_tier: premium
     reasoning_effort: high
     user_invocable: true
     can_delegate: true
     can_receive_delegation: true
     capabilities:
-      - code_review
-      - security_audit
-      - test_coverage_validation
-      - quality_gate
-      - dead_code_detection
-      - deprecation_audit
-      - memory_search
-      - pantheon_resources
+    - code_review
+    - security_audit
+    - test_coverage_validation
+    - quality_gate
+    - dead_code_detection
+    - deprecation_audit
+    - memory_search
+    - pantheon_resources
     subagent_can_delegate_to:
-      - mnemosyne
+    - mnemosyne
     skills:
-      - code-review-checklist
-      - security-hardening
-      - tdd-with-agents
-      - context-compression
-
+    - code-review-checklist
+    - security-hardening
+    - tdd-with-agents
+    - context-compression
   prometheus:
-    role: "Infrastructure specialist"
-    model_tier: default
+    role: Infrastructure specialist
+    model_tier: code
     reasoning_effort: medium
     user_invocable: true
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - infrastructure_as_code
-      - docker_configuration
-      - ci_cd_pipelines
-      - deployment_strategy
-      - container_optimization
-      - pantheon_code_mode
-      - memory_store
+    - infrastructure_as_code
+    - docker_configuration
+    - ci_cd_pipelines
+    - deployment_strategy
+    - container_optimization
+    - pantheon_code_mode
+    - memory_store
     skills:
-      - git-workflow-and-versioning
-      - incremental-implementation
-
+    - git-workflow-and-versioning
+    - incremental-implementation
   hephaestus:
-    role: "AI pipelines"
-    model_tier: default
+    role: AI pipelines
+    model_tier: code
     reasoning_effort: medium
     user_invocable: true
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - rag_pipeline_design
-      - langchain_workflow
-      - vector_store_integration
-      - embedding_strategy
-      - ai_workflow_composition
-      - memory_search
+    - rag_pipeline_design
+    - langchain_workflow
+    - vector_store_integration
+    - embedding_strategy
+    - ai_workflow_composition
+    - memory_search
     skills:
-      - tdd-with-agents
-      - auto-continue
-
+    - tdd-with-agents
+    - auto-continue
   nyx:
-    role: "Observability"
-    model_tier: fast
+    role: Observability
+    model_tier: free
     reasoning_effort: low
     user_invocable: true
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - opentelemetry_setup
-      - token_cost_tracking
-      - agent_performance_analytics
-      - alerting
-      - monitoring_dashboards
-      - pantheon_resources_routing
+    - opentelemetry_setup
+    - token_cost_tracking
+    - agent_performance_analytics
+    - alerting
+    - monitoring_dashboards
+    - pantheon_resources_routing
     skills:
-      - security-hardening
-      - auto-continue
-
+    - security-hardening
+    - auto-continue
   gaia:
     role: Remote sensing domain specialist
-    model_tier: fast
+    model_tier: free
     reasoning_effort: low
     user_invocable: false
     can_delegate: false
@@ -257,183 +224,175 @@ agents:
     - ml_classification
     skills:
     - auto-continue
-
   iris:
-    role: "GitHub operations"
-    model_tier: fast
+    role: GitHub operations
+    model_tier: free
     reasoning_effort: low
     user_invocable: true
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - branch_management
-      - pull_request_creation
-      - issue_tracking
-      - release_management
-      - changelog_generation
-      - pantheon_resources
+    - branch_management
+    - pull_request_creation
+    - issue_tracking
+    - release_management
+    - changelog_generation
+    - pantheon_resources
     subagent_can_delegate_to:
-      - mnemosyne
+    - mnemosyne
     skills:
-      - git-workflow-and-versioning
-      - artifact-management
-
+    - git-workflow-and-versioning
+    - artifact-management
   mnemosyne:
-    role: "Memory bank"
-    model_tier: fast
+    role: Memory bank
+    model_tier: free
     reasoning_effort: low
     user_invocable: true
     can_delegate: true
     can_receive_delegation: true
     capabilities:
-      - memory_bank_management
-      - artifact_persistence
-      - adr_writing
-      - project_initialization
-      - sprint_documentation
-      - context_compression
-      - memory_store
-      - memory_recall
-      - pantheon_resources_memory_bank
+    - memory_bank_management
+    - artifact_persistence
+    - adr_writing
+    - project_initialization
+    - sprint_documentation
+    - context_compression
+    - memory_store
+    - memory_recall
+    - pantheon_resources_memory_bank
     subagent_can_delegate_to: []
     skills:
-      - artifact-management
-      - memory-bank
-      - context-compression
-      - session-goal
-
+    - artifact-management
+    - memory-bank
+    - context-compression
+    - session-goal
   talos:
-    role: "Hotfix agent"
-    model_tier: fast
+    role: Hotfix agent
+    model_tier: free
     reasoning_effort: low
     user_invocable: true
     can_delegate: false
     can_receive_delegation: true
     capabilities:
-      - rapid_repair
-      - css_fix
-      - typo_correction
-      - minor_bug_fix
-      - escalation_detection
-      - pantheon_code_mode
+    - rapid_repair
+    - css_fix
+    - typo_correction
+    - minor_bug_fix
+    - escalation_detection
+    - pantheon_code_mode
     subagent_can_delegate_to: []
     skills:
-      - incremental-implementation
-
-# AUTO-CONTINUE CONFIGURATION
-# Checkpoint and heartbeat settings for autonomous sessions
+    - incremental-implementation
 auto_continue:
-  checkpoint_script: ".pantheon/code-mode/checkpoint-session.sh"
+  checkpoint_script: .pantheon/code-mode/checkpoint-session.sh
   heartbeat_interval: 5
   idle:
     warning: 60
     stall: 120
     pause: 300
-
-# DELEGATION RULES
-# Implicit default: any agent can delegate to apollo for codebase discovery.
-# Overrides are listed in agent subagent_can_delegate_to fields above.
-# See instructions/zeus-timeout-retry.instructions.md for timeout/retry defaults.
-# INTENT GATE — Heuristic request classification (zero LLM)
-# Zeus classifies the request BEFORE delegating to the correct agent.
-# Patterns are matched by keyword, not LLM call.
 intent_gate:
   fix:
-    patterns: ["bug", "error", "crash", "broken", "fail", "wrong", "incorrect"]
+    patterns:
+    - bug
+    - error
+    - crash
+    - broken
+    - fail
+    - wrong
+    - incorrect
     target: talos
   research:
-    patterns: ["how", "what", "why", "where", "find", "search", "lookup", "documentation"]
+    patterns:
+    - how
+    - what
+    - why
+    - where
+    - find
+    - search
+    - lookup
+    - documentation
     target: apollo
   investigate:
-    patterns: ["compare", "vs", "trade.?off", "should", "which", "risk", "impact"]
+    patterns:
+    - compare
+    - vs
+    - trade.?off
+    - should
+    - which
+    - risk
+    - impact
     target: athena
   plan:
-    patterns: ["plan", "roadmap", "architecture", "design", "proposal", "strategy"]
+    patterns:
+    - plan
+    - roadmap
+    - architecture
+    - design
+    - proposal
+    - strategy
     target: athena
   implement:
     patterns: []
-    target: hermes  # default fallback
-
+    target: hermes
 delegation:
   zeus:
-    - target: athena
-    - target: apollo
-    - target: hermes
-    - target: aphrodite
-    - target: demeter
-    - target: themis
-    - target: prometheus
-    - target: hephaestus
-    - target: nyx
-    - target: gaia
-    - target: iris
-    - target: mnemosyne
-    - target: talos
-
-  # Delegation conventions (documentation only — not programmatically enforced):
-  # - Implementers → themis for code review
-  # - Themis → zeus (blockers/escalation) or mnemosyne (documentation)
-  # - Others → zeus or athena as appropriate
-
-# HANDOFF DEFINITIONS — named contracts for delegation
+  - target: athena
+  - target: apollo
+  - target: hermes
+  - target: aphrodite
+  - target: demeter
+  - target: themis
+  - target: prometheus
+  - target: hephaestus
+  - target: nyx
+  - target: gaia
+  - target: iris
+  - target: mnemosyne
+  - target: talos
 handoffs:
   zeus:
     compress_context:
-      label: "🗜️ Compress Context"
-      description: "Compress completed subtask_summaries and archive IMPL/REVIEW artifacts after Themis approval"
+      label: 🗜️ Compress Context
+      description: Compress completed subtask_summaries and archive IMPL/REVIEW artifacts
+        after Themis approval
       agent: mnemosyne
-      prompt: "Compress completed phase artifacts (Level 2): create ZZ-phase{N}-context.md with priority-scored entries, write compressed entries to 01-active-context.md (priority-aware, budget-allocated), archive IMPL/REVIEW to 02-progress-log.md, update _xref/index.md cross-references."
-
-# PLATFORM TOOL MAPPINGS
+      prompt: 'Compress completed phase artifacts (Level 2): create ZZ-phase{N}-context.md
+        with priority-scored entries, write compressed entries to 01-active-context.md
+        (priority-aware, budget-allocated), archive IMPL/REVIEW to 02-progress-log.md,
+        update _xref/index.md cross-references.'
 platforms:
   opencode:
-    display_name: "OpenCode"
+    display_name: OpenCode
     tools:
-      delegate_agent: "agent"
-      delegate_subagent: "task"
-      ask_user: "question"
-      search_codebase: "grep"
-      search_files: "glob"
-      read_file: "read"
-      run_bash: "bash"
-      web_fetch: "webfetch"
-      web_search: "websearch"
+      delegate_agent: agent
+      delegate_subagent: task
+      ask_user: question
+      search_codebase: grep
+      search_files: glob
+      read_file: read
+      run_bash: bash
+      web_fetch: webfetch
+      web_search: websearch
     capabilities:
-      - agent_delegation
-      - subagent_delegation
-      - bash_execution
-      - web_fetch
-      - web_search
-
-# ARTIFACT LIFECYCLE
-# See skill: artifact-management for full lifecycle rules.
-# Summary: PLAN, IMPL, REVIEW, DISC → .pantheon/memory-bank/.tmp/ (ephemeral, sprint-scoped).
-# ADR → .pantheon/memory-bank/_notes/ (permanent). Subtask → inline, no artifact.
-
-# MODEL FALLBACK CHAINS
-# When an agent's primary model is rate-limited (429) or unavailable,
-# the platform should attempt the next model in the chain.
-# Chain pattern: Primary → Secondary → Emergency
-# These chains are advisory — the platform's model routing determines
-# actual fallback behavior at runtime.
+    - agent_delegation
+    - subagent_delegation
+    - bash_execution
+    - web_fetch
+    - web_search
 fallback_chains:
   premium_agents:
-    primary: "anthropic/claude-sonnet-4-20250514"
-    secondary: "openai/gpt-5.1"
-    emergency: "deepseek/deepseek-v4-pro"
-
-  default_agents:
-    primary: "anthropic/claude-sonnet-4-20250514"
-    secondary: "openai/gpt-4o"
-    emergency: "deepseek/deepseek-v4-pro"
-
-  fast_agents:
-    primary: "deepseek/deepseek-v4-pro"
-    secondary: "anthropic/claude-haiku-4-20250514"
-    emergency: "openai/gpt-4o-mini"
-
-  agent_overrides:
-    gaia:
-      primary: "anthropic/claude-sonnet-4-20250514"
-      secondary: "openai/gpt-4o"
-      emergency: "deepseek/deepseek-v4-pro"
+    primary: deepseek/deepseek-v4-pro
+    secondary: mimo/v2.5
+    emergency: deepseek/deepseek-v4-pro
+  code_agents:
+    primary: deepseek/deepseek-v4-flash
+    secondary: mimo/v2.5
+    emergency: deepseek/deepseek-v4-flash
+  free_agents:
+    primary: deepseek/deepseek-v4-flash
+    secondary: mimo/v2.5
+    emergency: deepseek/deepseek-v4-flash
+background_job_board:
+  max_concurrent_per_agent: 3
+  signal_dir: .pantheon/deepwork/board-signals/
+  persistence_dir: .pantheon/board/jobs/