memtrace 0.8.62 → 1.0.0

package/skills/workflows/memtrace-decision-memory.md

@@ -1,6 +1,6 @@
 ---
 name: memtrace-decision-memory
-description: "Check Cortex decision memory through the normal Memtrace MCP tools — the umbrella entry point for decision recall, provenance (why is this here), intent verification, and governing contracts. Use before assuming WHY code exists, before any non-trivial edit/refactor/delete of existing code, before re-picking a library/pattern/architecture, or before contradicting an apparent convention. Route: free-text decisions/bans/conventions → memtrace-decision-recall; symbol lineage/contracts → memtrace-provenance; did the decision hold → memtrace-intent-verification. Do not guess rationale from the diff or git log."
+description: "Use Cortex decision memory through the normal Memtrace MCP tools. Trigger for free-text questions about what was decided, chosen, rejected, banned, or established as a convention; for why a symbol exists or which contracts constrain it; for whether a known decision held, drifted, or was violated; and for the implementation arc behind a decision. Use before non-trivial edits, refactors, deletions, or re-picking a library, pattern, architecture, or subsystem behavior. Routes internally across recall_decision, why_is_this_here, governing_contracts, verify_intent, and get_arc. Do not guess rationale from a diff or git log."
 allowed-tools:
   - mcp__memtrace__recall_decision
   - mcp__memtrace__why_is_this_here
@@ -63,16 +63,16 @@ with `memtrace-first`; do not fabricate decisions.
 
 ## The decision rule
 
-| What you're about to do / be asked | Right tool | Sub-skill |
+| What you're about to do / be asked | Right tool | Procedure |
 |---|---|---|
-| "Did we already decide/choose/reject X?" "What's our convention on Y?" | `recall_decision("X")` | `memtrace-decision-recall` |
-| "Is there a ban / a 'don't do this' on Z?" | `recall_decision("Z")` — bans surface as decisions | `memtrace-decision-recall` |
-| About to edit behavior, re-pick a library/pattern/architecture, or change a subsystem policy | `recall_decision` FIRST — don't re-litigate a settled call | `memtrace-decision-recall` |
-| "Why is this code here?" "Why is it done this odd way?" | `why_is_this_here(symbol_id)` | `memtrace-provenance` |
-| About to delete/refactor/clean up existing code, especially odd or "dead" code | `why_is_this_here` + `governing_contracts` before touching it | `memtrace-provenance` |
-| "What rules/contracts constrain this symbol?" | `governing_contracts(symbol_id)` | `memtrace-provenance` |
-| "Did decision D actually hold, or did we drift?" | `verify_intent(decision_id)` | `memtrace-intent-verification` |
-| "What commits/episodes implemented decision D?" | `get_arc(decision_id)` | `memtrace-intent-verification` |
+| "Did we already decide/choose/reject X?" "What's our convention on Y?" | `recall_decision("X")` | Free-text recall |
+| "Is there a ban / a 'don't do this' on Z?" | `recall_decision("Z")` — bans surface as decisions | Free-text recall |
+| About to edit behavior, re-pick a library/pattern/architecture, or change a subsystem policy | `recall_decision` FIRST — don't re-litigate a settled call | Free-text recall |
+| "Why is this code here?" "Why is it done this odd way?" | `why_is_this_here(symbol_id)` | Symbol provenance |
+| About to delete/refactor/clean up existing code, especially odd or "dead" code | `why_is_this_here` + `governing_contracts` before touching it | Symbol provenance |
+| "What rules/contracts constrain this symbol?" | `governing_contracts(symbol_id)` | Symbol contracts |
+| "Did decision D actually hold, or did we drift?" | `verify_intent(decision_id)` | Intent verification |
+| "What commits/episodes implemented decision D?" | `get_arc(decision_id)` | Implementation arc |
 
 ## How the tools chain (ids come from recall, not from names)
 
@@ -136,8 +136,8 @@ The routing outcome: which sibling skill/tool to invoke, and the evidence to quo
 
 ```
 Ask:    "Should I switch to library X?"
-Route:  recall_decision("library X")   →  memtrace-decision-recall
+Route:  recall_decision("library X")   →  free-text recall
 Hit:    { id: 4217, kind: "decision", ... }   (a ban exists)
-Next:   verify_intent(4217)            →  memtrace-intent-verification
+Next:   verify_intent(4217)            →  intent verification
 Quote:  Verdict + Evidence (FactStatus, proof path) — or CannotProve = unknown, not permission
 ```

package/skills/workflows/memtrace-docs.md

@@ -1,6 +1,6 @@
 ---
 name: memtrace-docs
-description: "Route Memtrace product documentation questions to the hosted docs MCP tools before guessing, searching the web, or reading stale local copies. Use when the user asks how Memtrace works, how to install/configure CLI/MCP/fleet/Cortex/enterprise MemDB, what tools or skills exist, what a command does, or wants the agent to read up on official docs. Calls search_docs, ask_docs, or read_doc on memtrace.io (override with MEMTRACE_DOCS_API_URL). Do not hallucinate Memtrace behavior — query docs first. Separate from memtrace-first (your repo's code graph)."
+description: "Use official hosted Memtrace documentation before guessing, web search, or stale local copies. Trigger when the user asks how Memtrace works; how to install, configure, or deploy CLI, MCP, fleet, Cortex, or enterprise MemDB; what tools, skills, or commands exist; wants to find or locate official docs for a topic; or provides/asks to read a full docs page or slug. Routes internally across ask_docs for cited natural-language answers, search_docs for page discovery, and read_doc for complete page text. Separate from memtrace-first, which searches the user's indexed source code."
 allowed-tools:
   - mcp__memtrace__search_docs
   - mcp__memtrace__ask_docs
@@ -45,15 +45,15 @@ Override API host: `MEMTRACE_DOCS_API_URL` (default `https://memtrace.io`).
 
 ## The decision rule
 
-| User is asking | Right tool | Sub-skill |
+| User is asking | Right tool |
 |---|---|---|
-| "How do I install / configure / deploy X in Memtrace?" | `ask_docs(question=…)` | `memtrace-docs-ask` |
-| "What MCP tools / skills / CLI commands exist?" | `ask_docs` or `search_docs` then `read_doc` on hit slugs | `memtrace-docs-ask` / `memtrace-docs-search` |
-| "What does `memtrace rail enable` do?" | `ask_docs` | `memtrace-docs-ask` |
-| "Find docs about fleet coordination" | `search_docs(query=…)` | `memtrace-docs-search` |
-| "Read the full getting-started page" | `read_doc(slug="getting-started")` | `memtrace-docs-read` |
-| "Read enterprise MemDB deploy guide" | `read_doc(slug="enterprise/memdb-deploy")` | `memtrace-docs-read` |
-| Need several related sections | `search_docs` → `read_doc` on top slugs | `memtrace-docs-search` + `memtrace-docs-read` |
+| "How do I install / configure / deploy X in Memtrace?" | `ask_docs(question=…)` |
+| "What MCP tools / skills / CLI commands exist?" | `ask_docs` or `search_docs` then `read_doc` on hit slugs |
+| "What does `memtrace rail enable` do?" | `ask_docs` |
+| "Find docs about fleet coordination" | `search_docs(query=…)` |
+| "Read the full getting-started page" | `read_doc(slug="getting-started")` |
+| "Read enterprise MemDB deploy guide" | `read_doc(slug="enterprise/memdb-deploy")` |
+| Need several related sections | `search_docs` → `read_doc` on top slugs |
 
 **Default for natural-language questions:** `ask_docs` — it retrieves context and
 returns a cited answer in one call.
@@ -88,6 +88,41 @@ if you need the full page.
 2. Follow-up `read_doc(slug="enterprise/memdb-deploy")` for operator steps
 3. Engineer connect → `read_doc(slug="enterprise/connect")` or `cli/connect`
 
+## Tool procedures
+
+### ask_docs — cited answers
+
+Pass the user's question verbatim when it is already clear:
+
+```json
+{ "question": "How do I deploy MemDB with Docker Compose?" }
+```
+
+The response is `{ ok, answer, citations[], refused, refusalReason? }`. If
+`refused: true` with `no_context`, retry `search_docs` with shorter keywords and
+then `read_doc` on the best slug. `ask_docs` sends only the question string to
+memtrace.io's hosted RAG service; do not include secrets or repo source.
+
+### search_docs — page discovery
+
+```json
+{ "query": "deploy MemDB helm azure", "limit": 8 }
+```
+
+Results are ranked chunks with `slug`, `pageTitle`, `h2Title`, `excerpt`, and
+`distance` (lower is a better match). They are not full pages. Follow with
+`read_doc` when you need the complete reference.
+
+### read_doc — complete page text
+
+```json
+{ "slug": "enterprise/memdb-deploy" }
+```
+
+Use a slug from a user URL, `ask_docs` citations, or `search_docs` results. The
+response is `{ ok, slug, title, body }`. For multi-page topics, read each slug you
+will rely on rather than extrapolating from one page.
+
 ## Red flags — STOP, use docs tools
 
 | Thought | Reality |
@@ -121,9 +156,3 @@ read_doc → { ok: true, slug, title, body }
 
 When `refused: true`, tell the user the docs did not cover it and suggest browsing
 https://memtrace.io/docs or rephrasing.
-
-## Sub-skills
-
-- Discovery / chunk search → `memtrace-docs-search`
-- Grounded Q&A → `memtrace-docs-ask`
-- Full page read → `memtrace-docs-read`

package/skills/workflows/memtrace-fleet-first.md

@@ -1,6 +1,6 @@
 ---
 name: memtrace-fleet-first
-description: "Coordinate fleets of coding agents sharing one repo+branch: declare typed intents, classify edit episodes, and resolve conflicts before they collide. Use FIRST when more than one coding agent works the same repo+branch at once (a 'fleet'), before reading code, planning a refactor, or making an edit — triggered by 'I'm about to edit X', 'rename Y across the codebase', joining a running fleet/session branch, coordinating with other agents, or prose hand-offs. Do not grep for 'who else is touching this' and do not skip fleet_publish_intent because 'it's a small change'. Fleet coordination is branch-scoped: pass your session branch so your fleet coordinates and stays isolated from agents on other branches. Skip ONLY for genuinely solo sessions or pure docs-only edits where coordination has zero value."
+description: "Coordinate fleets of coding agents sharing one repo+branch: publish typed intents, classify edit episodes, and resolve conflicts before they collide. Use FIRST when multiple agents work the same repo+branch, before reading/planning/editing, when joining a fleet or handing work off, and when the user says two agents are changing the same thing, asks who should proceed, has a decision waiting, or asks you to mediate a Class C conflict. Covers branch-scoped publish-edit-record plus verdict, human-resolution, and directive polling. Do not grep for who else is touching a symbol or skip coordination because a change looks small. Skip only genuinely solo sessions or docs-only edits with no coordination value."
 allowed-tools:
   - mcp__memtrace__fleet_status
   - mcp__memtrace__fleet_branch_context
@@ -128,6 +128,8 @@ degrades to "a human reviews a suggestion," never a silent bad merge.
 | Finish an edit | `fleet_record_episode` (get A/B/C) |
 | Got a Class C as the judge | `fleet_submit_verdict` (reconcile/recommend/defer) |
 | Blocked on a Class C | poll `fleet_get_escalation` until `your_directive ≠ wait` |
+| A human chose the outcome | `fleet_resolve_escalation` (record the decision) |
+| See the needs-human queue | `fleet_list_escalations` |
 | See who's in the fleet | `fleet_status` (active_agents, pending decisions) |
 | Inspect a symbol's coordination state | `fleet_get_node_state` |
 

package/skills/workflows/memtrace-refactoring-guide.md

@@ -35,7 +35,7 @@ Run these three tools in parallel to build a candidate list:
 Call `find_most_complex_functions` with `top_n: 20`
 
 **b) Dead code:**
-Call `find_dead_code` to find unused symbols
+Call `find_dead_code` (prefer `min_confidence: "high"`) for symbols unreachable from roots
 
 **c) Architectural bottlenecks:**
 Call `find_bridge_symbols` to find chokepoints with too much responsibility
@@ -122,7 +122,7 @@ For each item, include:
 |-----------|--------|
 | Complex + volatile + high blast radius | Highest priority — but plan carefully; incremental approach |
 | Complex + stable + low blast radius | Can wait; refactor when you're already touching nearby code |
-| Dead code with zero callers | Run Cortex provenance/recall first; zero callers is not proof that no decision/contract keeps it |
+| Dead code (`unreachable from roots`, high confidence) | Run Cortex provenance/recall first; reachability is not proof that no decision/contract keeps it |
 | Bridge symbol with many dependents | Extract interface first, then refactor implementation behind it |
 | Symbol in cross-repo API | Coordinate with consumers; backward-compatible changes only |
 | Cortex returns a held ban/contract | Preserve it or ask before overriding it |

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 |