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

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

@@ -1,133 +1,23 @@
 ---
 description: "Universal memory protocol rules for all Pantheon agents with agent-specific overrides"
 name: "Memory Protocol"
-applyTo: "agents/*.agent.md"
+agents: ["*"]
 ---
 
 # 🧠 Memory Protocol — Universal Rules
 
-These rules apply to ALL Pantheon agents. Agent-specific overrides are defined
-in each agent's `## 🧠 Memory Protocol` section.
+These rules apply to all agents; each agent file may add domain-specific rules.
 
 ## Universal Rules
 
-### 1. Pre-Work Read-Only Recall
-**Call `memory_search()` at task start before any file reads.**
-- Use domain-specific context matching your agent's focus area
-- Single call per task, not per turn
-- Agents have **read-only** memory access — only `memory_search()` is available
+### Retrieval
+- Search only when prior project history could change the outcome; skip self-contained questions and bounded changes.
+- For delegated work, Zeus searches at most once and passes useful hits to the specialist. Reuse supplied results; search separately only if relevant history is needed but missing.
+- Use a targeted query (`top_k=2`); do not search the whole prompt by default. Missing or irrelevant results never block current work.
 
-### 2. Auto-Store by Zeus on Subtask Summary
-**`memory_store()` is called AUTOMATICALLY by Zeus when you return a subtask_summary.**
-- Include a clear `summary` field in your return — no explicit `memory_store()` call needed
-- This is the **ONLY** persistence path: agent → subtask_summary → Zeus → memory_store
-- Zeus persists ALL agent returns (implementers and read-only agents alike)
+### Persistence
+- `memory_store()` is manual, not automatic. Store at most one concise, reusable top-level result; never persist routine child summaries, phase updates, test logs, or temporary state.
+- Confirm the store succeeded before claiming persistence. There is no automatic memory WAL or recovery. Add ADRs to the memory bank only when explicitly requested.
 
-### 3. Write-Ahead Log (WAL)
-Before Zeus calls `memory_store()`, it writes a write-ahead log to:
-```
-.pantheon/memory-wal/<agent>/<timestamp>.json
-```
-- WAL format: `{ agent, phase, summary, files_changed, status, timestamp }`
-- WAL is written **before** the store operation — if store crashes, WAL is recovered on next session start
-- WAL files are ephemeral (auto-cleaned after 7 days)
-
-### 4. Relevance Threshold
-**Skip search results if relevance score < 0.3.**
-- Prevents noise from unrelated past entries
-- Applies to `memory_search()` results only
-
-### 5. Permanent Documentation
-**ADR-level decisions → delegate to `@mnemosyne`.**
-- Use for: architecture decisions, significant trade-offs, pattern changes
-- Not for: routine task summaries (handled by Auto-Store)
-
-## Per-Agent Overrides
-
-Each agent file defines overrides in its `## 🧠 Memory Protocol` section:
-- Domain-specific `memory_search()` context string
-- Read-only access via `memory_search()` only — no `memory_store` for subagents
-- Agent-specific rules (session-end, sprint close, quick-index, etc.)
-
-
-## Delegation Cache
-
-Para otimizar decisoes de delegacao e reduzir gasto de tokens:
-
-1. **memory_search(query=task_prompt, top_k=2)** antes de aplicar a arvore de roteamento
-2. Se score > 0.85 → reutiliza agente + background_mode do cache
-3. Se score ≤ 0.85 → aplica regras estaticas e memory_store() com:
-   - key: deleg:<task_type>
-   - value: JSON.stringify({agent, background, pattern})
-   - metadata: JSON.stringify({type: "decision", score: N})
-
-   `value` E `metadata` sao JSON-encoded strings — o runtime exige que o
-   chamador serialize os dois. Objeto cru em `metadata` e rejeitado pelo
-   `BeforeValidator` do servidor com `metadata must be a JSON object encoded
-   as a string (got object). json.dumps it first. Example: metadata='{"type":
-   "decision", "score": 0.9}'`.
-
-4. **kv_store(namespace="deleg", key="deleg:<pattern>", value=...)** para padroes recorrentes de delegacao
-5. **kv_get(namespace="deleg", key="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: JSON.stringify({
-    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",
-    precedent_used: false,
-    timestamp: "<ISO-8601>"
-  }),
-  metadata: JSON.stringify({
-    type: "council_decision",
-    specialist_count: N,
-    model_tier_used: "premium|default|fast"
-  })
-})
-```
-`value` is JSON-serialized before storing (the MCP `memory_store.value` argument is a string).
-`metadata` works the same way — it is a JSON object encoded as a **string**, so pass
-`JSON.stringify({...})`. A raw object is rejected with `metadata must be a JSON object
-encoded as a string (got object). json.dumps it first. Example: metadata='{"type":
-"decision", "score": 0.9}'` (enforced by a `BeforeValidator` in
-`memory_mcp.py`). **Both `value` and `metadata` must be serialized by the caller.**
-
-### Read Path (Precedent Fast-Path)
-Before dispatching a new council, Zeus runs:
-```
-memory_search(query=question, top_k=2, namespace="council_decisions")
-```
-
-Result interpretation:
-| Score | Age | Action |
-|-------|-----|--------|
-| > 0.85 | < 30 days | Return precedent verbatim (note "⚠️ Decisão de [data] — reavaliar se contexto mudou") as fast-path answer. Skip council dispatch entirely. |
-| > 0.85 | >= 30 days | Return with warning "Reavaliar se contexto mudou — decisão tem mais de 30 dias" + 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
+### Relevance and permanent records
+Ignore weak matches; routine summaries do not belong in durable memory.

package/src/instructions/zeus-anti-stall.instructions.md

@@ -1,7 +1,8 @@
 ---
 description: "Stall detection, phase reminders, delegate retry, and progress checkpoints for Zeus"
 name: "Zeus Anti-Stall"
-applyTo: "agents/zeus.agent.md"
+agents: [zeus]
+fallback: shared
 ---
 
 # 🛑 ANTI-STALL & STALL DETECTION
@@ -32,85 +33,29 @@ Self-check every 3 turns: "Am I waiting on a delegate? Have I polled without nee
 
 ## Delegate Retry Enhancement
 
-When a delegation fails (timeout, empty response, error):
-
-1. **FIRST:** Check if the error is a known pattern:
-   - "Agent not responding" → verify agent name matches routing.yml
-   - "Context exceeded" → reduce scope, split into smaller tasks
-   - "Permission denied" → verify agent has correct tools/permissions
-
-2. **Retry ONCE** with rephrased prompt — add: "Previous attempt failed with: [error]. Adjusted approach: [what changed]."
-
-3. **If retry also fails** → do NOT retry blindly; follow the fallback chain and escalation protocol in `## ⏱️ Timeout & Retry Enforcement`.
+When a delegation has a transient dispatch failure (timeout, crash, or empty
+response), check known causes first and allow at most one corrected retry per
+agent/task. Do not retry a scope refusal or a failed test/validation; reroute
+only when the correct specialist is clear, otherwise diagnose or escalate.
+After a transient retry fails, follow the canonical fallback chain once and
+escalate rather than restarting it. See `## ⏱️ Timeout & Retry Enforcement`.
 
 ## Progress Checkpoint
 
-On tasks expected to run > 5 turns:
+For long-running or multi-phase tasks expected to run > 5 turns only:
 - After turn 5: output `[CHECKPOINT] Completed so far: [summary]. Remaining: [list].`
 - After turn 10: re-evaluate. If < 50% done, consider splitting or escalating.
 - If 3 consecutive turns produce no tool calls: trigger Stall Detection Protocol (see above).
 
 ## Heartbeat & Checkpoint Integration
 
-All session state lives in **pantheon-persistence** (namespace `checkpoint:<slug>`).
-No file I/O, no checkpoint_session.py — TTL (4h) handles cleanup automatically.
-
-### Heartbeat Check
-- If `context_get(slug=slug, key="heartbeat", session_id=SESSION_ID)` returns a checkin older than 300s, log a stall warning and resume
-- Write heartbeat after every anti-stall recovery action:
-  ```
-  context_save(slug=slug, key="heartbeat", content=JSON.stringify({"status": "alive", "last_action": "...", "turn_count": N}), session_id=SESSION_ID)
-  ```
-
-### Checkpoint Auto-Save (Pré-Compactação)
-Before ANY delegate dispatch, save a checkpoint:
-```
-context_save(slug=slug, key="phase:N", content=JSON.stringify({
-  "phase": {"current": N, "total": M, "name": "..."},
-  "turn_count": N, "agent": "...", "summary": "..."
-}), session_id=SESSION_ID)
-```
-**`content.phase` must be an OBJECT, not a bare number.** `{"phase": 1}` is rejected with
-`context_save: content.phase must be an object (got number)`. The server reads `current`
-and `total` (non-negative ints) and `name` (string, max 256 **bytes** — the guard
-measures `len(value.encode())`, so multi-byte characters count as more than one). That
-set is not closed: any other key inside `phase` is accepted and ignored, never an
-error. The `"phase:N"` slot KEY above is unrelated to `content.phase` and stays a plain
-string.
-All checkpoints auto-expire after 4h (TTL=14400).
-
-### Gatilho de Pré-Compactação (Anti-perda de estado)
-Antes da compactação nativa do OpenCode disparar (75-96% do context window),
-o Zeus DEVE salvar o estado atual:
-1. Capture session_id do primeiro `context_save` da sessão
-2. Salve heartbeat + phase atual + tarefas pendentes
-3. Só então permita que a compactação prossiga
-```
-# Ao iniciar sessão (session_id é REQUIRED — use o id da sessão corrente):
-result = context_save(slug=slug, key="init", content=JSON.stringify(session_state), session_id=SESSION_ID)
-SESSION_ID = result.session_id   # ← guarde para toda a sessão
-
-# Antes de CADA delegação:
-context_save(slug=slug, key=f"pre:{agent}", content=JSON.stringify(current_state), session_id=SESSION_ID)
-
-# Após retorno do agente:
-context_save(slug=slug, key=f"post:{agent}", content=JSON.stringify(result_state), session_id=SESSION_ID)
-```
-Isso garante que o estado sobreviva à compactação — o "latest" pointer
-sempre aponta para o checkpoint mais recente, mesmo após compactação.
+Use checkpoints only for long-running or multi-phase work when `context_save` and `context_get` are available. Never add persistence calls for a bounded task.
 
+### Checkpoint / Pre-Compaction
+Checkpoint only when context loss is plausible and both checkpoint tools are present. Save once at a meaningful boundary using `content=JSON.stringify(state)` and an explicit session ID; `state` must be an object with object-valued `phase`/`goal`/`delegations`/`heartbeat` fields and an array `tail`, and omit an unset `goal`. A successful save needs no immediate read. Checkpoints expire after 4h.
 
 ### Context Retrieval
-Next-phase agents retrieve previous context via:
-```
-context_get(slug=slug, session_id=SESSION_ID)                    # most recent checkpoint ("latest" is the default key)
-context_get(slug=slug, key="phase:3", session_id=SESSION_ID)     # specific phase
-context_list(slug=slug, session_id=SESSION_ID)                   # all checkpoints
-```
+Read a checkpoint only when resuming a workflow with a known session ID. Do not retrieve it after every dispatch; carry ordinary handoffs in the task context.
 
 ### Long-Session Progress
-Every 5 turns during a long session, update STATUS.md with:
-- Current phase
-- Completed tasks
-- Pending tasks
-- Any blockers
+For long-lived multi-phase work, update an existing/requested progress record every 5 turns with completed and pending work and blockers. Do not create STATUS.md for a bounded task.

package/src/instructions/zeus-communication-rules.instructions.md

@@ -1,7 +1,6 @@
 ---
 description: "Communication rules for Zeus and all Pantheon agents — clarity, conciseness, and directness"
 name: "Zeus Communication Rules"
-applyTo: "agents/zeus.agent.md"
 ---
 
 # 🗣️ COMMUNICATION RULES

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

@@ -1,203 +1,37 @@
 ---
-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"
+description: "Council synthesis — dispatch 2-3 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"
+agents: [zeus]
+fallback: shared
 ---
 
 # 🏛️ INLINE COUNCIL SYNTHESIS — /pantheon
 
-When a question requires multiple expert perspectives on a trade-off or architecture decision, **dispatch specialists inline** (visible to user) instead of delegating to a hidden subagent.
+Use an inline specialist council for material trade-offs, architecture/security choices, technology selection, cost/quality decisions, or multi-stakeholder questions. Do not use it for ordinary implementation tasks.
 
-## Trigger Patterns (detect ANY)
-- Trade-off questions: "which is better?", "should we use X or Y?", "compare A and B"
-- Architecture decisions with long-term impact
-- Security/compliance choices
-- Technology selection (databases, frameworks, providers, libraries)
-- "Is this safe?", "trade-offs of...", "what are the risks?"
-- Cost vs quality decisions
-- Multi-stakeholder concerns (frontend + backend + infra)
+## Dispatch and Synthesis
 
-```mermaid
----
-config:
-  look: classic
-  theme: dark
----
-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 [--research] question
-    Z->>M: memory_search(query, namespace="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
-```
-
-## Dispatch Sequence (9-Step Protocol)
-
-### Step 0 — Precedent Fast-Path (Fase 1)
-Run the precedent read path defined in `## Memory Protocol > Council Decisions Namespace` (`memory_search(query=question, top_k=2, namespace="council_decisions")`). If no precedent applies, 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:
-
-| 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 |
-
-"Specific claim" = statement with evidence, data point, or verifiable fact (not opinion).
-
-### 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. **Precedent:** Run the separate `council_decisions` search defined in `## Memory Protocol`. Apply its age/score rules; if no fast-path decision applies, continue.
+2. **Research (optional):** For `/pantheon --research <question>`, ask @apollo for a 30s pre-scan and pass findings as `shared_context` to every specialist.
+3. **Register:** Before dispatch, call `board.registerLaunch` with a council task ID, parent session, Zeus, question, and synthesis objective. This enables crash recovery.
+4. **Select and dispatch:** Choose at most 3 agents using the domain map below. Send all `task()` calls in one message. Each prompt includes the question, shared context, required response format, and role timeout (120s reviewers; 60s explorers/implementers).
+5. **Collect:** Wait for all responses and note timeouts. Partial responses are acceptable only from read-only @apollo or @gaia.
+6. **Validate confidence:** High requires at least 3 verifiable claims; otherwise downgrade to Medium and state why. Medium requires at least 1 claim; Low needs no minimum. Opinions alone are not specific claims.
+7. **Resolve divergence:** Compute agreement rate as `min(agreements, divergences) / total_points` from structured `agreement_signals`. Below 50%, and only if no agent timed out, run one rebuttal round with all responses and the current synthesis draft. Treat revised responses as final. If disagreement remains below 50%, research factual divergence points with official docs, benchmarks, or issues (max 3 searches; seek 2 independent sources per point when possible). Skip research for subjective-only disagreements. Send responses and a cited evidence brief to @themis as moderator; request verdicts, overall direction, confidence, and unresolved issues. Low confidence or unresolved points remain explicit in the synthesis. Moderator and audit roles are separate.
+8. **Synthesize and audit:** Use the output format below, then ask @themis to compare raw responses with the synthesis. Check representation of every specialist, preserved divergences, accurate attribution, and confidence specificity. Fix any issue before delivery.
+9. **Persist:** Store the decision using the `council_decisions` write format in `## Memory Protocol`, then call `board.markReconciled(task_id)`.
 
-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]
+If context is lost, use `board.recoverRunningJobs()` and `board.formatForPrompt()` to find unreconciled work. Re-dispatch a crashed council with the same question and label it as a retry.
 
-   **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
+## Specialist Response Format
 
-**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
+Require `## specialist_response` from `## Agent Return Format`: `position`, `reasoning`, `trade_offs`, `risks`, `confidence`, `agreement_signals`, and `specific_claims`.
 
-### Step 7 — Zeus Synthesize
-Use structured `agreement_signals` to auto-detect agreements/divergences. Output synthesis template (see below).
+## Domain Map
 
-### 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)
-Persist the decision using the write path in `## Memory Protocol > Council Decisions Namespace`, then `board.markReconciled("<task-id>")`.
-
-## Specialist Output Format (Fase 1 — machine-parseable structured fields)
-
-Specialists MUST return the structured `## specialist_response` format (position, reasoning, trade_offs, risks, confidence, agreement_signals, specific_claims) defined in `## Agent Return Format > Council Specialist Response Format`.
-
-## Domain-to-Specialist Mapping
-
-| Domain | Specialists |
-|--------|-------------|
-| Architecture | hermes, demeter, themis, athena |
+| Domain | Candidate agents |
+|---|---|
+| Architecture | athena, hermes, demeter, themis |
 | Security | themis, hermes, prometheus, nyx |
 | Database | demeter, hermes, prometheus |
 | AI/RAG | hephaestus, nyx |
@@ -206,94 +40,32 @@ Specialists MUST return the structured `## specialist_response` format (position
 | Observability | nyx, hermes |
 | General | athena, themis, hermes |
 
-## Synthesis Output Template (enhanced)
+## User-Facing Synthesis
 
-```
+```text
 ## 🏛️ Council Synthesis
-
-**Question:** <original question>
-**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)
+Question / date / response rate / timed-out agents / precedent / research context
 
 ### Specialist Perspectives
 | Agent | Position | Trade-offs | Confidence |
-|-------|----------|------------|------------|
-| @agent1 | ... | ... | High/Med/Low |
 
 ### Agreements
-- <what 2+ specialists agree on>
+- Points shared by multiple specialists
 
 ### Divergences
-| Issue | Side A | Side B | Resolution |
-|-------|--------|--------|------------|
+| Issue | Sides | Resolution |
 
-### Evidence & Moderation (if tie-break activated)
-**Divergence points researched:** <list>
-**Evidence summary:** <key findings from web>
-**Moderator verdict:** <Themis final determination>
-**Sources:** <citations>
+### Evidence & Moderation (when used)
+Research points, evidence, moderator verdict, cited sources, unresolved issues
 
 ### Recommendation
-<decisive conclusion>
+Decisive conclusion
 
 ### Audit Gate
-**Status:** ✅ Themis approved | ⚠️ Issues corrected
+Themis approved, or issues corrected
 
 ### Decision Gate
-**Confidence:** High/Medium/Low (adjusted for response rate)
+Confidence adjusted for response rate
 ```
 
-## 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
+The user invokes this flow with `/pantheon <question>`; `--research` enables the Apollo pre-scan. Preserve actual specialist timeout or unresolved-tie details in the response.

package/src/instructions/zeus-memory-operations.instructions.md

@@ -0,0 +1,26 @@
+---
+description: "Zeus-only council memory procedures"
+name: "Zeus Memory Operations"
+agents: [zeus]
+fallback: shared
+---
+
+# Zeus Memory Operations
+
+## Routing
+
+Reuse relevant memory already present in the request or task context. If prior project history matters and no result is present, Zeus may do one targeted search and pass useful hits with the delegation. Do not search on every turn or add KV/cache calls to ordinary dispatches.
+
+## Council Decisions
+
+Before a council, search separately from the task-level lookup only when a past council decision could affect the recommendation:
+`memory_search(query=question, top_k=2, namespace="council_decisions")`.
+Use a recent, directly matching decision only after checking current context;
+otherwise treat it as background, never as authority to skip a needed review.
+
+Persist only reusable, material decisions. Use
+`key="council:<yyyy-mm-dd>:<slug>"`; JSON-stringify both `value` and
+`metadata` for `memory_store(namespace="council_decisions", ...)`. Keep the
+record concise: question, recommendation, specialists, confidence, unresolved
+trade-off, and timestamp. Do not store routine subtask summaries or status
+updates. Use the memory bank for ADRs only when explicitly requested.