supermind-claude 2.1.0 → 4.0.1

package/hooks/improvement-logger.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+// Improvement Logger Hook — logs session git activity to JSONL
+// Fires on: Stop (async)
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execFileSync } = require("child_process");
+
+const LOG_FILE = path.join(os.homedir(), ".claude", "improvement-log.jsonl");
+const MAX_SIZE = 10 * 1024 * 1024; // 10MB
+
+function gitExec(args, cwd) {
+  return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+}
+
+function getGitInfo(projectDir) {
+  const info = { branch: null, commits: [], filesChanged: 0 };
+
+  try {
+    info.branch = gitExec(["rev-parse", "--abbrev-ref", "HEAD"], projectDir);
+  } catch {
+    // silently skip
+  }
+
+  try {
+    const logOutput = gitExec(
+      ["log", "--oneline", "--since=4 hours ago"],
+      projectDir
+    );
+    info.commits = logOutput
+      ? logOutput.split("\n").filter((line) => line.length > 0)
+      : [];
+  } catch {
+    // silently skip
+  }
+
+  try {
+    const diffOutput = gitExec(
+      ["diff", "--name-only", "HEAD~1", "HEAD"],
+      projectDir
+    );
+    info.filesChanged = diffOutput
+      ? diffOutput.split("\n").filter((line) => line.length > 0).length
+      : 0;
+  } catch {
+    try {
+      const diffOutput = gitExec(["diff", "--name-only"], projectDir);
+      info.filesChanged = diffOutput
+        ? diffOutput.split("\n").filter((line) => line.length > 0).length
+        : 0;
+    } catch {
+      // silently skip
+    }
+  }
+
+  return info;
+}
+
+function rotateLogs() {
+  try {
+    const stats = fs.statSync(LOG_FILE);
+    if (stats.size > MAX_SIZE) {
+      fs.renameSync(LOG_FILE, LOG_FILE + ".1");
+    }
+  } catch {
+    // file doesn't exist or stat failed — no rotation needed
+  }
+}
+
+function main() {
+  const projectDir = process.env.PROJECT_DIR || process.cwd();
+  const sessionId = process.env.SESSION_ID || "unknown";
+
+  const gitInfo = getGitInfo(projectDir);
+
+  const entry = {
+    timestamp: new Date().toISOString(),
+    project: projectDir,
+    branch: gitInfo.branch,
+    sessionId,
+    commits: gitInfo.commits,
+    filesChanged: gitInfo.filesChanged,
+  };
+
+  try {
+    rotateLogs();
+    fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + "\n");
+  } catch {
+    // Non-critical — silently fail
+  }
+}
+
+main();

package/hooks/pre-merge-checklist.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+// PostToolUse hook — advisory warnings before merging into main/master.
+// Fires after any Bash command containing "git merge".
+// Never blocks — outputs warnings only.
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function gitExec(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', timeout: 10000 }).trim();
+}
+
+function isMergingToMainOrMaster(command) {
+  // Match "git merge" anywhere in the command (handles compound cmds)
+  if (!/\bgit\b.*\bmerge\b/.test(command)) return false;
+
+  // After "merge" keyword, find the target branch token
+  const afterMerge = command.replace(/^[\s\S]*?\bmerge\b/, '').trim();
+  const tokens = afterMerge.split(/\s+/).filter(t => t && !t.startsWith('-') && !t.startsWith('"') && !t.startsWith("'"));
+  for (const token of tokens) {
+    const bare = token.replace(/^[^/]+\//, ''); // strip "origin/" prefix
+    if (bare === 'main' || bare === 'master') return true;
+  }
+  return false;
+}
+
+function getTargetBranch(command) {
+  const afterMerge = command.replace(/^[\s\S]*?\bmerge\b/, '').trim();
+  const tokens = afterMerge.split(/\s+/).filter(t => t && !t.startsWith('-'));
+  for (const token of tokens) {
+    const bare = token.replace(/^[^/]+\//, '');
+    if (bare === 'main' || bare === 'master') return token;
+  }
+  return 'main';
+}
+
+// ─── Check 1: ARCHITECTURE.md in branch diff ─────────────────────────────────
+
+function checkLivingDocs(projectDir, targetBranch) {
+  try {
+    const diffOutput = gitExec(['diff', '--name-only', `${targetBranch}...HEAD`], projectDir);
+    const changedFiles = diffOutput.split('\n').map(f => f.trim()).filter(Boolean);
+    const archChanged = changedFiles.some(f => f === 'ARCHITECTURE.md' || f.endsWith('/ARCHITECTURE.md'));
+    if (!archChanged) {
+      return 'ARCHITECTURE.md not updated in this branch';
+    }
+  } catch {
+    // Diff failed (e.g., no common history) — skip check
+  }
+  return null;
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+function main() {
+  let input = '';
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(input || '{}');
+      const command = data.tool_input?.command || '';
+
+      // Only fire on git merge commands targeting main/master
+      if (!command.includes('git') || !command.includes('merge')) {
+        process.stdout.write('{}');
+        return;
+      }
+
+      if (!isMergingToMainOrMaster(command)) {
+        process.stdout.write('{}');
+        return;
+      }
+
+      const projectDir = process.env.PROJECT_DIR || process.cwd();
+      const targetBranch = getTargetBranch(command);
+      const warnings = [];
+
+      // Check 1: ARCHITECTURE.md in diff
+      try {
+        const livingDocsWarning = checkLivingDocs(projectDir, targetBranch);
+        if (livingDocsWarning) warnings.push(livingDocsWarning);
+      } catch {
+        // skip
+      }
+
+      if (warnings.length === 0) {
+        process.stdout.write('{}');
+      } else {
+        process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'PostToolUse', warnings } }));
+      }
+    } catch {
+      // Hook errors must never surface — exit silently
+      process.stdout.write('{}');
+    }
+  });
+}
+
+main();

package/hooks/session-start.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Session Start Hook — loads previous session context + living docs summaries
 // Fires on: SessionStart
-// Outputs combined context: session summary + ARCHITECTURE.md + DESIGN.md
+// Outputs combined context: session summary + ARCHITECTURE.md + DESIGN.md + .planning/
 
 const fs = require("fs");
 const path = require("path");
@@ -10,6 +10,36 @@ const os = require("os");
 const SESSION_DIR = path.join(os.homedir(), ".claude", "sessions");
 const MAX_AGE_DAYS = 7;
 
+// ─── Path safety ────────────────────────────────────────────────────────────
+
+/**
+ * Validate that each segment is safe (no traversal, not absolute), then join
+ * onto a trusted base via string concatenation. This satisfies semgrep
+ * taint-tracking rules for path.join/path.resolve with untrusted input.
+ * NOTE: Duplicated from cli/lib/planning.js — hooks run standalone and cannot
+ * import from cli/lib/. Keep both copies in sync.
+ */
+function safeJoin(trustedBase, ...segments) {
+  for (const seg of segments) {
+    if (typeof seg !== "string" || seg.length === 0) {
+      throw new Error("safeJoin: segment must be a non-empty string");
+    }
+    if (path.isAbsolute(seg)) {
+      throw new Error("safeJoin: segment must not be an absolute path");
+    }
+    for (const part of seg.split(/[\\/]/)) {
+      if (part === "..") {
+        throw new Error("safeJoin: path traversal not allowed");
+      }
+    }
+  }
+  const joined = trustedBase + path.sep + segments.join(path.sep);
+  if (!joined.startsWith(trustedBase + path.sep)) {
+    throw new Error("safeJoin: resolved path escapes base directory");
+  }
+  return joined;
+}
+
 // ─── Session loading ─────────────────────────────────────────────────────────
 
 function getLatestSession(projectDir) {
@@ -18,7 +48,7 @@ function getLatestSession(projectDir) {
   const files = fs.readdirSync(SESSION_DIR)
     .filter(f => f.endsWith(".json"))
     .map(f => {
-      const filepath = path.join(SESSION_DIR, f);
+      const filepath = safeJoin(SESSION_DIR, f);
       const stat = fs.statSync(filepath);
       return { filepath, mtime: stat.mtimeMs };
     })
@@ -96,7 +126,7 @@ function formatLivingDocs(projectDir) {
   const parts = [];
 
   // ARCHITECTURE.md — always check
-  const archPath = path.join(projectDir, "ARCHITECTURE.md");
+  const archPath = safeJoin(projectDir, "ARCHITECTURE.md");
   if (fs.existsSync(archPath)) {
     try {
       const content = fs.readFileSync(archPath, "utf-8");
@@ -108,7 +138,7 @@ function formatLivingDocs(projectDir) {
   }
 
   // DESIGN.md — only if it exists
-  const designPath = path.join(projectDir, "DESIGN.md");
+  const designPath = safeJoin(projectDir, "DESIGN.md");
   if (fs.existsSync(designPath)) {
     try {
       const content = fs.readFileSync(designPath, "utf-8");
@@ -124,7 +154,7 @@ function formatLivingDocs(projectDir) {
 
 function checkProjectHealth(projectDir) {
   const missing = [];
-  if (!fs.existsSync(path.join(projectDir, "CLAUDE.md"))) {
+  if (!fs.existsSync(safeJoin(projectDir, "CLAUDE.md"))) {
     missing.push("CLAUDE.md");
   }
   if (missing.length > 0) {
@@ -133,6 +163,76 @@ function checkProjectHealth(projectDir) {
   return null;
 }
 
+// ─── Planning session detection ─────────────────────────────────────────────
+
+function formatPlanningContext(projectDir) {
+  const planningDir = safeJoin(projectDir, ".planning");
+  if (!fs.existsSync(planningDir)) return null;
+
+  try {
+    // Read roadmap to find active phase
+    const roadmapPath = safeJoin(planningDir, "roadmap.md");
+    if (!fs.existsSync(roadmapPath)) {
+      return "[Planning] Active .planning/ directory detected (initializing)";
+    }
+
+    const roadmapContent = fs.readFileSync(roadmapPath, "utf-8");
+    const phases = [];
+    for (const line of roadmapContent.split("\n")) {
+      const match = line.match(/^\|\s*(\d+)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*$/);
+      if (match && match[2].trim()) {
+        phases.push({
+          phase: parseInt(match[1], 10),
+          status: match[2].trim(),
+          description: match[3].trim(),
+        });
+      }
+    }
+
+    if (phases.length === 0) {
+      return "[Planning] Active .planning/ directory detected (no phases yet)";
+    }
+
+    const completed = phases.filter(p => p.status === "completed").length;
+    const active = phases.find(p => p.status !== "completed" && p.status !== "skipped");
+
+    if (!active) {
+      return `[Planning] All ${phases.length} phases completed`;
+    }
+
+    // Read progress.md from the active phase — validate phase number
+    const phaseNum = Number(active.phase);
+    if (!Number.isInteger(phaseNum) || phaseNum < 1) {
+      return "[Planning] Active .planning/ directory detected (invalid phase number)";
+    }
+    const phasesDir = safeJoin(planningDir, "phases");
+    const phaseDir = safeJoin(phasesDir, `phase-${phaseNum}`);
+    const progressPath = safeJoin(phaseDir, "progress.md");
+    let progressSummary = "";
+    if (fs.existsSync(progressPath)) {
+      const progressContent = fs.readFileSync(progressPath, "utf-8");
+      const entries = [];
+      for (const line of progressContent.split("\n")) {
+        const match = line.match(/^\|\s*(\d+)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*$/);
+        if (match) {
+          entries.push({ wave: parseInt(match[1], 10), status: match[3].trim() });
+        }
+      }
+      if (entries.length > 0) {
+        const done = entries.filter(e => e.status === "completed").length;
+        const currentWave = Math.max(
+          ...entries.filter(e => e.status !== "completed").map(e => e.wave).concat([0])
+        );
+        progressSummary = `, Wave ${currentWave}, ${done}/${entries.length} tasks complete`;
+      }
+    }
+
+    return `[Planning] Active planning session detected — Phase ${phaseNum} (${active.description})${progressSummary} [${completed}/${phases.length} phases done]`;
+  } catch {
+    return "[Planning] Active .planning/ directory detected (could not read state)";
+  }
+}
+
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 function main() {
@@ -153,6 +253,10 @@ function main() {
     const docsContext = formatLivingDocs(projectDir);
     if (docsContext) outputParts.push(docsContext);
 
+    // Planning session awareness
+    const planningContext = formatPlanningContext(projectDir);
+    if (planningContext) outputParts.push(planningContext);
+
     console.log(outputParts.join("\n---\n"));
   } catch (err) {
     console.log("[Session] Hook error: " + err.message);

package/hooks/statusline-command.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 // Claude Code status line — sleek terminal aesthetic
-// Two-line display with box-drawing chars, context bar gradient, subagent tracking
+// Two-line display: identity + context bar, wave progress + executors + cost
+// Reads .planning/ state for wave progress, context-metrics.json for enhanced context display
 
 const { execSync } = require("child_process");
-const { readFileSync, statSync, openSync, readSync, closeSync } = require("fs");
+const { readFileSync, writeFileSync, statSync, existsSync, openSync, readSync, closeSync } = require("fs");
 const { join } = require("path");
 
 let input = "";
@@ -22,12 +23,12 @@ process.stdin.on("end", () => {
   let cwd = data?.workspace?.current_dir || data?.cwd || process.cwd();
   let cwdUnix = cwd.replace(/\\/g, "/");
   const home = (process.env.HOME || process.env.USERPROFILE || "").replace(/\\/g, "/");
-  let cwdDisplay = cwdUnix;
-  if (home && cwdDisplay.startsWith(home)) cwdDisplay = "~" + cwdDisplay.slice(home.length);
-
   const model = data?.model?.display_name || process.env.CLAUDE_MODEL_NAME || "";
 
   // Git branch (symbolic-ref with short hash fallback)
+  // Note: execSync is used here with hardcoded commands only (no user input),
+  // so shell injection is not a concern. This is a status line hook with no
+  // interactive input — all values come from process.env or the Claude Code data pipe.
   let gitBranch = "";
   try {
     gitBranch = execSync("git symbolic-ref --short HEAD", {
@@ -122,6 +123,78 @@ process.stdin.on("end", () => {
   const windowSize = data?.context_window?.context_window_size;
   const cost = process.env.CLAUDE_SESSION_COST_USD;
 
+  // ─── Write context metrics for context-monitor hook ─────────────────────
+
+  let percentRemaining = null;
+  if (usedPct != null && windowSize) {
+    percentRemaining = Math.round((100 - usedPct) * 10) / 10;
+    try {
+      const metricsPath = join(process.env.HOME || process.env.USERPROFILE, ".claude", "context-metrics.json");
+      writeFileSync(metricsPath, JSON.stringify({
+        percentRemaining,
+        tokensUsed: usedTokens || 0,
+        tokensTotal: windowSize,
+        timestamp: Date.now(),
+      }));
+    } catch {}
+  }
+
+  // ─── Wave progress (from .planning/) ────────────────────────────────────
+
+  let waveProgress = null;
+  try {
+    const planningDir = join(cwdUnix, ".planning");
+    if (existsSync(planningDir)) {
+      // Find active phase from roadmap.md
+      const roadmapPath = join(planningDir, "roadmap.md");
+      if (existsSync(roadmapPath)) {
+        const roadmapContent = readFileSync(roadmapPath, "utf8");
+        const roadmapLines = roadmapContent.split("\n");
+        let activePhase = null;
+        for (const line of roadmapLines) {
+          const match = line.match(/^\|\s*(\d+)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*$/);
+          if (match && match[2].trim() !== "completed" && match[2].trim() !== "skipped") {
+            activePhase = parseInt(match[1], 10);
+            break;
+          }
+        }
+
+        if (activePhase != null) {
+          const progressPath = join(planningDir, "phases", `phase-${activePhase}`, "progress.md");
+          if (existsSync(progressPath)) {
+            const progressContent = readFileSync(progressPath, "utf8");
+            const entries = [];
+            for (const line of progressContent.split("\n")) {
+              const match = line.match(/^\|\s*(\d+)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|\s*$/);
+              if (match) {
+                entries.push({
+                  wave: parseInt(match[1], 10),
+                  status: match[3].trim(),
+                });
+              }
+            }
+
+            if (entries.length > 0) {
+              const totalTasks = entries.length;
+              const doneTasks = entries.filter(e => e.status === "completed").length;
+              const maxWave = Math.max(...entries.map(e => e.wave));
+              // Use the lowest incomplete wave as "current"
+              const incompleteWaves = entries.filter(e => e.status !== "completed").map(e => e.wave);
+              const currentWave = incompleteWaves.length > 0 ? Math.min(...incompleteWaves) : maxWave;
+
+              waveProgress = {
+                currentWave,
+                totalWaves: maxWave,
+                doneTasks,
+                totalTasks,
+              };
+            }
+          }
+        }
+      }
+    }
+  } catch {}
+
   // ─── Helpers ────────────────────────────────────────────────────────────
 
   function fmt(n) {
@@ -136,37 +209,37 @@ process.stdin.on("end", () => {
 
   // 256-color ANSI sequences
   const c = (n) => `\x1b[38;5;${n}m`;
-  const bg = (n) => `\x1b[48;5;${n}m`;
   const R = "\x1b[0m";
   const BOLD = "\x1b[1m";
-  const DIM = "\x1b[2m";
 
   // Palette
   const TEAL   = c(80);   // user@host
   const ROSE   = c(204);  // model
-  const AMBER  = c(215);  // path
   const MINT   = c(114);  // branch
-  const SKY    = c(117);  // ctx bar filled
   const SLATE  = c(239);  // ctx bar empty / separators
   const LILAC  = c(183);  // thinking
   const CORAL  = c(209);  // supabase
   const GRAY   = c(245);  // labels
   const WHITE  = c(255);  // bright text
   const DKGRAY = c(237);  // box chars
+  const GREEN  = c(114);  // context bar >50% remaining
+  const YELLOW = c(220);  // context bar 25-50% remaining
+  const RED    = c(196);  // context bar <25% remaining
 
-  // ─── Progress bar (teal -> sky -> rose gradient at 75%) ─────────────────
+  // ─── Context bar (color-coded by remaining capacity) ────────────────────
 
-  function progressBar(pct, width = 20) {
-    const filled = Math.round((pct / 100) * width);
+  function contextBar(usedPercent, width = 10) {
+    const filled = Math.round((usedPercent / 100) * width);
     const empty = width - filled;
-    // Gradient: low=teal, mid=sky, high=rose
-    let barColor = SKY;
-    if (pct > 75) barColor = c(204);
-    else if (pct > 50) barColor = c(220);
-
-    const filledStr = barColor + "\u2501".repeat(filled);
-    const emptyStr = SLATE + "\u2501".repeat(empty);
-    return filledStr + emptyStr + R;
+    const remaining = 100 - usedPercent;
+
+    // Color by remaining capacity: green >50%, yellow 25-50%, red <25%
+    let barColor;
+    if (remaining > 50) barColor = GREEN;
+    else if (remaining >= 25) barColor = YELLOW;
+    else barColor = RED;
+
+    return `${SLATE}[${R}${barColor}${"\u2588".repeat(filled)}${SLATE}${"\u2591".repeat(empty)}${R}${SLATE}]${R}`;
   }
 
   // ─── Separators ─────────────────────────────────────────────────────────
@@ -174,24 +247,44 @@ process.stdin.on("end", () => {
   const SEP = `${DKGRAY}  \u2502  ${R}`;
   const DOT = `${DKGRAY} \u00b7 ${R}`;
 
-  // ─── Line 1: identity + location ────────────────────────────────────────
+  // ─── Line 1: identity + branch + context bar ───────────────────────────
 
   let line1 = `${DKGRAY}\u256d${R} `;
   line1 += `${TEAL}${BOLD}${user}${R}${GRAY}@${R}${TEAL}${host}${R}`;
   if (model) line1 += `${SEP}${ROSE}${model}${R}`;
-  line1 += `${SEP}${AMBER}${cwdDisplay}${R}`;
-  if (gitBranch) line1 += `${DOT}${MINT}${BOLD}${gitBranch}${R}`;
+  if (gitBranch) line1 += `${SEP}${MINT}${BOLD}${gitBranch}${R}`;
+
+  if (usedPct != null) {
+    const pct = Math.round(usedPct);
+    const remaining = 100 - pct;
+    const bar = contextBar(pct);
+
+    // Color the percentage by remaining capacity
+    let pctColor;
+    if (remaining > 50) pctColor = GREEN;
+    else if (remaining >= 25) pctColor = YELLOW;
+    else pctColor = RED;
 
-  // ─── Line 2: metrics ───────────────────────────────────────────────────
+    line1 += `${SEP}${bar} ${pctColor}${BOLD}${pct}%${R}`;
+  }
+
+  // ─── Line 2: wave progress + executors + cost ──────────────────────────
 
   let line2 = `${DKGRAY}\u2570${R} `;
   const parts2 = [];
 
-  if (usedPct != null) {
-    const pct = Math.round(usedPct);
-    const bar = progressBar(pct);
+  // Token counts (compact)
+  if (usedTokens != null && windowSize) {
+    parts2.push(
+      `${WHITE}${fmt(usedTokens)}${R}${GRAY}/${R}${WHITE}${fmt(windowSize)}${R}${GRAY} tokens${R}`,
+    );
+  }
+
+  // Wave progress (only when .planning/ has active progress)
+  if (waveProgress) {
+    const VIOLET = c(141);
     parts2.push(
-      `${bar} ${WHITE}${BOLD}${pct}%${R}${GRAY} ctx${R}${DOT}${WHITE}${fmt(usedTokens)}${R}${GRAY}/${R}${WHITE}${fmt(windowSize)}${R}`,
+      `${VIOLET}\u25b8 Wave ${waveProgress.currentWave}/${waveProgress.totalWaves}${R}${DOT}${WHITE}${waveProgress.doneTasks}/${waveProgress.totalTasks}${R}${GRAY} tasks${R}`,
     );
   }
 
@@ -204,6 +297,7 @@ process.stdin.on("end", () => {
     parts2.push(`${CORAL}\u25c8 ${R}${GRAY}sb:${R}${CORAL}${supabaseRef}${R}`);
   }
 
+  // Active executors / agents
   if (activeAgents.length) {
     const CYAN = c(81);
     const names = activeAgents
@@ -214,7 +308,7 @@ process.stdin.on("end", () => {
         Math.floor(Date.now() / 100) % 10
       ];
     parts2.push(
-      `${CYAN}${spinner} ${activeAgents.length} agent${activeAgents.length > 1 ? "s" : ""}${R}${GRAY}: ${names}${R}`,
+      `${CYAN}${spinner} ${activeAgents.length} executor${activeAgents.length > 1 ? "s" : ""}${R}${GRAY}: ${names}${R}`,
     );
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supermind-claude",
-  "version": "2.1.0",
-  "description": "Complete, opinionated Claude Code setup — hooks, skills, status line, MCP servers, and living documentation",
+  "version": "4.0.1",
+  "description": "Unified skill engine for Claude Code — execution infrastructure meets behavioral discipline",
   "bin": {
     "supermind-claude": "cli/index.js",
     "supermind": "cli/index.js"
@@ -10,8 +10,10 @@
     "cli/",
     "hooks/",
     "skills/",
+    "agents/",
     "templates/",
     "airis/",
+    ".claude-plugin/",
     ".env.example"
   ],
   "keywords": [

package/skills/anti-rationalization/SKILL.md

@@ -0,0 +1,38 @@
+<!-- Forked from obra/superpowers (MIT license) by Jesse Vincent and Prime Radiant. Adapted for Supermind executor injection. -->
+---
+name: anti-rationalization
+description: Blocks common LLM rationalizations for skipping steps — injected into all executors
+injects_into: [all]
+forked_from: obra/superpowers (MIT)
+---
+
+# Anti-Rationalization
+
+**These are not suggestions. They are constraints.** The executor follows them or fails the completion contract.
+
+## The Rule
+
+If you catch yourself rationalizing why a step can be skipped, that is the step most likely to matter.
+
+## Common Rationalizations
+
+| Rationalization | Reality |
+|----------------|---------|
+| "This is too simple to need tests" | Simple code with tests stays simple. Simple code without tests becomes complex bugs. |
+| "I'll just do this one quick thing" | Quick things done carelessly create slow debugging later. |
+| "The user didn't ask for tests" | The completion contract requires tests. Follow the contract. |
+| "I can skip verification, it obviously works" | Obvious correctness is the most common source of bugs. Verify. |
+| "This refactor doesn't need tests since behavior isn't changing" | Refactors without tests have no proof behavior was preserved. |
+| "Let me just fix this real quick without investigating" | Fixes without investigation are guesses. Investigate first. |
+| "I know what the problem is" | Knowing is not proving. Show evidence. |
+| "This is just a config change" | Config changes can break everything. Verify the system still works. |
+
+## How to Apply
+
+When you form a thought that matches any rationalization above — or any thought that argues for skipping a required step:
+
+1. **Stop.** Recognize it as a rationalization.
+2. **Do the step anyway.** The rationalization is evidence the step matters.
+3. **If the step turns out to be unnecessary,** it cost seconds. If skipping it introduced a bug, it costs minutes or hours.
+
+The cost of doing an "unnecessary" step is always lower than the cost of skipping a necessary one.