memtrace 0.8.61 → 0.8.63

package/installer/skills/commands/memtrace-decision-recall.md

@@ -1,94 +0,0 @@
----
-name: memtrace-decision-recall
-description: "Recall ranked decisions, bans, and conventions from Cortex decision memory by free-text query through the normal Memtrace MCP server. Use when the user asks what was decided/chosen/rejected, whether there is a convention/ban/policy, and before any non-trivial edit/refactor/delete or re-picking a library, pattern, architecture, or subsystem behavior that may already be settled. Do not reconstruct decisions from git log or guesswork. To verify whether a known decision held, use memtrace-intent-verification; for symbol lineage/contracts, use memtrace-provenance."
-allowed-tools:
-  - mcp__memtrace__recall_decision
-  - mcp__memtrace__verify_intent
-  - mcp__memtrace__get_arc
-metadata:
-  author: "Syncable <support@syncable.dev>"
-  version: "1.0.0"
-  category: development
----
-
-## Overview
-
-`recall_decision` is the **free-text entry point** to decision memory. Given a query,
-it returns the statistically-ranked set of decisions/conversations that bear on it —
-including **bans** ("never use X", "don't do Y"), which are recorded as decisions.
-Use it before re-litigating a settled choice, changing existing behavior, or
-contradicting a convention.
-
-This is the one decision-memory tool that takes plain text. The ranked decisions it
-returns carry the `decision_id`s the other tools (`verify_intent`, `get_arc`) need.
-
-Full parameter spec for every Memtrace tool: `references/mcp-parameters.md` (bundled at the memtrace-skills plugin root).
-
-## Quick Reference
-
-| Tool | Purpose |
-|------|---------|
-| `recall_decision` | Ranked decisions/bans for a free-text query (the entry point) |
-| `verify_intent` | Given a returned `decision_id` — did it still hold? (see `memtrace-intent-verification`) |
-| `get_arc` | Given a returned `decision_id` — what implemented it? (see `memtrace-intent-verification`) |
-
-> **Honesty contract:** an empty or unknown query returns an explicit **CannotProve**,
-> never a fabricated decision. CannotProve means "no recorded decision on this" — it is
-> *unknown*, not *approved*. Don't treat it as a green light.
-
-## Steps
-
-### 1. Query in the user's own terms
-
-`recall_decision(query)` — `query` is free text. Use the noun phrase of the thing in
-question: a library (`"redis vs in-memory cache"`), a pattern (`"error handling
-strategy"`), a subsystem (`"auth tokens"`), a symbol, or the exact edit/refactor/delete
-you are about to do.
-
-### 2. Read the ranked result
-
-Results come back ranked (lexical + semantic lanes, RRF-fused) with an `id`, a
-`kind`, and a score per hit. **`decision`-kind hits are ranked first**; lower-ranked
-`conversation` hits are supporting context (the verbatim turns around the decision).
-For anything you mean to chain (step 4), use a hit whose `kind` is `decision` — its
-`id` is the `decision_id` the other tools require.
-
-### 3. Act on what's there
-
-| Result | Action |
-|---|---|
-| A matching decision | Honor it. Quote it back to the user before doing anything that contradicts it. |
-| A **ban** ("never/don't …") | Do **not** reintroduce the banned approach without explicit user sign-off. |
-| Several competing/old hits | Run `verify_intent(decision_id)` on the top one to see if it still holds before relying on it. |
-| **CannotProve** | No recorded decision. Don't invent one — fall back to `memtrace-first` and/or ask the user. |
-
-### 4. Chain into the id-based tools when you need more
-
-The `id` of a `kind: "decision"` hit feeds `verify_intent` (did it hold?) and
-`get_arc` (what implemented it?). Don't pass a `conversation` hit's id — those tools
-require a Decision node and will honestly return CannotProve. See
-`memtrace-intent-verification`.
-
-## Decision Points
-
-| Situation | Action |
-|-----------|--------|
-| About to edit/refactor/delete existing code where intent may matter | `recall_decision("<symbol/subsystem/behavior>")` FIRST — you may be crossing a recorded decision, ban, or convention |
-| About to choose or replace a library/pattern/architecture | `recall_decision` FIRST — you may be undoing a deliberate choice or ban |
-| User asks "did we decide X?" / "what's our convention on Y?" | `recall_decision("X" / "Y")` |
-| You suspect a "don't do this" rule exists | `recall_decision` — bans are decisions and will surface |
-| Recall returns a decision you're about to contradict | Surface it to the user verbatim; don't silently override |
-| Recall returns CannotProve | Treat as unknown, not approval; do not fabricate a rationale |
-
-## Output
-
-`recall_decision` returns ranked hits — `kind: "decision"` first, `conversation` hits below as supporting context — or an explicit **CannotProve**:
-
-```json
-[
-  { "id": "…", "kind": "decision", "score": 0.91 },
-  { "id": "…", "kind": "conversation", "score": 0.44 }
-]
-```
-
-Only a `decision`-kind hit's `id` is a `decision_id` usable with `verify_intent` / `get_arc`. An empty or unknown query returns CannotProve, never fabricated hits.

package/installer/skills/commands/memtrace-docs-ask.md

@@ -1,99 +0,0 @@
----
-name: memtrace-docs-ask
-description: "Answer questions from official Memtrace documentation only — installation, CLI, MCP tools, fleet, Cortex, enterprise MemDB deploy, skills, configuration. Use when the user asks how Memtrace works or wants a cited explanation. Calls ask_docs on memtrace.io (RAG + guardrails). Do not guess product behavior from training data."
-allowed-tools:
-  - mcp__memtrace__ask_docs
-  - mcp__memtrace__search_docs
-  - mcp__memtrace__read_doc
-metadata:
-  author: "Syncable <support@syncable.dev>"
-  version: "1.0.0"
-  category: development
----
-
-## Overview
-
-`ask_docs` sends the user's question to the hosted docs RAG backend. The server
-retrieves relevant doc chunks, generates an answer **only from that context**, and
-returns citations. Off-topic or ungrounded questions return `refused: true`.
-
-This is the **default** tool for "how does Memtrace X work?" questions.
-
-Umbrella routing: `memtrace-docs` workflow.
-
-## `ask_docs` parameters
-
-| Param | Required | Notes |
-|---|---|---|
-| `question` | yes | Pass the user's question verbatim when possible |
-
-```json
-{ "question": "How do I deploy MemDB with Docker Compose?" }
-```
-
-## Response shape
-
-```json
-{
-  "ok": true,
-  "answer": "…markdown with /docs/… links…",
-  "citations": ["enterprise/memdb-deploy", "cli/connect"],
-  "refused": false
-}
-```
-
-| Field | Meaning |
-|---|---|
-| `answer` | Grounded response text |
-| `citations` | Doc slugs used as context |
-| `refused` | `true` when no context or injection detected |
-| `refusalReason` | `no_context` or `injection` when refused |
-
-## Steps
-
-### 1. Ask
-
-Use the user's exact wording when it is already a clear question:
-
-```json
-{ "question": "What MCP tools are available?" }
-```
-
-### 2. Handle refusal
-
-If `refused: true` with `no_context`:
-
-1. Retry `search_docs` with shorter keywords
-2. `read_doc` on the best slug
-3. If still empty — tell the user docs did not cover it; do not invent
-
-### 3. Deepen with read_doc
-
-When the user needs exhaustive tables (e.g. all MCP tools):
-
-```json
-{ "slug": "mcp/tools" }
-```
-
-After `ask_docs` gave a summary.
-
-## Example questions → ask_docs
-
-| User asks | ask_docs question |
-|---|---|
-| How to install Memtrace? | `"How do I install Memtrace?"` |
-| What is Rail? | `"What is Memtrace Rail and how do I enable it?"` |
-| Enterprise MemDB on Azure | `"How do I deploy self-hosted MemDB on Azure?"` |
-| How to connect local memtrace to shared MemDB | `"How do engineers connect with memtrace connect?"` |
-| What skills exist? | `"What agent skills does Memtrace ship?"` |
-
-## Privacy note
-
-`ask_docs` sends the **question string** to memtrace.io, which runs retrieval and
-calls a hosted LLM (DeepSeek) server-side. No repo source code is transmitted.
-Do not paste secrets into questions.
-
-## Offline behavior
-
-`ok: false` → network or API error. Quote the `error` and `hint` fields; suggest
-checking connectivity or `MEMTRACE_DOCS_API_URL`.

package/installer/skills/commands/memtrace-docs-read.md

@@ -1,91 +0,0 @@
----
-name: memtrace-docs-read
-description: "Read the full plain-text body of an official Memtrace docs page by slug. Use when you know the page path (from search_docs, ask_docs citations, or user link) and need complete content — CLI reference, enterprise deploy guide, MCP tool tables. Calls read_doc or memtrace://docs/* resources on memtrace.io."
-allowed-tools:
-  - mcp__memtrace__read_doc
-  - mcp__memtrace__search_docs
-metadata:
-  author: "Syncable <support@syncable.dev>"
-  version: "1.0.0"
-  category: development
----
-
-## Overview
-
-`read_doc` fetches the full rendered text of one docs page. Use after `search_docs`
-or `ask_docs` when excerpts are not enough — long flag tables, deploy runbooks,
-MCP tool inventories.
-
-Alternative: MCP resource `memtrace://docs/<slug>` via `read_resource` if your
-client prefers resources over tools.
-
-Umbrella routing: `memtrace-docs` workflow.
-
-## `read_doc` parameters
-
-| Param | Required | Notes |
-|---|---|---|
-| `slug` | yes | Path without `/docs/` prefix |
-
-```json
-{ "slug": "enterprise/memdb-deploy" }
-```
-
-Valid examples:
-
-- `getting-started`
-- `cli/start`
-- `mcp/tools`
-- `enterprise/connect`
-- `cli/rail` (hidden from sidebar but indexed)
-
-## Response shape
-
-```json
-{
-  "ok": true,
-  "slug": "enterprise/memdb-deploy",
-  "title": "Deploy MemDB",
-  "body": "…full plain text…"
-}
-```
-
-## Steps
-
-### 1. Resolve slug
-
-From user URL `https://memtrace.io/docs/cli/connect` → slug `cli/connect`.
-
-From `ask_docs` citations array → use slug directly.
-
-From unknown topic → `search_docs` first, then `read_doc` on top hit.
-
-### 2. Read and summarize
-
-Read the `body`, answer the user, keep `/docs/<slug>` links when citing.
-
-### 3. Multi-page topics
-
-Enterprise deploy + engineer connect:
-
-```json
-{ "slug": "enterprise/memdb-deploy" }
-```
-
-then
-
-```json
-{ "slug": "enterprise/connect" }
-```
-
-## When NOT to use read_doc
-
-| Situation | Use instead |
-|---|---|
-| User asked a natural-language question | `ask_docs` first |
-| You don't know which page | `search_docs` first |
-| User's **source code** in their repo | `memtrace-search` / `memtrace-first` |
-
-## Offline behavior
-
-`ok: false` → docs API unreachable. Do not substitute local README guesses.

package/installer/skills/commands/memtrace-docs-search.md

@@ -1,94 +0,0 @@
----
-name: memtrace-docs-search
-description: "Search official Memtrace documentation with semantic full-text search. Use when the user wants to find doc pages, locate a guide, or discover which docs cover a topic (fleet, MCP, CLI, enterprise MemDB, skills). Calls search_docs on memtrace.io. Do not grep local files or web-search for Memtrace product docs."
-allowed-tools:
-  - mcp__memtrace__search_docs
-  - mcp__memtrace__read_doc
-metadata:
-  author: "Syncable <support@syncable.dev>"
-  version: "1.0.0"
-  category: development
----
-
-## Overview
-
-`search_docs` queries the hosted Memtrace docs corpus (same index as memtrace.io/docs
-and the Ask AI widget). Returns ranked **chunks** — not full pages. Follow with
-`read_doc` when you need the complete page.
-
-Umbrella routing: `memtrace-docs` workflow.
-
-## Quick Reference
-
-| Tool | Best for |
-|------|----------|
-| `search_docs` | Find which doc pages/sections match a topic |
-| `read_doc` | Load full page text after search hits |
-
-## `search_docs` parameters
-
-| Param | Required | Default | Notes |
-|---|---|---|---|
-| `query` | yes | — | Natural-language search string |
-| `limit` | no | 8 | Max chunks to return |
-
-```json
-{ "query": "deploy MemDB helm azure", "limit": 8 }
-```
-
-## Steps
-
-### 1. Search
-
-```json
-{ "query": "memtrace rail enable hook", "limit": 6 }
-```
-
-### 2. Inspect results
-
-Each hit includes:
-
-```json
-{
-  "slug": "cli/rail",
-  "pageTitle": "memtrace rail & route",
-  "h2Title": "Subcommands",
-  "h2Id": "enable-sub",
-  "excerpt": "…",
-  "distance": 0.12
-}
-```
-
-Lower `distance` ≈ better match.
-
-### 3. Read full pages when needed
-
-```json
-{ "slug": "cli/rail" }
-```
-
-Slug uses forward slashes: `enterprise/memdb-deploy`, `mcp/tools`, `getting-started`.
-
-## Common slugs
-
-| Topic | Slug |
-|---|---|
-| Getting started | `getting-started` |
-| MCP tools list | `mcp/tools` |
-| MCP docs tools | `mcp/docs-tools` |
-| Agent skills | `mcp/skills` |
-| Deploy MemDB (enterprise) | `enterprise/memdb-deploy` |
-| Connect to shared MemDB | `enterprise/connect` |
-| memtrace connect CLI | `cli/connect` |
-| Rail | `cli/rail` |
-
-## Offline behavior
-
-If `ok: false`, the docs API is unreachable. Report the error; do not fall back to
-hallucinated documentation. Local code-graph tools are unaffected.
-
-## Hand off
-
-- Natural-language "how do I…" → `memtrace-docs-ask` (`ask_docs`) instead
-- Found the right slug → `memtrace-docs-read` (`read_doc`)
-- User's **source code** → `memtrace-first` / `memtrace-search` (different corpus)

package/installer/skills/commands/memtrace-intent-verification.md

@@ -1,81 +0,0 @@
----
-name: memtrace-intent-verification
-description: "Verify whether a past decision actually held or was violated, and surface the arc of episodes that implemented that specific decision. Returns a Held | ViolatedAt | CannotProve verdict and the implementing arc from Cortex decision memory. Use when the user asks whether a decision held, was followed, or drifted, or before relying on a decision or reporting drift. Requires a decision_id (from memtrace-decision-recall); do NOT use for free-text decision lookup — use memtrace-decision-recall first. Do not assume a decision was followed; verify it."
-allowed-tools:
-  - mcp__memtrace__verify_intent
-  - mcp__memtrace__get_arc
-  - mcp__memtrace__recall_decision
-  - mcp__memtrace__why_is_this_here
-metadata:
-  author: "Syncable <support@syncable.dev>"
-  version: "1.0.0"
-  category: development
----
-
-## Overview
-
-A decision being *recorded* doesn't mean it was *followed*. `verify_intent` checks
-whether a decision held across its arc; `get_arc` returns the episodes that implemented
-it. Use these to confirm a rationale is still in force before relying on it, and to
-detect drift where the code quietly diverged from what was decided.
-
-Full parameter spec for every Memtrace tool: `references/mcp-parameters.md` (bundled at the memtrace-skills plugin root).
-
-## Quick Reference
-
-| Tool | Purpose | Returns / FactStatus |
-|------|---------|----------------------|
-| `verify_intent` | Did the decision hold across its arc? | `Held` \| `ViolatedAt` \| `CannotProve` |
-| `get_arc` | Arc of episodes implementing the decision | DeterministicallyDerived \| CannotProve |
-
-> **Both take a `decision_id` (uint64), not free text.** Get it from `recall_decision`
-> (see `memtrace-decision-recall`) or from `why_is_this_here` (see `memtrace-provenance`).
-> Do not invent ids.
-
-> **Honesty contract:** verdicts are deterministically defended. `CannotProve` means the
-> decision is invisible or has no implementing episode — *unknown*, not "fine."
-
-## Steps
-
-### 1. Get the decision_id
-
-Run `recall_decision(...)` and take a `decision_id` from a hit, or get one from
-`why_is_this_here(symbol_id)`. These tools do not accept names.
-
-### 2. Verify it held
-
-`verify_intent(decision_id)`:
-
-| Verdict | Meaning | Action |
-|---|---|---|
-| **Held** | The decision held across its arc | Safe to rely on; honor it |
-| **ViolatedAt** | The code drifted from the decision at a point | Surface the drift — it's either a bug or an unrecorded reversal; ask which |
-| **CannotProve** | Decision invisible or no implementing episode | Treat as unknown; don't claim it held |
-
-### 3. Inspect what implemented it
-
-`get_arc(decision_id)` → the episodes reachable by Produced/DerivedFrom edges. This is
-the implementation trail: where the decision actually landed (or where it should have).
-
-### 4. Cross to the code graph for the "what"
-
-The arc names episodes/symbols; to see the current code or its blast radius, hand those
-over to `memtrace-first` / `memtrace-impact`. Decision memory proves *whether it held*;
-the code graph shows *the current state*.
-
-## Decision Points
-
-| Situation | Action |
-|-----------|--------|
-| Relying on a recalled decision for a choice | `verify_intent` first — only trust a `Held` verdict |
-| Auditing whether the codebase follows its own decisions | `verify_intent` per decision; report every `ViolatedAt` |
-| "Where/when was decision D implemented?" | `get_arc(decision_id)` |
-| `verify_intent` returns `ViolatedAt` | Don't silently 'fix' it — it may be a deliberate (unrecorded) reversal; confirm with the user |
-| `verify_intent` returns `CannotProve` | Treat as unknown; fall back to `recall_decision` + the code graph |
-
-## Output
-
-| Call | Returns |
-|------|---------|
-| `verify_intent(decision_id)` | Verdict: `Held` \| `ViolatedAt` (the point where code drifted from the decision) \| `CannotProve` (decision invisible or no implementing episode — unknown, not "fine") |
-| `get_arc(decision_id)` | FactStatus `DeterministicallyDerived` \| `CannotProve`, plus the implementing arc: the episodes reachable by Produced/DerivedFrom edges |

package/installer/skills/commands/memtrace-provenance.md

@@ -1,93 +0,0 @@
----
-name: memtrace-provenance
-description: "Retrieve the governing decision lineage (why is this here) and contracts that bind a symbol from Cortex decision memory through the normal Memtrace MCP server. Use before deleting, rewriting, refactoring, or 'cleaning up' existing code that looks unused, odd, redundant, legacy, or policy-sensitive, and when the user asks why a symbol exists or what rules constrain it. Symbol-scoped; for free-text decision search use memtrace-decision-recall first. Do not infer intent from the diff or assume unfamiliar code is safe to remove."
-allowed-tools:
-  - mcp__memtrace__why_is_this_here
-  - mcp__memtrace__governing_contracts
-  - mcp__memtrace__verify_intent
-  - mcp__memtrace__recall_decision
-metadata:
-  author: "Syncable <support@syncable.dev>"
-  version: "1.0.0"
-  category: development
----
-
-## Overview
-
-Provenance answers **"why is this code here, and what binds it?"** before you change
-it. `why_is_this_here` returns the decision/conversation lineage that governs a symbol
-(its Governs/Produced provenance); `governing_contracts` returns the contract nodes
-that constrain it. Together they stop you from deleting code that closes a past issue
-or violating an invariant nothing in the AST advertises.
-
-Full parameter spec for every Memtrace tool: `references/mcp-parameters.md` (bundled at the memtrace-skills plugin root).
-
-## Quick Reference
-
-| Tool | Purpose | Returns / FactStatus |
-|------|---------|----------------------|
-| `why_is_this_here` | The governing decision/conversation lineage of a symbol | DeterministicallyDerived \| CannotProve |
-| `governing_contracts` | The contract nodes that constrain a symbol | Contract nodes \| CannotProve |
-| `verify_intent` | Given a returned governing `decision_id` — is that rationale still valid? | Held \| ViolatedAt \| CannotProve |
-
-> **`why_is_this_here` and `governing_contracts` each take a `symbol_id` (uint64 node
-> id), not a name. `verify_intent` takes a `decision_id` (uint64), not a `symbol_id`.**
-> If you only have a name or a question, start with `recall_decision` (free text) — see
-> `memtrace-decision-recall`. ids come from a prior recall/arc result or the Cortex
-> view. Do not invent ids.
-
-> **Honesty contract:** for a symbol no decision produced, `why_is_this_here` returns an
-> honest **CannotProve**; `governing_contracts` returns CannotProve rather than a false
-> "no contracts" verdict. **CannotProve ≠ safe to delete / unconstrained** — it means
-> *unknown*, so fall back to blast-radius and the user.
-
-## Steps
-
-### 1. Get the symbol_id
-
-If you have a name or a "why" question, run `recall_decision(...)` first and take the
-`symbol_id` from the result if present, or use the id returned by a graph/Cortex view.
-The id-based tools need a numeric id. If you cannot get a symbol id, do not skip
-decision memory entirely: use `recall_decision("<symbol/subsystem/behavior>")` and
-report any matching decision/bans before changing the code.
-
-### 2. Ask why it's here
-
-`why_is_this_here(symbol_id)` → the governing decision lineage. This is the *rationale*
-the git blame won't give you: the decision that produced this code and, often, the
-problem it was put there to solve.
-
-### 3. Ask what constrains it
-
-`governing_contracts(symbol_id)` → contracts that must survive any rewrite (invariants,
-interface promises, "must always …" rules). A refactor that breaks one of these is a
-regression even if every test passes.
-
-### 4. Check the rationale still holds
-
-If `why_is_this_here` returns a governing `decision_id`, run `verify_intent(decision_id)`
-(see `memtrace-intent-verification`) — a `ViolatedAt` verdict (or a decision you can see
-was superseded via `recall_decision`) changes whether the code should still look this way.
-
-## Decision Points
-
-| Situation | Action |
-|-----------|--------|
-| Code looks unused/dead and you want to delete it | `why_is_this_here` + `governing_contracts` BEFORE deleting; CannotProve is not a green light |
-| Code is written in a strange/non-obvious way | `why_is_this_here` if you have a symbol id; otherwise `recall_decision` for the symbol/subsystem |
-| About to refactor a symbol's internals | `why_is_this_here` + `governing_contracts` — preserve the rationale and every constraint, not just the test surface |
-| User asks "why is this here?" | `why_is_this_here(symbol_id)`; if you only have a name, `recall_decision` first |
-| All provenance returns CannotProve | Treat as unknown; combine with `memtrace-impact` (blast radius) and ask the user before removing |
-
-## Output
-
-```text
-why_is_this_here(symbol_id: 4821)
-→ DeterministicallyDerived — governing lineage:
-   decision_id 913 (Governs): "Keep retry shim until legacy clients migrate"
-governing_contracts(symbol_id: 4821)
-→ contract node: "writes must always be debounced" (must survive any rewrite)
-— no decision produced the symbol → CannotProve (unknown, NOT unconstrained)
-```
-
-`verify_intent(decision_id)` on a returned lineage id yields Held | ViolatedAt | CannotProve.

package/installer/skills/workflows/memtrace-fleet-coordination.md

@@ -1,107 +0,0 @@
----
-name: memtrace-fleet-coordination
-description: "Resolve fleet conflicts between coordinated agents: what conflict class A/B/C means, how a Class C destructive overlap gets decided (by an agent judge or a human), how to be the judge (fleet_submit_verdict), how to read your directive after a decision, and how branch-scoping isolates fleets. Use when the user says 'two agents are changing the same thing', 'resolve this conflict', 'who should proceed', 'a decision is waiting', or asks you to act as a mediator between agents. This skill explains the conflict model and decision loop; for just the verdict/directive/resolution tool calls on a specific escalation, use memtrace-fleet-resolve."
-allowed-tools:
-  - mcp__memtrace__fleet_record_episode
-  - mcp__memtrace__fleet_submit_verdict
-  - mcp__memtrace__fleet_get_escalation
-  - mcp__memtrace__fleet_list_escalations
-  - mcp__memtrace__fleet_resolve_escalation
-  - mcp__memtrace__fleet_get_node_state
-metadata:
-  author: "Syncable <support@syncable.dev>"
-  version: "1.0.0"
-  category: development
----
-
-# Fleet Coordination
-
-How the fleet turns overlapping edits into a safe decision. Read
-`memtrace-fleet-first` for the publish→edit→record protocol; this skill is the
-*conflict resolution* half.
-
-## Conflict classes (what `fleet_record_episode` returns)
-
-| Class | Meaning | What to do |
-|---|---|---|
-| **A** | Additive, order-independent | Proceed. |
-| **B** | Non-destructive overlap with another agent's work | Re-read the shared symbols, then proceed. |
-| **C** | A **destructive** change (signature change / move / dead-code removal) overlaps another agent's work | A decision is needed — it does NOT auto-resolve. |
-
-Class is computed **only against agents on your branch** (`(repo, branch)`).
-Agents on other branches are never conflict peers.
-
-## The Class C decision loop
-
-When `fleet_record_episode` returns class C it also returns an `escalation_id` and
-(when mediation is on) a `mediation_request`. The decision is made by an **agent
-judge**, a **human**, or — only when provably safe — the **deterministic referee**.
-
-### Being the judge (the user's own agent does the judging — no API keys)
-
-The `mediation_request` bundles **every agent's `assignment`** plus the contested
-symbols. Read the *other* agent's task and decide on merit (including against your
-own change). Submit:
-
-```jsonc
-fleet_submit_verdict({
-  escalation_id: "01J…",
-  agent_id: "agent-a",
-  verdict: { "kind": "recommend", "winner": "agent-b",
-             "rationale": "the signature change is the wider contract; rebase the fix onto it",
-             "confidence": 0.8 }
-})
-```
-
-Verdict kinds: `reconcile {merge_plan}` · `recommend {winner, rationale, confidence}`
-· `defer_to_human {question}`.
-
-Full parameter spec for every Memtrace tool: `references/mcp-parameters.md` (bundled at the memtrace-skills plugin root).
-
-The referee then decides the outcome:
-- **Auto-apply** only when safe: the clear machine case, or ≥2 independent agents
-  agree — and **never** for a destructive *removal* (delete/move), which always
-  needs a human.
-- **Human confirm** — a recommendation is surfaced for one-click confirmation.
-- **Human required** — both sides destructive, agents disagree, or an agent
-  deferred → a person decides.
-
-### Reading your directive
-
-Poll `fleet_get_escalation({escalation_id, agent_id})` until `your_directive` ≠
-`wait`: `proceed` (you continue), `defer` (stand down / rebase onto the winner),
-`review` (read `resolution`).
-
-### Resolving as a human (or on a human's behalf via the dashboard)
-
-`fleet_resolve_escalation({escalation_id, resolution, winner})` records a human
-decision and clears the queue. Prefer the agent-judge path; use this for the
-genuine human-decision cases. `fleet_list_escalations({repo_id})` shows the
-"needs human" queue.
-
-## Why branch-scoping matters here
-
-A "winner / defer" only makes sense on a shared surface. Across branches, the
-loser can't defer (its branch needs the change too), so the fleet never escalates
-cross-branch — that's a merge-time concern git already owns. Keep your fleet to
-one session branch and conflicts stay real and resolvable.
-
-## Inspecting state
-
-`fleet_get_node_state({repo_id, node})` — recent episodes, active intents, dominant
-intent, and conflict density for one symbol. Use it to understand pressure on a
-hot symbol before you pile on.
-
-## Output
-
-`fleet_record_episode` on a destructive overlap, then `fleet_get_escalation` once decided:
-
-```jsonc
-// fleet_record_episode
-{ "conflict_class": "C", "escalation_id": "01J…",
-  "mediation_request": { /* every agent's assignment + the contested symbols */ } }
-
-// fleet_get_escalation — poll until your_directive ≠ "wait"
-{ "your_directive": "defer",
-  "resolution": "recommend: agent-b — rebase the fix onto the signature change" }
-```