@dug-21/unimatrix 0.5.9 → 0.6.0

package/protocols/uni-design-protocol.md

@@ -0,0 +1,379 @@
+# Design Session Protocol (Session 1)
+
+Triggers on: specification, architecture, design, research, scope, risk strategy, SCOPE.md creation.
+
+---
+
+## Execution Model
+
+Session 1 produces three sacred source-of-truth documents, a scope risk assessment, a vision alignment report, an implementation brief, and an acceptance map. All artifacts land in `product/features/{feature-id}/` as untracked files — no git operations occur during design. Session 2 (Delivery) creates the feature branch, commits the design artifacts, and continues from there.
+
+**You are the Design Leader.** Read the SM agent definition (`.claude/agents/uni/uni-scrum-master.md`) for role boundaries. You orchestrate — you NEVER generate content. Spawn specialist agents for all work.
+
+```
+Design Leader (you)                                  Design Agents
+───────────────────                                  ─────────────
+read protocol + SCOPE.md (or initiate)
+spawn researcher (Phase 1) ─────────────────────────► SCOPE.md written
+◄────────────────────────────────────────────────────
+human approves SCOPE.md
+spawn risk strategist (Phase 1b) ───────────────────► scope risk assessment
+◄────────────────────────────────────────────────────
+spawn 2 specialists (Phase 2a) ─────────────────────► produce arch + spec
+◄────────────────────────────────────────────────────
+spawn risk strategist (Phase 2a+) ──────────────────► produce risk strategy
+◄────────────────────────────────────────────────────
+spawn vision guardian (Phase 2b)
+spawn synthesizer (Phase 2c)
+return all artifacts to human
+human reviews and approves
+```
+
+**Session 1 ends when artifacts are returned to the human.** The human decides whether to proceed to Session 2 (Delivery).
+
+### Concurrency Rules
+
+Each message batches ALL related operations of the same type:
+
+- ALWAYS spawn all agents WITHIN each phase step in ONE message via Task tool
+- ALWAYS batch ALL file reads/writes/edits in ONE message
+
+### Design Rules
+
+- Output goes to `product/features/{feature-id}/` ONLY
+- NO code changes. NO file edits outside `product/features/`
+- NO launching delivery agents (uni-rust-dev, uni-pseudocode, uni-tester)
+- Agents return: artifact paths + key decisions + open questions (NOT full file contents)
+
+### No Git Operations in Design
+
+Design produces artifacts in `product/features/{feature-id}/` only. No branch is created, no commits are made, no PR is opened. The working tree stays on whatever branch is currently checked out. Git operations begin in Session 2 (Delivery), which creates the feature branch and commits the design artifacts as its first action.
+
+### Feature Cycle Attribution
+
+Before spawning any agents, call `context_cycle` to declare the feature cycle:
+
+```
+context_cycle(
+  type: "start",
+  topic: "{feature-id}",
+  next_phase: "scope",
+  agent_id: "{feature-id}-design-leader"
+)
+```
+
+This sets session-level feature attribution so all subsequent tool calls are tracked against this feature.
+
+---
+
+## Flow: Phase 1 + Phase 2
+
+### Phase 1: Research & Scope Definition
+
+**Participants**: Human + uni-researcher
+
+The Design Leader spawns `uni-researcher` to collaborate with the human on scope definition.
+
+```
+Task(
+  subagent_type: "uni-researcher",
+  prompt: "You are researching the problem space for {feature-id}.
+    Your agent ID: {feature-id}-researcher
+
+    High-level intent: {human's description}
+
+    Explore the problem space — existing codebase patterns, technical landscape,
+    constraints, and relevant project knowledge.
+
+    Synthesize findings and propose scope boundaries with rationale.
+    Write SCOPE.md to product/features/{feature-id}/SCOPE.md.
+
+    Return: SCOPE.md path, key findings, open questions for human."
+)
+```
+
+After the researcher returns, the Design Leader presents SCOPE.md to the human for review and approval. **Do not proceed to Phase 1b until the human approves SCOPE.md.**
+
+### Phase 1b: Scope Risk Assessment
+
+**Participants**: uni-risk-strategist (scope-risk mode)
+
+After SCOPE.md approval, the Design Leader spawns the risk strategist in scope-risk mode. This surfaces product-level risks (technology bets, dependency risks, scope boundary risks) BEFORE the architect and spec writer begin — so they can design with risk awareness.
+
+```
+Task(
+  subagent_type: "uni-risk-strategist",
+  prompt: "Your agent ID: {feature-id}-agent-0-scope-risk
+    MODE: scope-risk
+
+    Assess scope-level risks for {feature-id}.
+
+    Read these artifacts:
+    - SCOPE.md: product/features/{id}/SCOPE.md
+    - Product vision: product/PRODUCT-VISION.md
+
+    Produce SCOPE-RISK-ASSESSMENT.md at product/features/{id}/SCOPE-RISK-ASSESSMENT.md.
+    Return: file path, risk summary, top 3 risks for architect attention."
+)
+```
+
+Wait for the scope risk assessment to complete before proceeding to Phase 2.
+
+```
+context_cycle(
+  type: "phase-end",
+  topic: "{feature-id}",
+  phase: "scope",
+  outcome: "SCOPE.md approved. Scope risk assessment complete.",
+  next_phase: "design",
+  agent_id: "{feature-id}-design-leader"
+)
+```
+
+### Phase 2: Design (Three Source Documents + Vision + Synthesis)
+
+Phase 2 has five sequential steps: 2a (architect + spec parallel) → 2a+ (risk strategist) → 2b (vision check) → 2c (synthesis) → 2d (return to human).
+
+#### Phase 2a: Architect + Specification (Parallel, ONE message)
+
+The Design Leader spawns two specialists in parallel:
+
+**uni-architect → Architecture** (`architecture/ARCHITECTURE.md` + `ADR-NNN-{name}.md`)
+
+- High-level system design, component breakdown and boundaries
+- How components interact (interfaces, contracts, data flow)
+- Technology decisions with rationale
+- Integration points and dependencies
+- ADRs as individual files in `architecture/`
+- **Store each ADR in Unimatrix** immediately after writing the file — `context_store(category: "decision", topic: "{feature-id}", feature_cycle: "{feature-id}", title: "{ADR title}", tags: ["adr", "{feature-id}"])` — so delivery agents can retrieve decisions via search without reading every ADR file
+
+**uni-specification → Specification** (`specification/SPECIFICATION.md`)
+
+- Functional and non-functional requirements
+- User workflows and use cases
+- Acceptance criteria with verification methods
+- Domain models and ubiquitous language
+- Constraints and dependencies
+
+Each specialist receives:
+1. `Your agent ID: {feature-id}-agent-N-{role}`
+2. Path to approved SCOPE.md
+3. Path to SCOPE-RISK-ASSESSMENT.md (from Phase 1b)
+4. Task description
+
+```
+# Spawn both in ONE message:
+Task(subagent_type: "uni-architect", prompt: "Your agent ID: {id}-agent-1-architect
+    ...
+    Read scope risk assessment: product/features/{id}/SCOPE-RISK-ASSESSMENT.md
+    Address SR-XX risks in your architecture decisions where applicable.
+
+    After writing each ADR file, store it in Unimatrix:
+    context_store(category: 'decision', topic: '{feature-id}', feature_cycle: '{feature-id}',
+      title: '{ADR title}', tags: ['adr', '{feature-id}'], content: '{full ADR content}')
+    ...")
+Task(subagent_type: "uni-specification", prompt: "Your agent ID: {id}-agent-2-spec
+    ...
+    Read scope risk assessment: product/features/{id}/SCOPE-RISK-ASSESSMENT.md
+    Consider SR-XX risks when defining constraints and acceptance criteria. ...")
+```
+
+Wait for BOTH to complete before proceeding to Phase 2a+.
+
+#### Phase 2a+: Risk Strategist (After Architect + Specification)
+
+The Design Leader spawns the risk strategist with the architecture and specification as additional inputs. This allows risk identification against concrete component boundaries, ADRs, acceptance criteria, and domain models — not just the scope.
+
+**uni-risk-strategist → Risk-Based Test Strategy** (`RISK-TEST-STRATEGY.md`)
+
+- Feature-level risk identification — what could fail and impact users
+- Risk-to-testing-scenario mapping
+- Coverage requirements per risk
+- Prioritization by severity and likelihood
+- Integration risks, edge cases, failure modes
+
+The risk strategist receives:
+1. `Your agent ID: {feature-id}-agent-3-risk`
+2. Path to approved SCOPE.md
+3. Paths to architecture and specification artifacts (from Phase 2a)
+4. Task description
+
+```
+Task(
+  subagent_type: "uni-risk-strategist",
+  prompt: "Your agent ID: {id}-agent-3-risk
+    MODE: architecture-risk
+    ...
+    Read these artifacts for context:
+    - SCOPE.md: product/features/{id}/SCOPE.md
+    - Architecture: product/features/{id}/architecture/ARCHITECTURE.md
+    - ADRs: {list ADR file paths from architect's return}
+    - Specification: product/features/{id}/specification/SPECIFICATION.md
+    - Scope Risk Assessment: product/features/{id}/SCOPE-RISK-ASSESSMENT.md
+
+    Use the architecture (component boundaries, integration points, ADRs)
+    and specification (acceptance criteria, domain models, constraints)
+    to inform your risk analysis. Identify risks that are specific to
+    the designed architecture — not generic risks.
+
+    Trace each SR-XX scope risk in the Scope Risk Traceability table."
+)
+```
+
+Wait for the risk strategist to complete before proceeding to Phase 2b.
+
+```
+context_cycle(
+  type: "phase-end",
+  topic: "{feature-id}",
+  phase: "design",
+  outcome: "Architecture, specification, and risk strategy complete.",
+  next_phase: "design-review",
+  agent_id: "{feature-id}-design-leader"
+)
+```
+
+#### Phase 2b: Vision Alignment Check
+
+Spawn `uni-vision-guardian`:
+
+```
+Task(
+  subagent_type: "uni-vision-guardian",
+  prompt: "Your agent ID: {feature-id}-vision-guardian
+
+    Read the product vision: product/PRODUCT-VISION.md
+    Read the three source documents:
+    - product/features/{id}/architecture/ARCHITECTURE.md
+    - product/features/{id}/specification/SPECIFICATION.md
+    - product/features/{id}/RISK-TEST-STRATEGY.md
+    Read the scope: product/features/{id}/SCOPE.md
+    Read the scope risk assessment: product/features/{id}/SCOPE-RISK-ASSESSMENT.md
+
+    Produce ALIGNMENT-REPORT.md at product/features/{id}/ALIGNMENT-REPORT.md.
+    Flag any variances requiring human attention.
+    Return: report path, variance summary."
+)
+```
+
+#### Phase 2c: Synthesizer (Fresh Context Window)
+
+After vision alignment, spawn `uni-synthesizer` with a fresh context window:
+
+```
+Task(
+  subagent_type: "uni-synthesizer",
+  prompt: "You are compiling the implementation brief for {feature-id}.
+    Your agent ID: {feature-id}-synthesizer
+
+    Read these artifacts:
+    - product/features/{id}/SCOPE.md
+    - product/features/{id}/SCOPE-RISK-ASSESSMENT.md
+    - product/features/{id}/specification/SPECIFICATION.md
+    - product/features/{id}/architecture/ARCHITECTURE.md
+    - product/features/{id}/architecture/ADR-*.md (all ADR files)
+    - product/features/{id}/RISK-TEST-STRATEGY.md
+    - product/features/{id}/ALIGNMENT-REPORT.md
+
+    ADR file paths from architect: {list from architect's return}
+    Vision variances: {from vision guardian's return}
+
+    Produce: IMPLEMENTATION-BRIEF.md, ACCEPTANCE-MAP.md, GH Issue.
+    Return: file paths + GH Issue URL."
+)
+```
+
+The synthesizer gets a fresh context window — it reads artifacts directly for higher quality synthesis.
+
+#### Phase 2d: Return to Human
+
+```
+context_cycle(
+  type: "phase-end",
+  topic: "{feature-id}",
+  phase: "design-review",
+  outcome: "Vision aligned. Synthesis complete.",
+  next_phase: "spec",
+  agent_id: "{feature-id}-design-leader"
+)
+```
+
+Then returns to the human:
+
+```
+SESSION 1 COMPLETE — Design artifacts ready for review.
+
+GH Issue: {URL}
+
+Artifacts (untracked — git begins in Session 2):
+- product/features/{feature-id}/SCOPE.md
+- product/features/{feature-id}/SCOPE-RISK-ASSESSMENT.md
+- product/features/{feature-id}/architecture/ARCHITECTURE.md
+- product/features/{feature-id}/specification/SPECIFICATION.md
+- product/features/{feature-id}/RISK-TEST-STRATEGY.md
+- product/features/{feature-id}/ALIGNMENT-REPORT.md
+- product/features/{feature-id}/IMPLEMENTATION-BRIEF.md
+- product/features/{feature-id}/ACCEPTANCE-MAP.md
+
+Vision Alignment: {summary}
+Variances requiring approval: {list or "none"}
+Open questions: {list or "none"}
+
+Human action required: Review design artifacts. Then start Session 2 to deliver.
+```
+
+**Session 1 ends here.** No branch, no commit, no PR — artifacts sit untracked in `product/features/{feature-id}/` until Session 2 picks them up.
+
+---
+
+## Agent Context Budget
+
+Each spawned agent receives:
+- Agent ID
+- Task description (2-3 sentences)
+- SCOPE.md path (agents read it themselves)
+- Specific file paths to read (not file contents)
+
+Do NOT paste full documents into agent prompts. Agents read files themselves.
+
+---
+
+## Quick Reference: Message Map
+
+```
+DESIGN LEADER (you):
+  Init:       context_cycle(type: "start", topic: "{feature-id}", next_phase: "scope", agent_id: "{feature-id}-design-leader")
+  Phase 1:    Task(uni-researcher) — scope exploration with human
+              ...human approves SCOPE.md...
+  Phase 1b:   Task(uni-risk-strategist, MODE: scope-risk) — scope risk assessment
+              ...wait...
+              context_cycle(type: "phase-end", phase: "scope", outcome: "...", next_phase: "design", ...)
+  Phase 2a:   Task(uni-architect) + Task(uni-specification) — parallel, ONE message
+              ...wait for both...
+  Phase 2a+:  Task(uni-risk-strategist, MODE: architecture-risk) — receives arch + spec + scope risks
+              ...wait...
+              context_cycle(type: "phase-end", phase: "design", outcome: "...", next_phase: "design-review", ...)
+  Phase 2b:   Task(uni-vision-guardian) — alignment check
+  Phase 2c:   Task(uni-synthesizer) — brief + maps + GH Issue (fresh context)
+  Phase 2d:   context_cycle(type: "phase-end", phase: "design-review", outcome: "...", next_phase: "spec", ...) — SESSION 1 ENDS
+              return artifacts to human (no git ops — artifacts are untracked)
+```
+
+---
+
+## Outcome Recording
+
+After Phase 2d, record the phase transition (do NOT call `stop` — the cycle remains open for the delivery session):
+
+```
+context_cycle(
+  type: "phase-end",
+  topic: "{feature-id}",
+  phase: "design-review",
+  outcome: "Vision aligned. Synthesis complete.",
+  next_phase: "spec",
+  agent_id: "{feature-id}-design-leader"
+)
+```
+
+The cycle is closed by `context_cycle(type: "stop")` at the end of Session 2 (delivery). If delivery never occurs, the cycle will be drained by GC or `context_status(maintain: true)`.

package/skills/retro/SKILL.md

@@ -26,7 +26,7 @@ Gather all evidence about the shipped feature:
 
 1. **Run retrospective analysis** (if observation data exists):
    ```
-   mcp__unimatrix__context_retrospective(feature_cycle: "{feature-id}")
+   mcp__unimatrix__context_cycle_review(feature_cycle: "{feature-id}")
    ```
    This returns structured data: metrics, hotspots, baseline comparisons, narratives, and recommendations.
 
@@ -36,7 +36,7 @@ Gather all evidence about the shipped feature:
       - `Warning` hotspots → potential lessons or procedure gaps
       - `Info` hotspots → note trends, may not need action
       - Key hotspot types to watch:
-        - `permission_retries` → settings.json allowlist may need updating
+        - `orphaned_calls` → tool invocations with no terminal event — check context overflow or parallel call management
         - `sleep_workarounds` → agents using sleep instead of run_in_background
         - `cold_restart` → context loss after gaps, agents re-reading files
         - `coordinator_respawns` → SM lifetime/handoff issues

package/skills/uni-init/SKILL.md

@@ -10,7 +10,7 @@ description: "Initialize Unimatrix in a repository: append knowledge block to CL
 Before running this skill:
 
 1. **Skill files installed**: Both `uni-init/SKILL.md` and `uni-seed/SKILL.md` must be present in `.claude/skills/` in the target repository.
-2. **MCP server wired** (for `/uni-seed`): The Unimatrix MCP server (`unimatrix-server`) must be running and configured in your Claude Code `settings.json`. This skill (`/uni-init`) does not require MCP, but `/uni-seed` does.
+2. **MCP server wired** (for `/uni-seed`): The Unimatrix MCP server (`unimatrix`) must be running and configured in your Claude Code `settings.json`. This skill (`/uni-init`) does not require MCP, but `/uni-seed` does.
 
 If you need to install the Unimatrix server or wire MCP, consult the installation documentation.
 
@@ -128,8 +128,18 @@ Knowledge engine (MCP server). Makes agent expertise searchable, trustworthy, an
 
 | Skill | When to Use |
 |-------|-------------|
-| `/uni-init` | First-time setup: wire CLAUDE.md and get agent recommendations |
+| `/uni-init` | First-time setup: wire CLAUDE.md and get agent orientation |
 | `/uni-seed` | Populate Unimatrix with foundational repo knowledge |
+| `/uni-store-adr` | After each architectural decision — stores the ADR |
+| `/uni-store-lesson` | After failures and gate rejections — prevents recurrence |
+| `/uni-store-pattern` | When a reusable implementation pattern emerges |
+| `/uni-store-procedure` | When a step-by-step how-to technique evolves |
+| `/uni-knowledge-search` | Semantic search across knowledge before implementing |
+| `/uni-knowledge-lookup` | Deterministic lookup by feature, category, or ID |
+| `/uni-query-patterns` | Query component patterns before designing or coding |
+| `/uni-retro` | Post-merge retrospective — extract and store what was learned |
+| `/uni-review-pr` | PR security review and merge readiness check |
+| `/uni-zero` | Strategic advisor for product evolution and vision alignment |
 
 ### Knowledge Categories
 

package/skills/uni-knowledge-lookup/SKILL.md

@@ -34,27 +34,27 @@ Call the `mcp__unimatrix__context_lookup` MCP tool:
 
 **Get all ADRs for a specific feature:**
 ```
-mcp__unimatrix__context_lookup(topic: "nxs-002", category: "decision", helpful: true)
+mcp__unimatrix__context_lookup({"topic": "nxs-002", "category": "decision", "helpful": true})
 ```
 
 **Get a specific entry by ID (full content):**
 ```
-mcp__unimatrix__context_lookup(id: 42, format: "markdown")
+mcp__unimatrix__context_lookup({"id": 42, "format": "markdown"})
 ```
 
 **Find all deprecated decisions:**
 ```
-mcp__unimatrix__context_lookup(category: "decision", status: "deprecated")
+mcp__unimatrix__context_lookup({"category": "decision", "status": "deprecated"})
 ```
 
 **Find entries tagged with a specific domain:**
 ```
-mcp__unimatrix__context_lookup(category: "decision", tags: ["adr", "serialization"])
+mcp__unimatrix__context_lookup({"category": "decision", "tags": ["adr", "serialization"]})
 ```
 
 **Get all knowledge for a feature (any category):**
 ```
-mcp__unimatrix__context_lookup(topic: "vnc-001")
+mcp__unimatrix__context_lookup({"topic": "vnc-001"})
 ```
 
 ### Helpful Vote Guidance
@@ -72,7 +72,7 @@ Note: `context_lookup` already records a doubled access signal automatically (×
 If you already have an entry ID (from a prior search or lookup result), use `context_get` for direct retrieval:
 
 ```
-mcp__unimatrix__context_get(id: 42, format: "markdown")
+mcp__unimatrix__context_get({"id": 42, "format": "markdown"})
 ```
 
 This is faster than a lookup with an ID filter and always returns full content.
@@ -95,21 +95,21 @@ This is faster than a lookup with an ID filter and always returns full content.
 
 **Before writing a new ADR (architect):**
 ```
-1. mcp__unimatrix__context_lookup(topic: "{feature-id}", category: "decision")
+1. mcp__unimatrix__context_lookup({"topic": "{feature-id}", "category": "decision"})
    → See what ADRs already exist for this feature
-2. mcp__unimatrix__context_lookup(category: "decision", tags: ["adr", "{domain}"])
+2. mcp__unimatrix__context_lookup({"category": "decision", "tags": ["adr", "{domain}"]})
    → See ADRs across features in the same domain
 ```
 
 **Before implementing a component (developer):**
 ```
-1. mcp__unimatrix__context_lookup(topic: "{feature-id}", category: "decision", format: "markdown")
+1. mcp__unimatrix__context_lookup({"topic": "{feature-id}", "category": "decision", "format": "markdown"})
    → Read all architectural decisions for this feature
 ```
 
 **Checking for deprecated knowledge:**
 ```
-mcp__unimatrix__context_lookup(category: "decision", status: "deprecated", topic: "{feature-id}")
+mcp__unimatrix__context_lookup({"category": "decision", "status": "deprecated", "topic": "{feature-id}"})
 → See what decisions have been superseded
 ```
 
@@ -121,8 +121,8 @@ Lookup may surface entries that are outdated or incorrect. Fix them:
 
 | Situation | Action |
 |-----------|--------|
-| Entry is **wrong** | `mcp__unimatrix__context_correct(original_id: {id}, content: "{corrected version}", reason: "{why}")` — supersedes with chain link |
-| Entry is **outdated** | `mcp__unimatrix__context_deprecate(id: {id}, reason: "{why}")` |
-| Entry is **suspicious** | `mcp__unimatrix__context_quarantine(id: {id}, reason: "{concern}")` — Admin only |
+| Entry is **wrong** | `mcp__unimatrix__context_correct({"original_id": 1234, "content": "{corrected version}", "reason": "{why}"})` — `original_id` is an integer, never quote it |
+| Entry is **outdated** | `mcp__unimatrix__context_deprecate({"id": 1234, "reason": "{why}"})` — `id` is an integer, never quote it |
+| Entry is **suspicious** | `mcp__unimatrix__context_quarantine({"id": 1234, "reason": "{concern}"})` — Admin only; `id` is an integer |
 
 Every agent shares responsibility for knowledge quality. Don't leave wrong entries for the next agent to trip over.

package/skills/uni-knowledge-search/SKILL.md

@@ -31,22 +31,22 @@ Call the `mcp__unimatrix__context_search` MCP tool:
 
 **Find ADRs about error handling across all features:**
 ```
-mcp__unimatrix__context_search(query: "error handling strategy", category: "decision", helpful: true)
+mcp__unimatrix__context_search({"query": "error handling strategy", "category": "decision", "helpful": true})
 ```
 
 **Find anything related to MCP transport:**
 ```
-mcp__unimatrix__context_search(query: "MCP transport stdio protocol")
+mcp__unimatrix__context_search({"query": "MCP transport stdio protocol"})
 ```
 
 **Find conventions about testing in a specific feature:**
 ```
-mcp__unimatrix__context_search(query: "test patterns integration", topic: "nxs-001")
+mcp__unimatrix__context_search({"query": "test patterns integration", "topic": "nxs-001"})
 ```
 
 **Get full content instead of summaries:**
 ```
-mcp__unimatrix__context_search(query: "serialization approach", format: "markdown")
+mcp__unimatrix__context_search({"query": "serialization approach", "format": "markdown"})
 ```
 
 ### Helpful Vote Guidance
@@ -100,7 +100,7 @@ Omit `category` to search across all categories.
 Search returns summaries by default. To read the full content of a specific result:
 
 1. Note the entry ID from search results
-2. Call `mcp__unimatrix__context_get(id: {entry_id}, format: "markdown")` for the full text
+2. Call `mcp__unimatrix__context_get({"id": {entry_id}, "format": "markdown"})` for the full text
 
 Or pass `format: "markdown"` directly to search if you want full content for all results.
 
@@ -112,8 +112,8 @@ Search may surface entries that are outdated or incorrect. Don't ignore them —
 
 | Situation | Action |
 |-----------|--------|
-| Entry is **wrong** — contains incorrect information | `mcp__unimatrix__context_correct(original_id: {id}, content: "{corrected version}", reason: "{why}")` — supersedes with chain link |
-| Entry is **outdated** — no longer relevant | `mcp__unimatrix__context_deprecate(id: {id}, reason: "{why it no longer applies}")` |
-| Entry is **suspicious** — may be poisoned or invalid | `mcp__unimatrix__context_quarantine(id: {id}, reason: "{concern}")` — Admin only |
+| Entry is **wrong** — contains incorrect information | `mcp__unimatrix__context_correct({"original_id": 1234, "content": "{corrected version}", "reason": "{why}"})` — `original_id` is an integer, never quote it |
+| Entry is **outdated** — no longer relevant | `mcp__unimatrix__context_deprecate({"id": 1234, "reason": "{why it no longer applies}"})` — `id` is an integer, never quote it |
+| Entry is **suspicious** — may be poisoned or invalid | `mcp__unimatrix__context_quarantine({"id": 1234, "reason": "{concern}"})` — Admin only; `id` is an integer |
 
 Correcting knowledge is as important as storing it. Every agent shares responsibility for knowledge quality.

package/skills/uni-query-patterns/SKILL.md

@@ -29,40 +29,40 @@ Searches Unimatrix for established patterns, procedures, and conventions relevan
 ### Step 1: Search by crate/area
 
 ```
-mcp__unimatrix__context_search(
-  query: "{what you're building — e.g., 'MCP tool handler'}",
-  category: "pattern",
-  k: 5
-)
+mcp__unimatrix__context_search({
+  "query": "{what you're building — e.g., 'MCP tool handler'}",
+  "category": "pattern",
+  "k": 5
+})
 ```
 
 ### Step 2: Also check conventions for the area
 
 ```
-mcp__unimatrix__context_search(
-  query: "{area — e.g., 'server tool pipeline'}",
-  category: "convention",
-  k: 5
-)
+mcp__unimatrix__context_search({
+  "query": "{area — e.g., 'server tool pipeline'}",
+  "category": "convention",
+  "k": 5
+})
 ```
 
 ### Step 3: Check for procedures (step-by-step techniques)
 
 ```
-mcp__unimatrix__context_search(
-  query: "{task — e.g., 'adding a new MCP tool'}",
-  category: "procedure",
-  k: 3
-)
+mcp__unimatrix__context_search({
+  "query": "{task — e.g., 'adding a new MCP tool'}",
+  "category": "procedure",
+  "k": 3
+})
 ```
 
 ### Step 4: Check for relevant ADRs
 
 ```
-mcp__unimatrix__context_lookup(
-  topic: "{feature-id}",
-  category: "decision"
-)
+mcp__unimatrix__context_lookup({
+  "topic": "{feature-id}",
+  "category": "decision"
+})
 ```
 
 ---
@@ -95,9 +95,9 @@ Query results may include entries that are outdated or incorrect. Fix them befor
 
 | Situation | Action |
 |-----------|--------|
-| Pattern/procedure is **wrong** | `mcp__unimatrix__context_correct(original_id: {id}, content: "{corrected version}", reason: "{why}")` |
-| Pattern/procedure is **outdated** | `mcp__unimatrix__context_deprecate(id: {id}, reason: "{why}")` |
-| Convention no longer applies | `mcp__unimatrix__context_deprecate(id: {id}, reason: "{why}")` |
+| Pattern/procedure is **wrong** | `mcp__unimatrix__context_correct({"original_id": 1234, "content": "{corrected version}", "reason": "{why}"})` — `original_id` is an integer, never quote it |
+| Pattern/procedure is **outdated** | `mcp__unimatrix__context_deprecate({"id": 1234, "reason": "{why}"})` — `id` is an integer, never quote it |
+| Convention no longer applies | `mcp__unimatrix__context_deprecate({"id": 1234, "reason": "{why}"})` — `id` is an integer, never quote it |
 
 If you correct or deprecate an entry during your session, mention it in your return to the coordinator so it can be noted in the outcome.