@nano-step/skill-manager 5.5.3 → 5.6.1

package/dist/index.js

@@ -123,6 +123,7 @@ async function run() {
         .command("install [name]")
         .description("Install a skill from the catalog")
         .option("--all", "Install all available skills")
+        .option("--force", "Force reinstall even if same version is installed")
         .action(async (name, options) => {
         const paths = await (0, utils_1.detectOpenCodePaths)();
         await (0, state_1.migrateV4State)(paths.configDir, paths.stateFilePath, paths.skillsDir);
@@ -135,11 +136,11 @@ async function run() {
                 return;
             }
             for (const entry of catalog) {
-                await (0, installer_1.installSkill)(entry.manifest.name, paths);
+                await (0, installer_1.installSkill)(entry.manifest.name, paths, options.force);
             }
         }
         else if (name) {
-            await (0, installer_1.installSkill)(name, paths);
+            await (0, installer_1.installSkill)(name, paths, options.force);
         }
         else {
             console.error(chalk_1.default.red("Please specify a skill name or use --all."));
@@ -158,11 +159,12 @@ async function run() {
     program
         .command("update [name]")
         .description("Update installed skill(s) to latest catalog version")
-        .action(async (name) => {
+        .option("--force", "Force update even if same version is installed")
+        .action(async (name, options) => {
         const paths = await (0, utils_1.detectOpenCodePaths)();
         await (0, state_1.migrateV4State)(paths.configDir, paths.stateFilePath, paths.skillsDir);
         if (name) {
-            await (0, installer_1.updateSkill)(name, paths);
+            await (0, installer_1.updateSkill)(name, paths, options.force);
         }
         else {
             const state = await (0, state_1.loadState)(paths.stateFilePath);
@@ -172,7 +174,7 @@ async function run() {
                 return;
             }
             for (const skillName of installed) {
-                await (0, installer_1.updateSkill)(skillName, paths);
+                await (0, installer_1.updateSkill)(skillName, paths, options.force);
             }
         }
     });

package/dist/installer.d.ts

@@ -1,4 +1,4 @@
 import { OpenCodePaths } from "./utils";
-export declare function installSkill(name: string, paths: OpenCodePaths): Promise<void>;
+export declare function installSkill(name: string, paths: OpenCodePaths, force?: boolean): Promise<void>;
 export declare function removeSkill(name: string, paths: OpenCodePaths): Promise<void>;
-export declare function updateSkill(name: string, paths: OpenCodePaths): Promise<void>;
+export declare function updateSkill(name: string, paths: OpenCodePaths, force?: boolean): Promise<void>;

package/dist/installer.js

@@ -14,11 +14,11 @@ const registry_1 = require("./registry");
 const state_1 = require("./state");
 const config_1 = require("./config");
 const remote_registry_1 = require("./remote-registry");
-async function installFromDir(manifest, sourceDir, paths, source) {
+async function installFromDir(manifest, sourceDir, paths, source, force) {
     const state = await (0, state_1.loadState)(paths.stateFilePath);
     const existing = state.skills[manifest.name];
-    if (existing && existing.version === manifest.version) {
-        console.log(chalk_1.default.yellow(`Skill "${manifest.name}" is already installed at v${manifest.version}.`));
+    if (existing && existing.version === manifest.version && !force) {
+        console.log(chalk_1.default.yellow(`Skill "${manifest.name}" is already installed at v${manifest.version}. Use --force to reinstall.`));
         return;
     }
     await (0, utils_1.ensureDirExists)(paths.skillsDir);
@@ -34,13 +34,14 @@ async function installFromDir(manifest, sourceDir, paths, source) {
     };
     await (0, state_1.saveState)(paths.stateFilePath, state);
     const sourceLabel = source === "private" ? chalk_1.default.magenta(" (private)") : "";
-    console.log(chalk_1.default.green(`✓ Installed ${manifest.name} v${manifest.version}${sourceLabel}`));
+    const forceLabel = force && existing ? " (forced)" : "";
+    console.log(chalk_1.default.green(`✓ Installed ${manifest.name} v${manifest.version}${sourceLabel}${forceLabel}`));
 }
-async function installSkill(name, paths) {
+async function installSkill(name, paths, force) {
     const localManifest = await (0, registry_1.getSkillManifest)(paths.packageSkillsDir, name);
     if (localManifest) {
         const packageSkillDir = path_1.default.join(paths.packageSkillsDir, name);
-        await installFromDir(localManifest, packageSkillDir, paths, "public");
+        await installFromDir(localManifest, packageSkillDir, paths, "public", force);
         return;
     }
     const remoteManifest = await (0, remote_registry_1.getRemoteSkillManifest)(name);
@@ -48,7 +49,7 @@ async function installSkill(name, paths) {
         const tempDir = await (0, remote_registry_1.downloadSkillToTemp)(name);
         if (tempDir) {
             try {
-                await installFromDir(remoteManifest, tempDir, paths, "private");
+                await installFromDir(remoteManifest, tempDir, paths, "private", force);
             }
             finally {
                 await fs_extra_1.default.remove(tempDir);
@@ -95,7 +96,7 @@ async function removeSkill(name, paths) {
     await (0, state_1.saveState)(paths.stateFilePath, state);
     console.log(chalk_1.default.green(`✓ Removed ${name}`));
 }
-async function updateSkill(name, paths) {
+async function updateSkill(name, paths, force) {
     const state = await (0, state_1.loadState)(paths.stateFilePath);
     if (!state.skills[name]) {
         console.error(chalk_1.default.red(`Skill "${name}" is not installed. Use 'skill-manager install ${name}' first.`));
@@ -104,8 +105,8 @@ async function updateSkill(name, paths) {
     const installed = state.skills[name];
     const localManifest = await (0, registry_1.getSkillManifest)(paths.packageSkillsDir, name);
     if (localManifest) {
-        if (installed.version === localManifest.version) {
-            console.log(chalk_1.default.yellow(`Skill "${name}" is already at v${localManifest.version} (up to date).`));
+        if (installed.version === localManifest.version && !force) {
+            console.log(chalk_1.default.yellow(`Skill "${name}" is already at v${localManifest.version} (up to date). Use --force to override.`));
             return;
         }
         const packageSkillDir = path_1.default.join(paths.packageSkillsDir, name);
@@ -120,13 +121,14 @@ async function updateSkill(name, paths) {
             location: installed.location,
         };
         await (0, state_1.saveState)(paths.stateFilePath, state);
-        console.log(chalk_1.default.green(`✓ Updated ${name} from v${installed.version} to v${localManifest.version}`));
+        const forceLabel = force && installed.version === localManifest.version ? " (forced)" : "";
+        console.log(chalk_1.default.green(`✓ Updated ${name} from v${installed.version} to v${localManifest.version}${forceLabel}`));
         return;
     }
     const remoteManifest = await (0, remote_registry_1.getRemoteSkillManifest)(name);
     if (remoteManifest) {
-        if (installed.version === remoteManifest.version) {
-            console.log(chalk_1.default.yellow(`Skill "${name}" is already at v${remoteManifest.version} (up to date).`));
+        if (installed.version === remoteManifest.version && !force) {
+            console.log(chalk_1.default.yellow(`Skill "${name}" is already at v${remoteManifest.version} (up to date). Use --force to override.`));
             return;
         }
         const tempDir = await (0, remote_registry_1.downloadSkillToTemp)(name);
@@ -143,7 +145,8 @@ async function updateSkill(name, paths) {
                     location: installed.location,
                 };
                 await (0, state_1.saveState)(paths.stateFilePath, state);
-                console.log(chalk_1.default.green(`✓ Updated ${name} from v${installed.version} to v${remoteManifest.version} (private)`));
+                const remoteForceLabel = force && installed.version === remoteManifest.version ? " (forced)" : "";
+                console.log(chalk_1.default.green(`✓ Updated ${name} from v${installed.version} to v${remoteManifest.version} (private)${remoteForceLabel}`));
             }
             finally {
                 await fs_extra_1.default.remove(tempDir);

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-export declare const MANAGER_VERSION = "5.5.3";
+export declare const MANAGER_VERSION = "5.6.1";
 export interface SkillManifest {
     name: string;
     version: string;

package/dist/utils.js

@@ -13,7 +13,7 @@ exports.writeText = writeText;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-exports.MANAGER_VERSION = "5.5.3";
+exports.MANAGER_VERSION = "5.6.1";
 async function detectOpenCodePaths() {
     const homeConfig = path_1.default.join(os_1.default.homedir(), ".config", "opencode");
     const cwd = process.cwd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano-step/skill-manager",
-  "version": "5.5.3",
+  "version": "5.6.1",
   "description": "CLI tool that installs and manages AI agent skills, MCP tool routing, and workflow configurations.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/private-catalog.json

@@ -16,8 +16,8 @@
   },
   {
     "name": "pr-code-reviewer",
-    "version": "2.6.0",
-    "description": "Comprehensive code review with 4 parallel subagents and GitHub Copilot-style PR summaries"
+    "version": "7.1.0",
+    "description": "PR review with MANDATORY cross-repo consumer search, nano-brain code intelligence, and better-context structural analysis. READ-ONLY — no comments, pushes, or code fixes."
   },
   {
     "name": "rri-t-testing",

package/skills/nano-brain/AGENTS_SNIPPET.md

@@ -19,15 +19,6 @@ nano-brain supports two access methods. Try MCP first; if unavailable, use CLI.
 
 ### Session Workflow
 
-**Start of session:** Check memory for relevant past context before exploring the codebase.
-```
-# MCP (if available):
-memory_query("what have we done regarding {current task topic}")
-
-# CLI fallback:
-npx nano-brain query "what have we done regarding {current task topic}"
-```
-
 **End of session:** Save key decisions, patterns discovered, and debugging insights.
 ```
 # MCP (if available):
@@ -37,10 +28,25 @@ memory_write("## Summary\n- Decision: ...\n- Why: ...\n- Files: ...")
 # File: ~/.nano-brain/memory/YYYY-MM-DD-summary.md
 ```
 
-### When to Search Memory vs Codebase
+### Code Intelligence Tools
+
+nano-brain also provides symbol-level code analysis (requires `memory_index_codebase` first):
+
+| I want to... | MCP Tool |
+|--------------|----------|
+| Understand a symbol's callers/callees/flows | `code_context(name="functionName")` |
+| Assess risk of changing a symbol | `code_impact(target="className", direction="upstream")` |
+| Map my git changes to affected symbols | `code_detect_changes(scope="all")` |
+
+Use `file_path` parameter to disambiguate when multiple symbols share the same name.
+
+### When to Search Memory vs Codebase vs Code Intelligence
 
 - **"Have we done this before?"** → `memory_query` or `npx nano-brain query` (searches past sessions)
 - **"Where is this in the code?"** → grep / ast-grep (searches current files)
 - **"How does this concept work here?"** → Both (memory for past context + grep for current code)
+- **"What calls this function?"** → `code_context` (symbol graph relationships)
+- **"What breaks if I change X?"** → `code_impact` (dependency + flow analysis)
+- **"What did my changes affect?"** → `code_detect_changes` (git diff to symbol mapping)
 
 <!-- OPENCODE-MEMORY:END -->

package/skills/nano-brain/SKILL.md

@@ -1,14 +1,23 @@
+---
+name: nano-brain
+description: Provide persistent memory and code intelligence for AI coding agents; use for hybrid search, cross-session recall, symbol analysis, and impact checks.
+compatibility: OpenCode
+metadata:
+  author: nano-step
+  version: 2.1.0
+---
+
 # nano-brain
 
-Persistent memory for AI coding agents. Hybrid search (BM25 + semantic + LLM reranking) across past sessions, codebase, notes, and daily logs.
+Provide persistent memory for AI coding agents. Run hybrid search (BM25 + semantic + LLM reranking) across past sessions, codebase, notes, and daily logs.
 
 ## Slash Commands
 
 | Command | When |
 |---------|------|
-| `/nano-brain-init` | First-time workspace setup |
-| `/nano-brain-status` | Health check, embedding progress |
-| `/nano-brain-reindex` | After branch switch, pull, or major changes |
+| `/nano-brain-init` | Run first-time workspace setup |
+| `/nano-brain-status` | Check health, embedding progress |
+| `/nano-brain-reindex` | Run after branch switch, pull, or major changes |
 
 ## When to Use Memory
 
@@ -17,25 +26,44 @@ Persistent memory for AI coding agents. Hybrid search (BM25 + semantic + LLM rer
 
 ## Access Methods: MCP vs CLI
 
-nano-brain can be accessed via **MCP tools** (when the MCP server is configured) or **CLI** (always available).
+Access nano-brain via **MCP tools** (when the MCP server is configured) or **CLI** (always available).
 
 **Detection:** Try calling `memory_status` MCP tool first. If it fails with "MCP server not found", fall back to CLI.
 
 ### MCP Tools (preferred when available)
 
-| Need | MCP Tool |
-|------|----------|
-| Exact keyword (error msg, function name) | `memory_search` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_search")` |
-| Conceptual ("how does auth work") | `memory_vsearch` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_vsearch")` |
-| Best quality, complex question | `memory_query` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_query")` |
-| Retrieve specific doc | `memory_get` / `memory_multi_get` |
-| Save insight or decision (append to daily log) | `memory_write` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_write")` |
-| Set/update a keyed memory (overwrites previous) | `memory_set` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_set")` |
-| Delete a keyed memory | `memory_delete` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_delete")` |
-| List all keyed memories | `memory_keys` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_keys")` |
-| Check health | `memory_status` via `skill_mcp(mcp_name="nano-brain", tool_name="memory_status")` |
-| Rescan source files | `memory_index_codebase` |
-| Refresh all indexes | `memory_update` |
+- **`memory_search`** — recall a specific error string or function name from past sessions.
+  Example: `skill_mcp(mcp_name="nano-brain", tool_name="memory_search", arguments={ query: "ECONNREFUSED redis timeout" })`
+- **`memory_vsearch`** — explore a fuzzy concept when you do not know the exact wording.
+  Example: `memory_vsearch("caching strategy for user sessions")`
+- **`memory_query`** — get the best hybrid answer for a complex, multi-part question.
+  Example: `memory_query("how did we handle rate limiting in the payment service")`
+- **`memory_get`** — pull one known doc by ID or path.
+  Example: `memory_get(id="#a1b2c3")`
+- **`memory_multi_get`** — fetch a set of known docs by pattern.
+  Example: `memory_multi_get(pattern="decisions/2025-*/auth-*.md")`
+- **`memory_write`** — log a decision or insight for future recall.
+  Example: `memory_write("## Decision: Use Redis Streams over Bull queues\n- Why: retries need ordered replay")`
+- **`memory_set`** — store a keyed note you plan to update over time.
+  Example: `memory_set(key="payments-rate-limit", content="429s come from gateway, not nginx")`
+- **`memory_delete`** — remove a stale keyed note that is no longer accurate.
+  Example: `memory_delete(key="legacy-redis-metrics")`
+- **`memory_keys`** — list all keyed notes to see what is tracked.
+  Example: `memory_keys()`
+- **`memory_status`** — verify MCP health or embedding progress before searching.
+  Example: `memory_status()`
+- **`memory_index_codebase`** — index source files before using code intelligence tools.
+  Example: `memory_index_codebase(root="/Users/tamlh/workspaces/self/AI/Tools")`
+- **`memory_update`** — refresh all indexes after big changes or repo syncs.
+  Example: `memory_update()`
+- **`memory_focus`** — inspect dependencies for a specific file you are editing.
+  Example: `memory_focus(filePath="/src/api/routes/auth.ts")`
+- **`memory_graph_stats`** — check dependency graph size and coverage.
+  Example: `memory_graph_stats()`
+- **`memory_symbols`** — find where cross-repo infrastructure symbols are defined or used.
+  Example: `memory_symbols(type="redis_key", pattern="session:*")`
+- **`memory_impact`** — see which repos or services are affected by a symbol.
+  Example: `memory_impact(type="mysql_table", pattern="orders")`
 
 ### CLI Fallback (always available)
 
@@ -69,9 +97,23 @@ Works with both MCP and CLI (`-c` flag):
 - `memory` — curated notes only
 - Omit — search everything (recommended)
 
+## Code Intelligence Tools (MCP)
+
+Use symbol-level analysis powered by Tree-sitter AST parsing. Require codebase indexing.
+
+- **`code_context`** — trace callers, callees, and flows around a symbol.
+  Example: `code_context(name="processPayment")`
+- **`code_impact`** — evaluate upstream or downstream risk before refactors.
+  Example: `code_impact(target="DatabaseClient", direction="upstream")`
+- **`code_detect_changes`** — map current git diffs to symbols and flows.
+  Example: `code_detect_changes(scope="all")`
+
+**Details and examples:** `references/code-intelligence.md`
+
 ## Memory vs Native Tools
 
 Memory excels at **recall and semantics** — past sessions, conceptual search, cross-project knowledge.
 Native tools (grep, ast-grep, glob) excel at **precise code patterns** — exact matches, AST structure.
+Code intelligence tools excel at **structural relationships** — call graphs, impact analysis, flow detection.
 
-**They are complementary.** Use both.
+**They are complementary.** Use all three.

package/skills/nano-brain/references/code-intelligence.md

@@ -0,0 +1,57 @@
+---
+name: nano-brain code intelligence
+description: Use MCP code_context, code_impact, and code_detect_changes for symbol-level analysis, impact checks, and diff mapping.
+---
+
+# Code Intelligence (nano-brain)
+
+## Overview
+
+Run code intelligence when symbol relationships, impact analysis, or diff-to-symbol mapping is needed. Ensure indexing is done with `memory_index_codebase` before using these tools.
+
+## code_context — 360-degree symbol view
+
+Return callers, callees, cluster membership, execution flows, and infrastructure connections for any function/class/method.
+
+```
+skill_mcp(mcp_name="nano-brain", tool_name="code_context", arguments={"name": "handleRequest"})
+skill_mcp(mcp_name="nano-brain", tool_name="code_context", arguments={"name": "helper", "file_path": "/src/utils.ts"})
+```
+
+Use `file_path` to disambiguate when multiple symbols share the same name.
+
+## code_impact — dependency analysis
+
+Traverse the symbol graph to find affected symbols and flows. Return a risk level (LOW/MEDIUM/HIGH/CRITICAL).
+
+```
+skill_mcp(mcp_name="nano-brain", tool_name="code_impact", arguments={"target": "DatabaseClient", "direction": "upstream"})
+skill_mcp(mcp_name="nano-brain", tool_name="code_impact", arguments={"target": "processOrder", "direction": "downstream", "max_depth": 3})
+```
+
+- `upstream` = "who calls this?" (callers, consumers)
+- `downstream` = "what does this call?" (callees, dependencies)
+
+## code_detect_changes — git diff to symbol mapping
+
+Map current git changes to affected symbols and execution flows.
+
+```
+skill_mcp(mcp_name="nano-brain", tool_name="code_detect_changes", arguments={"scope": "staged"})
+skill_mcp(mcp_name="nano-brain", tool_name="code_detect_changes", arguments={"scope": "all"})
+```
+
+Scopes: `unstaged`, `staged`, `all` (default).
+
+## When to Use Code Intelligence vs Memory vs Native Tools
+
+| Question | Tool |
+|----------|------|
+| "What calls function X?" | `code_context` |
+| "What breaks if I change X?" | `code_impact` |
+| "What did I change and what's affected?" | `code_detect_changes` |
+| "Have we done this before?" | `memory_query` |
+| "Find exact string in code" | grep / ast-grep |
+| "How does auth work conceptually?" | `memory_vsearch` |
+
+Code intelligence requires indexing. Run `memory_index_codebase` first if the workspace has not been indexed.

package/skills/nano-brain/skill.json

@@ -1,7 +1,7 @@
 {
     "name": "nano-brain",
-    "version": "1.0.0",
-    "description": "Persistent memory for AI coding agents. Hybrid search (BM25 + semantic + LLM reranking) across past sessions, codebase, notes, and daily logs.",
+    "version": "2.1.0",
+    "description": "Persistent memory and code intelligence for AI coding agents. Hybrid search, cross-session recall, symbol analysis, and impact checks.",
     "compatibility": "OpenCode",
     "agent": null,
     "commands": [],
@@ -10,6 +10,9 @@
         "persistence",
         "search",
         "context",
-        "sessions"
+        "sessions",
+        "code-intelligence",
+        "symbol-analysis",
+        "impact-analysis"
     ]
 }

package/skills/rri-t-testing/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: rri-t-testing
+description: RRI-T v2 - Rapid Risk-Informed Testing with BMAD-enhanced risk scoring, traceability, quality gates, and nano-brain memory persistence
+---
+
+# RRI-T v2.0 Testing Skill
+
+Rapid Risk-Informed Testing methodology for AI agents. Guides systematic QA testing through 6 phases with risk scoring, traceability, quality gates, and cross-session memory persistence.
+
+## When to Use
+
+- Testing a new feature before release
+- Validating a bug fix with regression coverage
+- Assessing release readiness with quality gates
+- Building test cases from requirements with traceability
+- Resuming interrupted testing sessions via nano-brain
+
+## Input Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `feature` | Yes | Feature name or PR reference |
+| `tier` | No | Testing depth: `full` (default), `standard`, `minimal` |
+| `acceptance_criteria` | No | List of acceptance criteria or link to spec |
+| `environment` | No | Target environment (dev/staging/prod) |
+
+## Workflow Phases
+
+### Phase 0: ASSESS
+
+Run testability gate, score risk, classify category, select tier, make go/no-go decision.
+
+**Steps:**
+1. Load `assets/rri-t-testability-gate.md` template
+2. Validate prerequisites (environment, test data, deployment, acceptance criteria)
+3. Assess testability (locators, API docs, auth flows, error states, baselines)
+4. Score risk: Probability (1-3) x Impact (1-3) = Score (1-9)
+5. Classify category: TECH / SEC / PERF / DATA / BUS / OPS
+6. Select tier based on score
+7. Decision: PROCEED / CONCERNS / BLOCK
+
+**Output:** `00-assess.md`, `risk-matrix.md`
+
+**MEMORY SAVE:** `rri-t/{feature}/assess` - Save risk register, tier, decision
+
+---
+
+### Phase 1: PREPARE
+
+Define test scope, assign personas, select dimensions based on tier.
+
+**Steps:**
+1. Define test scope based on tier selection
+2. Assign personas (5 for Full, 3 for Standard, 1 for Minimal)
+3. Select dimensions (7 for Full, 4 for Standard, 2 for Minimal)
+4. Set coverage targets per tier
+5. Create output directory structure
+
+**Output:** `01-prepare.md`
+
+**MEMORY SAVE:** `rri-t/{feature}/prepare` - Save scope, persona assignments, dimension targets
+
+---
+
+### Phase 2: DISCOVER
+
+Run persona interviews, map to dimensions, consolidate findings.
+
+**Steps:**
+1. Load `assets/rri-t-persona-interview.md` template
+2. Run persona interviews using risk-tagged questions
+3. Map questions to dimensions (D1-D7)
+4. Consolidate findings into risk register update
+5. Generate raw test ideas
+
+**Output:** `02-discover.md`
+
+**MEMORY SAVE:** `rri-t/{feature}/discover` - Save interview findings, test ideas, updated risks
+
+---
+
+### Phase 3: STRUCTURE
+
+Create test cases, select stress axes, build traceability matrix.
+
+**Steps:**
+1. Load `assets/rri-t-test-case.md` template
+2. Create test cases with Q-A-R-P-T format + risk category + traceability
+3. Load `assets/rri-t-stress-matrix.md` and select relevant stress axes
+4. Build traceability matrix using `assets/rri-t-traceability-matrix.md`
+5. Identify coverage gaps
+
+**Output:** `03-structure.md`, `traceability.md`
+
+**MEMORY SAVE:** `rri-t/{feature}/structure` - Save test cases, traceability, gaps
+
+---
+
+### Phase 4: EXECUTE
+
+Execute test cases via Playwright MCP, capture evidence, record results.
+
+**Steps:**
+1. Execute test cases using Playwright MCP browser automation
+2. Capture evidence (screenshots, console logs, network requests)
+3. Record results: PASS / FAIL / PAINFUL / MISSING
+4. Calculate quality score using `assets/rri-t-quality-scorecard.md`
+5. Log bugs found
+
+**Output:** `04-execute.md`, `quality-scorecard.md`
+
+**MEMORY SAVE:** `rri-t/{feature}/execute` - Save results, bugs, quality score
+
+---
+
+### Phase 5: ANALYZE
+
+Fill coverage dashboard, apply gate rules, generate final report.
+
+**Steps:**
+1. Load `assets/rri-t-coverage-dashboard.md` template
+2. Fill coverage dashboard with results
+3. Complete traceability matrix with test results
+4. Apply gate decision rules (PASS/CONCERNS/FAIL/WAIVED)
+5. Generate final report
+6. Extract reusable patterns for knowledge base
+
+**Output:** `05-analyze.md`, `coverage-dashboard.md`
+
+**MEMORY SAVE:** `rri-t/{feature}/analyze` - Save gate decision, report, lessons learned, reusable patterns
+
+---
+
+## Output Directory Structure
+
+```
+rri-t-{feature}/
+  00-assess.md              # Phase 0: Testability gate + risk assessment
+  01-prepare.md             # Phase 1: Scope, personas, dimensions
+  02-discover.md            # Phase 2: Interview findings, test ideas
+  03-structure.md           # Phase 3: Test cases, stress selections
+  04-execute.md             # Phase 4: Execution log, evidence
+  05-analyze.md             # Phase 5: Final analysis, recommendations
+  risk-matrix.md            # Risk register with PxI scoring
+  traceability.md           # Requirement-to-test mapping
+  quality-scorecard.md      # 0-100 quality scoring
+  coverage-dashboard.md     # Coverage metrics, gate decision
+  evidence/                 # Screenshots, logs
+```
+
+## Templates
+
+| Template | Purpose |
+|----------|---------|
+| `rri-t-testability-gate.md` | Phase 0 readiness checklist |
+| `rri-t-risk-matrix.md` | PxI risk scoring template |
+| `rri-t-traceability-matrix.md` | Requirement-to-test mapping |
+| `rri-t-quality-scorecard.md` | 0-100 quality scoring |
+| `rri-t-memory-protocol.md` | nano-brain save/resume protocol |
+| `rri-t-test-case.md` | Q-A-R-P-T test case format |
+| `rri-t-persona-interview.md` | 5-persona interview template |
+| `rri-t-coverage-dashboard.md` | Coverage metrics dashboard |
+| `rri-t-stress-matrix.md` | 8-axis stress testing scenarios |
+
+## 7 Dimensions
+
+| ID | Dimension | Target Coverage |
+|----|-----------|-----------------|
+| D1 | UI/UX | >= 85% |
+| D2 | API | >= 85% |
+| D3 | Performance | >= 70% |
+| D4 | Security | >= 85% |
+| D5 | Data Integrity | >= 85% |
+| D6 | Infrastructure | >= 70% |
+| D7 | Edge Cases | >= 85% |
+
+## 5 Personas
+
+| Persona | Focus |
+|---------|-------|
+| End User | Daily usage, speed, clarity, data safety |
+| Business Analyst | Business rules, permissions, data consistency |
+| QA Destroyer | Edge cases, race conditions, malformed inputs |
+| DevOps Tester | Load, recovery, observability, scalability |
+| Security Auditor | Auth, access control, data exposure, audit trails |
+
+## Tier Selection
+
+| Tier | Risk Score | Personas | Dimensions | Stress Axes | Est. Time |
+|------|------------|----------|------------|-------------|-----------|
+| Full | 6-9 | 5 | 7 | 8 | 2-4 hours |
+| Standard | 3-5 | 3 | 4 | 4 | 1-2 hours |
+| Minimal | 1-2 | 1 | 2 | 2 | 30-60 min |
+
+## Release Gates
+
+| State | Criteria |
+|-------|----------|
+| PASS | P0 coverage = 100% AND P1 >= 90% AND overall >= 80% |
+| CONCERNS | P0 = 100% AND P1 = 80-89% AND mitigations documented |
+| FAIL | P0 < 100% OR P1 < 80% OR unresolved security issues |
+| WAIVED | FAIL + business approval + owner + expiry + remediation plan |
+
+## Risk Categories
+
+| Code | Category | Description |
+|------|----------|-------------|
+| TECH | Technical | Architecture/integration fragility |
+| SEC | Security | Security vulnerabilities |
+| PERF | Performance | Performance/scalability issues |
+| DATA | Data | Data integrity/corruption |
+| BUS | Business | Business logic errors |
+| OPS | Operational | Deployment/operational issues |
+
+## Guardrails
+
+- Always run Phase 0 ASSESS before testing
+- Score risk before testing (PxI formula)
+- Use Q-A-R-P-T format for all test cases
+- Map every test case to a requirement (traceability)
+- Capture evidence for all FAIL and PAINFUL results
+- Save to nano-brain after every phase
+- Never skip security dimension for SEC-category risks
+- Document all waivers with owner, expiry, remediation