continuous-improvement 3.11.0 → 3.15.0

package/bin/unified-cli.mjs

@@ -1,33 +1,26 @@
 #!/usr/bin/env node
 /**
- * Unified Continuous Improvement CLI.
+ * CLI-Anything command (`ci`).
  *
- * Comprehensive command-line interface for the unified plugin that combines
- * CLI-Anything, Compound Engineering, and PM-Skills.
+ * Thin front-end over the CLIAnything library: turns a repository into an
+ * agent-native CLI wrapper that a language model can drive.
+ *
+ * The former Compound Engineering and PM-Skills tools (and the unified-plugin
+ * orchestrator that combined all three) were removed in 3.13.0 - Compound
+ * Engineering overlapped the Mulahazah instinct engine and PM-Skills overlapped
+ * the out-of-band phuryn/pm-skills marketplace install. See CHANGELOG [3.13.0].
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import UnifiedContinuousImprovement from "../lib/unified-plugin.mjs";
+import CLIAnything from "../lib/cli-anything.mjs";
 const DEFAULT_CONFIG = {
     workspace: "./ci-workspace",
     verbose: false,
-    defaultMode: "expert",
 };
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function parseJsonOption(raw) {
-    if (!raw)
-        return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Invalid JSON option: ${getErrorMessage(error)}`);
-    }
-}
 class UnifiedCLI {
-    plugin = null;
     config;
     constructor() {
         this.config = this.loadConfig();
@@ -40,350 +33,48 @@ class UnifiedCLI {
                 return { ...DEFAULT_CONFIG, ...parsed };
             }
             catch {
-                console.warn("Warning: Invalid config file, using defaults");
+                console.warn("Warning: invalid config file, using defaults");
             }
         }
         return { ...DEFAULT_CONFIG };
     }
-    initializePlugin(options) {
-        this.plugin = new UnifiedContinuousImprovement({
-            workspace: options.workspace ?? this.config.workspace,
-            verbose: options.verbose ?? this.config.verbose,
-        });
-        return this.plugin;
-    }
-    requirePlugin() {
-        if (!this.plugin) {
-            throw new Error("CLI plugin not initialized");
-        }
-        return this.plugin;
-    }
     async runCommand(command, args, options = {}) {
-        this.initializePlugin(options);
         switch (command) {
-            case "init":
-                return this.handleInit(args, options);
-            case "workflow":
-                return this.handleWorkflow(args, options);
-            case "research":
-                return this.handleResearch(options);
-            case "planning":
-                return this.handlePlanning(options);
-            case "execution":
-                return this.handleExecution();
-            case "review":
-                return this.handleReview(options);
-            case "status":
-                return this.handleStatus();
-            case "cli":
-                return this.handleCLI(args);
-            case "pm":
-                return this.handlePM(args, options);
-            case "compound":
-                return this.handleCompound(args);
-            case "learnings":
-                return this.handleLearnings(args);
+            case "generate":
+                return this.handleGenerate(args, options);
+            case "list":
+                return this.handleList();
             case "config":
                 return this.handleConfig(args);
             default:
                 throw new Error(`Unknown command: ${command}`);
         }
     }
-    async handleInit(args, options) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci init <project-name> <objective> [options]");
-        }
-        const [name, ...objectiveParts] = args;
-        const objective = objectiveParts.join(" ");
-        console.log(`🚀 Initializing project: ${name}`);
-        console.log(`📋 Objective: ${objective}`);
-        const plugin = this.requirePlugin();
-        const result = await plugin.initializeProject({
-            name: name,
-            objective,
-            product: parseJsonOption(options.product) ?? {},
-            industry: options.industry ?? "",
-            targetMarket: parseJsonOption(options.targetMarket) ?? {},
-        });
-        console.log(`✅ Project initialized successfully!`);
-        console.log(`🆔 Project ID: ${result.projectId}`);
-        console.log(`🔗 Session ID: ${result.sessionId}`);
-        console.log(`📊 PM Analysis: ${result.pmAnalysis.totalSkills} skills completed`);
-        console.log(`\n🎯 Next steps:`);
-        result.nextSteps.forEach((step, i) => {
-            console.log(`   ${i + 1}. ${step}`);
-        });
-        return result;
-    }
-    async handleWorkflow(args, options) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci workflow <project-name> <objective> [options]");
+    async handleGenerate(args, options) {
+        const repoPath = args[0];
+        if (!repoPath) {
+            throw new Error("Usage: ci generate <repository-path>");
         }
-        const [name, ...objectiveParts] = args;
-        const objective = objectiveParts.join(" ");
-        console.log(`🚀 Starting complete workflow for: ${name}`);
-        console.log(`📋 Objective: ${objective}`);
-        const progressCallback = (message) => {
-            console.log(`   ⏳ ${message}`);
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeCompleteWorkflow({
-            name: name,
-            objective,
-            product: parseJsonOption(options.product) ?? {},
-            industry: options.industry ?? "",
-            targetMarket: parseJsonOption(options.targetMarket) ?? {},
-        }, {
-            researchContext: options.repo ? { repositoryPath: options.repo } : {},
-            progressCallback,
+        const cliAnything = new CLIAnything({
+            outputDir: options.workspace ?? this.config.workspace,
+            verbose: options.verbose ?? this.config.verbose,
         });
-        console.log(`🎉 Complete workflow finished!`);
-        console.log(`🆔 Project: ${result.project}`);
-        console.log(`🔗 Session: ${result.sessionId}`);
-        for (const [phase] of Object.entries(result.phases)) {
-            console.log(`\n📊 ${phase.charAt(0).toUpperCase() + phase.slice(1)} Phase:`);
-        }
-        return result;
-    }
-    async handleResearch(options) {
-        console.log(`🔍 Starting research phase...`);
-        const context = {};
-        if (options.repo)
-            context.repositoryPath = options.repo;
-        if (options.context)
-            context.additionalContext = parseJsonOption(options.context);
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeResearchPhase(context);
-        console.log(`✅ Research phase completed!`);
-        console.log(`💡 Generated ${result.brainstorm.ideas.length} ideas`);
-        console.log(`🔍 Identified ${result.brainstorm.risks.length} risks`);
-        if (result.cliTools) {
-            console.log(`🛠️  Generated CLI with ${result.cliTools.commands.length} commands`);
-        }
-        return result;
-    }
-    async handlePlanning(options) {
-        console.log(`📋 Starting planning phase...`);
-        const preferences = parseJsonOption(options.preferences) ?? {};
-        const plugin = this.requirePlugin();
-        const result = await plugin.executePlanningPhase(preferences);
-        console.log(`✅ Planning phase completed!`);
-        console.log(`📈 Created plan with ${result.corePlan.steps.length} steps`);
-        const estimated = result.corePlan.timeline?.estimated;
-        if (estimated)
-            console.log(`⏱️  Timeline: ${estimated}`);
-        console.log(`⚠️  Identified ${result.risks.length} risks`);
-        return result;
-    }
-    async handleExecution() {
-        console.log(`🔧 Starting execution phase...`);
-        const progressCallback = (message) => {
-            console.log(`   ⚡ ${message}`);
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeWorkingPhase(progressCallback);
-        console.log(`✅ Execution phase completed!`);
-        console.log(`📋 Completed ${result.coreWork.steps.length} steps`);
-        console.log(`🔧 Resolved ${result.issues.length} issues`);
-        console.log(`💡 Applied ${result.solutions.length} solutions`);
-        return result;
-    }
-    async handleReview(options) {
-        console.log(`🔍 Starting review phase...`);
-        const criteria = parseJsonOption(options.criteria);
-        const plugin = this.requirePlugin();
-        const result = await plugin.executeReviewPhase(criteria);
-        console.log(`✅ Review phase completed!`);
-        console.log(`📊 Overall score: ${result.coreReview.review.overallScore}/100`);
-        console.log(`💡 Generated ${result.learnings.length} learnings`);
-        console.log(`📋 Created ${result.recommendations.length} recommendations`);
-        return result;
-    }
-    async handleStatus() {
-        const plugin = this.requirePlugin();
-        const status = await plugin.getProjectStatus();
-        console.log(`📊 Project Status:`);
-        console.log(`   Project: ${status.project ?? "No active project"}`);
-        console.log(`   Session: ${status.sessionId ?? "N/A"}`);
-        console.log(`   Current Phase: ${status.currentPhase ?? "N/A"}`);
-        if (status.progress) {
-            console.log(`   Progress: ${status.progress.completed}/${status.progress.total} (${status.progress.percentage}%)`);
-        }
-        if (status.nextSteps && status.nextSteps.length > 0) {
-            console.log(`\n🎯 Next Steps:`);
-            status.nextSteps.forEach((step, i) => {
-                console.log(`   ${i + 1}. ${step}`);
-            });
-        }
-        return status;
-    }
-    async handleCLI(args) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "generate":
-                if (subArgs.length === 0) {
-                    throw new Error("Usage: ci cli generate <repository-path>");
-                }
-                return this.handleCLIGenerate(subArgs[0]);
-            case "list":
-                return this.handleCLIList();
-            default:
-                throw new Error("Usage: ci cli <generate|list> [args]");
-        }
-    }
-    async handleCLIGenerate(repoPath) {
-        console.log(`🛠️  Generating CLI for: ${repoPath}`);
-        const plugin = this.requirePlugin();
-        const result = await plugin.cliAnything.generateCLI(repoPath);
-        console.log(`✅ CLI generated successfully!`);
-        console.log(`📁 Output: ${result.outputPath}`);
-        console.log(`🔧 Commands: ${result.commands.length}`);
-        console.log(`\n📋 Available Commands:`);
+        const result = await cliAnything.generateCLI(repoPath);
+        console.log(`Generated CLI for: ${repoPath}`);
+        console.log(`  Output: ${result.outputPath}`);
+        console.log(`  Commands: ${result.commands.length}`);
         for (const cmd of result.commands) {
-            console.log(`   ${cmd.name.padEnd(15)} - ${cmd.description}`);
+            console.log(`    ${cmd.name.padEnd(15)} ${cmd.description}`);
         }
         return result;
     }
-    handleCLIList() {
-        console.log(`🛠️  CLI Generation Tool Status: Ready`);
-        console.log(`   Repository Analysis: Supported`);
-        console.log(`   Project Types: Node.js, React, Python, Docker, and more`);
-        console.log(`   Output Format: Executable JavaScript`);
+    handleList() {
+        console.log("CLI-Anything status: ready");
+        console.log("  Repository analysis: supported");
+        console.log("  Project types: Node.js, React, Python, Docker, and more");
+        console.log("  Output format: executable JavaScript");
     }
-    async handlePM(args, options) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "analyze":
-                return this.handlePMAnalyze(options);
-            case "skill":
-                return this.handlePMSkill(subArgs);
-            case "list":
-                return this.handlePMList();
-            default:
-                throw new Error("Usage: ci pm <analyze|skill|list> [args]");
-        }
-    }
-    async handlePMAnalyze(options) {
-        console.log(`📊 Running comprehensive PM analysis...`);
-        const productInfo = {
-            product: parseJsonOption(options.product) ?? {},
-            industry: options.industry ?? "Technology",
-            targetMarket: parseJsonOption(options.targetMarket) ?? {},
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.pmSkills.runProductAnalysis(productInfo);
-        console.log(`✅ PM analysis completed!`);
-        console.log(`📊 Summary: ${result.summary.completedSkills}/${result.summary.totalSkills} skills completed`);
-        console.log(`💡 Key insights: ${result.summary.keyInsights.length}`);
-        console.log(`📋 Recommendations: ${result.summary.recommendations.length}`);
-        console.log(`📁 Results saved to: ${result.savedTo}`);
-        return result;
-    }
-    async handlePMSkill(args) {
-        if (args.length === 0) {
-            throw new Error("Usage: ci pm skill <skill-name>");
-        }
-        const [skillName] = args;
-        console.log(`📊 Executing PM skill: ${skillName}`);
-        const input = {
-            product: { name: "Sample Product" },
-            market: { size: "Medium" },
-        };
-        const plugin = this.requirePlugin();
-        const result = await plugin.pmSkills.executeSkill(skillName, input);
-        console.log(`✅ PM skill ${skillName} completed!`);
-        console.log(`📁 Results saved to: ${result.savedTo}`);
-        return result;
-    }
-    handlePMList() {
-        const plugin = this.requirePlugin();
-        const skills = plugin.pmSkills.getAvailableSkills();
-        console.log(`📊 Available PM Skills:`);
-        for (const skill of skills) {
-            console.log(`   ${skill.name.padEnd(20)} - ${skill.description} [${skill.category}]`);
-        }
-    }
-    async handleCompound(args) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "session":
-                return this.handleCompoundSession(subArgs);
-            case "learnings":
-                return this.handleCompoundLearnings();
-            default:
-                throw new Error("Usage: ci compound <session|learnings> [args]");
-        }
-    }
-    async handleCompoundSession(args) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci compound session <project-name> <objective>");
-        }
-        const [name, ...objectiveParts] = args;
-        const objective = objectiveParts.join(" ");
-        console.log(`🔧 Starting compound engineering session...`);
-        const plugin = this.requirePlugin();
-        const session = await plugin.compoundEngineering.startSession(name, objective);
-        console.log(`✅ Session started!`);
-        console.log(`🆔 Session ID: ${session.id}`);
-        console.log(`📋 Objective: ${session.objective}`);
-        console.log(`🔄 Current Phase: ${session.phase}`);
-        return session;
-    }
-    async handleCompoundLearnings() {
-        console.log(`📚 Loading compound engineering learnings...`);
-        const plugin = this.requirePlugin();
-        await plugin.compoundEngineering.loadLearnings();
-        const learnings = plugin.compoundEngineering.getAllLearnings();
-        console.log(`📚 Found ${learnings.length} learnings:`);
-        for (const learning of learnings) {
-            console.log(`   [${learning.confidence.toFixed(2)}] ${learning.summary}`);
-        }
-        return learnings;
-    }
-    async handleLearnings(args) {
-        const [subcommand, ...subArgs] = args;
-        switch (subcommand) {
-            case "search":
-                return this.handleLearningsSearch(subArgs.join(" "));
-            case "all":
-                return this.handleLearningsAll();
-            default:
-                throw new Error("Usage: ci learnings <search|all> [query]");
-        }
-    }
-    async handleLearningsSearch(query) {
-        console.log(`🔍 Searching learnings for: "${query}"`);
-        const plugin = this.requirePlugin();
-        await plugin.compoundEngineering.loadLearnings();
-        const results = plugin.compoundEngineering.searchLearnings(query);
-        console.log(`🔍 Found ${results.length} matching learnings:`);
-        for (const learning of results) {
-            console.log(`   [${learning.confidence.toFixed(2)}] ${learning.summary}`);
-        }
-        return results;
-    }
-    async handleLearningsAll() {
-        console.log(`📚 Loading all learnings...`);
-        const plugin = this.requirePlugin();
-        await plugin.compoundEngineering.loadLearnings();
-        const learnings = plugin.compoundEngineering.getAllLearnings();
-        console.log(`📚 Total learnings: ${learnings.length}`);
-        const grouped = learnings.reduce((groups, learning) => {
-            const type = learning.type || "general";
-            if (!groups[type])
-                groups[type] = [];
-            groups[type].push(learning);
-            return groups;
-        }, {});
-        for (const [type, items] of Object.entries(grouped)) {
-            console.log(`\n   ${type.charAt(0).toUpperCase() + type.slice(1)} (${items.length}):`);
-            for (const learning of items) {
-                console.log(`     [${learning.confidence.toFixed(2)}] ${learning.summary}`);
-            }
-        }
-        return learnings;
-    }
-    async handleConfig(args) {
+    handleConfig(args) {
         const [subcommand, ...subArgs] = args;
         switch (subcommand) {
             case "show":
@@ -395,15 +86,11 @@ class UnifiedCLI {
         }
     }
     handleConfigShow() {
-        console.log(`⚙️  Current Configuration:`);
-        console.log(`   Workspace: ${this.config.workspace}`);
-        console.log(`   Verbose: ${this.config.verbose}`);
-        console.log(`   Default Mode: ${this.config.defaultMode}`);
+        console.log("Current configuration:");
+        console.log(`  Workspace: ${this.config.workspace}`);
+        console.log(`  Verbose: ${this.config.verbose}`);
     }
     handleConfigSet(args) {
-        if (args.length < 2) {
-            throw new Error("Usage: ci config set <key> <value>");
-        }
         const [key, value] = args;
         if (!key || value === undefined) {
             throw new Error("Usage: ci config set <key> <value>");
@@ -414,13 +101,10 @@ class UnifiedCLI {
         else if (key === "verbose") {
             this.config.verbose = value === "true";
         }
-        else if (key === "defaultMode") {
-            this.config.defaultMode = value;
-        }
         else {
             throw new Error(`Unknown config key: ${key}`);
         }
-        console.log(`✅ Configuration updated: ${key} = ${value}`);
+        console.log(`Configuration updated: ${key} = ${value}`);
     }
 }
 function parseGlobalOptions(args) {
@@ -428,34 +112,19 @@ function parseGlobalOptions(args) {
     for (let i = 0; i < args.length; i++) {
         const flag = args[i];
         const next = args[i + 1];
-        const consumeValue = (key) => {
-            if (next === undefined)
-                return;
-            options[key] = next;
-            args.splice(i, 2);
-            i--;
-        };
         switch (flag) {
             case "--workspace":
-                consumeValue("workspace");
+                if (next !== undefined) {
+                    options.workspace = next;
+                    args.splice(i, 2);
+                    i--;
+                }
                 break;
             case "--verbose":
                 options.verbose = true;
                 args.splice(i, 1);
                 i--;
                 break;
-            case "--repo":
-                consumeValue("repo");
-                break;
-            case "--product":
-                consumeValue("product");
-                break;
-            case "--industry":
-                consumeValue("industry");
-                break;
-            case "--target-market":
-                consumeValue("targetMarket");
-                break;
             default:
                 break;
         }
@@ -464,49 +133,25 @@ function parseGlobalOptions(args) {
 }
 async function main() {
     const [, , command, ...args] = process.argv;
-    if (!command || command === "--help" || command === "-h") {
+    if (!command || command === "--help" || command === "-h" || command === "help") {
         console.log(`
-Unified Continuous Improvement CLI
+CLI-Anything (ci) - turn a repository into an agent-native CLI
 
 Usage: ci <command> [args] [options]
 
-Main Commands:
-  init <name> <objective>        Initialize new project with comprehensive analysis
-  workflow <name> <objective>    Run complete end-to-end workflow
-  research                       Execute research phase
-  planning                       Execute planning phase
-  execution                      Execute execution phase
-  review                         Execute review phase
-  status                         Show project status
-
-Tool Commands:
-  cli generate <repo-path>       Generate CLI for repository
-  pm analyze                     Run comprehensive PM analysis
-  pm skill <name>                Execute specific PM skill
-  pm list                        List available PM skills
-  compound session <name> <obj>  Start compound engineering session
-  compound learnings             Show compound engineering learnings
-  learnings search <query>       Search through all learnings
-  learnings all                  Show all learnings
-
-Configuration:
-  config show                    Show current configuration
-  config set <key> <value>       Set configuration value
+Commands:
+  generate <repo-path>      Analyze a repository and generate an agent-native CLI wrapper
+  list                      Show CLI-Anything capabilities
+  config show               Show current configuration
+  config set <key> <value>  Set a configuration value (workspace | verbose)
 
 Global Options:
-  --workspace <dir>              Workspace directory
-  --verbose                      Enable verbose logging
-  --repo <path>                  Repository path for CLI generation
-  --product <json>               Product information as JSON
-  --industry <name>              Industry name
-  --target-market <json>         Target market as JSON
+  --workspace <dir>         Workspace directory (default: ./ci-workspace)
+  --verbose                 Enable verbose logging
 
 Examples:
-  ci init "MyApp" "Build a task management app"
-  ci workflow "MyApp" "Build task management" --repo ./my-app
-  ci cli generate ./my-repo
-  ci pm analyze --industry "SaaS" --target-market '{"segment":"SMB"}'
-  ci learnings search "performance"
+  ci generate ./my-repo
+  ci config set workspace ./out
 `);
         process.exit(0);
     }
@@ -515,18 +160,18 @@ Examples:
     try {
         const result = await cli.runCommand(command, args, options);
         if (options.verbose && result) {
-            console.log(`\n🔍 Detailed result:`);
+            console.log("\nDetailed result:");
             console.log(JSON.stringify(result, null, 2));
         }
     }
     catch (error) {
-        console.error(`❌ Error: ${getErrorMessage(error)}`);
+        console.error(`Error: ${getErrorMessage(error)}`);
         process.exit(1);
     }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
     main().catch((error) => {
-        console.error(`❌ Fatal error: ${getErrorMessage(error)}`);
+        console.error(`Fatal error: ${getErrorMessage(error)}`);
         process.exit(1);
     });
 }

package/commands/harvest.md

@@ -65,7 +65,7 @@ Appended 12 instinct(s) to /Users/.../instincts/0af156594b39/instincts.jsonl
 If `tool_complete rows: 0`, the bash-fallback hook is active (no jq AND the Node observer is not on PATH) and only emits `tool_start` events. Two remediation paths:
 
 - **Install jq** — `winget install jqlang.jq` (Windows), `brew install jq` (macOS), `apt install jq` (Linux).
-- **Wire the Node observer** — ensure `hooks/bin/observe.mjs` is reachable from the active hook script.
+- **Wire the Node observer** — ensure the installed observer shim `instincts/bin/observe.mjs` (copied from `bin/observe.mjs`) sits beside the active hook script.
 
 Both are documented in the WARNING the classifier prints on a thin-schema host.
 

package/commands/model-forward.md

@@ -0,0 +1,13 @@
+---
+name: model-forward
+description: Restate the model-forward stance — go with Claude, not against it; skills are scaffolding; the durable core is goal-driven execution plus guardrails.
+---
+
+# /model-forward
+
+Load the `model-forward` skill and apply its stance to the current session.
+
+1. Restate the two invariants: goal-driven execution (anchor on the highest stated goal) and self-discipline guardrails (the 7 Laws).
+2. Audit the current task for places where custom scaffolding fights a native Claude Code capability; list each with the native alternative.
+3. Apply the decision rules from the skill before adding any new skill, hook, or wrapper to the workflow.
+4. Close with one line naming which native capability was preferred, which scaffold (if any) was proposed for retirement, and that the operator decides.

package/commands/production-readiness-review.md

@@ -0,0 +1,53 @@
+---
+name: production-readiness-review
+description: "Parallel multi-agent readiness gate — fan blind reviewers across performance, security, UI/UX, and test coverage, each grounding findings in real code/logs/live data, then reconcile into one deduplicated, severity-ranked punch-list. Reports only; never fixes, merges, or deploys."
+---
+
+# /production-readiness-review
+
+The review-side sibling of `/ship`. Fans a set of blind, specialized reviewers across distinct dimensions, then reconciles their findings into a single prioritized punch-list. It reports — it does not fix. Fixing a finding is a separate `/ship` run.
+
+Pure routing over existing skills and agents. Adds no new code.
+
+## Usage
+
+```
+/production-readiness-review [scope]
+```
+
+`scope` defaults to the current branch diff against `origin/main`. Pass a path or PR number to narrow it.
+
+## Behavior
+
+1. **Scope** — establish ground truth: the diff under review and which changes are recent (`git diff`; `reconcile` fallback for branch/base state). Recent changes get extra scrutiny because they are the likeliest source of self-inflicted defects.
+2. **Fan out** — `superpowers:dispatching-parallel-agents` launches four reviewers, each blind to the others. Every reviewer is instructed to ground each finding in real code, logs, or live queries, and never to assume or fabricate state:
+   - **Performance & bundle-size** — hot paths, N+1 queries, unbounded work, regressions.
+   - **Security & data-access** (`security-auditor`) — authn/authz, input handling, injection, secret exposure, unsafe data access.
+   - **UI/UX correctness** — verified live with Playwright when the MCP is available, else static review of the changed surface.
+   - **Test coverage & flaky/stale mocks** (`test-engineer`) — uncovered branches, stale mocks, timing-flaky tests.
+3. **Reconcile** — a final pass dedupes findings across reviewers, ranks each CRITICAL / HIGH / MEDIUM / LOW by severity and confidence, and explicitly flags any defect introduced by the changes under review.
+4. **Present** — emit the consolidated punch-list, severity-ranked, with file references. **Stop.**
+
+## Hard stops (report, never act)
+
+- Does not fix, edit, commit, merge, or deploy anything — output is a punch-list only.
+- A reviewer that cannot ground a finding marks it `unverified` rather than asserting it.
+- If a dimension's tooling is unavailable (e.g. no Playwright MCP), it says so rather than silently skipping coverage.
+
+## Anti-patterns this command refuses
+
+- **Fabricated state.** No finding may rest on an assumed SHA, row, or log line — ground it or mark it `unverified`.
+- **Silent skip.** A dimension that cannot run is reported as not-run, never dropped from the summary.
+- **Drive-by fix.** Findings become `/ship` tasks; this command does not touch code.
+
+## Composition
+
+Routes through: `reconcile` (scope/ground truth) → `superpowers:dispatching-parallel-agents` (fan-out) → the `security-auditor` and `test-engineer` agents (two of the four dimensions) → a reconciliation pass that ranks and dedupes. Each step falls back to its inline behavior when the preferred skill or agent is not installed.
+
+## Example
+
+```
+/production-readiness-review #246
+```
+
+Scopes PR #246's diff, fans four blind reviewers across performance, security, UI/UX, and test coverage, then returns one deduplicated severity-ranked punch-list — flagging anything the PR's own changes introduced — and stops for you to prioritize.