@plumpslabs/kuma 2.4.3 → 2.4.4

package/dist/index.js

@@ -302,7 +302,20 @@ function flushDb(db) {
     }
     const data = d.export();
     const buffer = Buffer.from(data);
-    fs2.writeFileSync(dbPath, buffer);
+    const tmpPath = path2.join(
+      kumaDir,
+      `${DB_FILENAME}.tmp.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString("hex")}`
+    );
+    fs2.writeFileSync(tmpPath, buffer);
+    try {
+      fs2.renameSync(tmpPath, dbPath);
+    } catch {
+      fs2.writeFileSync(dbPath, buffer);
+      try {
+        if (fs2.existsSync(tmpPath)) fs2.unlinkSync(tmpPath);
+      } catch {
+      }
+    }
   } catch (err) {
     console.error(`[KumaDB] Failed to flush database: ${err}`);
   }
@@ -347,7 +360,7 @@ function createSchema(db) {
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     source_id TEXT NOT NULL REFERENCES nodes(id),
     target_id TEXT NOT NULL REFERENCES nodes(id),
-    type TEXT NOT NULL CHECK(type IN ('calls','imports','defines','tests','routes','implements','extends','depends_on','owns','modified_by','contains','composes','flows_through','triggers','syncs_with','affects')),
+    type TEXT NOT NULL CHECK(type IN ('calls','imports','defines','tests','routes','implements','extends','depends_on','owns','modified_by','contains','composes','flows_through','triggers','syncs_with','affects','explains')),
     weight REAL DEFAULT 1.0,
     metadata TEXT DEFAULT '{}',
     created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
@@ -356,13 +369,13 @@ function createSchema(db) {
   try {
     const schema = db.exec(`SELECT sql FROM sqlite_master WHERE type='table' AND name='edges'`);
     const edgeSql = schema[0]?.values?.[0]?.[0] || "";
-    if (edgeSql.includes("flows_through") === false) {
+    if (edgeSql.includes("explains") === false) {
       db.run(`ALTER TABLE edges RENAME TO edges_old`);
       db.run(`CREATE TABLE IF NOT EXISTS edges (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         source_id TEXT NOT NULL REFERENCES nodes(id),
         target_id TEXT NOT NULL REFERENCES nodes(id),
-        type TEXT NOT NULL CHECK(type IN ('calls','imports','defines','tests','routes','implements','extends','depends_on','owns','modified_by','contains','composes','flows_through','triggers','syncs_with','affects')),
+        type TEXT NOT NULL CHECK(type IN ('calls','imports','defines','tests','routes','implements','extends','depends_on','owns','modified_by','contains','composes','flows_through','triggers','syncs_with','affects','explains')),
         weight REAL DEFAULT 1.0,
         metadata TEXT DEFAULT '{}',
         created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
@@ -586,8 +599,10 @@ function createSchema(db) {
       content_hash TEXT,
       trigger_command TEXT,
       status TEXT NOT NULL DEFAULT 'active'
-        CHECK(status IN ('active','resolved')),
-      last_verified_at INTEGER
+        CHECK(status IN ('candidate','active','verified','resolved','deprecated')),
+      last_verified_at INTEGER,
+      scope_package TEXT,
+      verified_by TEXT
     );
   `);
   try {
@@ -605,6 +620,37 @@ function createSchema(db) {
     if (!cols.includes("last_verified_at")) {
       db.run(`ALTER TABLE known_gotchas ADD COLUMN last_verified_at INTEGER`);
     }
+    if (!cols.includes("scope_package")) {
+      db.run(`ALTER TABLE known_gotchas ADD COLUMN scope_package TEXT`);
+    }
+    if (!cols.includes("verified_by")) {
+      db.run(`ALTER TABLE known_gotchas ADD COLUMN verified_by TEXT`);
+    }
+    const schema = db.exec(`SELECT sql FROM sqlite_master WHERE type='table' AND name='known_gotchas'`);
+    const gotchaSql = schema[0]?.values?.[0]?.[0] || "";
+    if (gotchaSql && !gotchaSql.includes("candidate")) {
+      db.run(`ALTER TABLE known_gotchas RENAME TO known_gotchas_old`);
+      db.run(`CREATE TABLE IF NOT EXISTS known_gotchas (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        file_path TEXT NOT NULL,
+        description TEXT NOT NULL,
+        severity TEXT NOT NULL DEFAULT 'medium'
+          CHECK(severity IN ('low','medium','high','critical')),
+        workaround TEXT,
+        added_by TEXT DEFAULT 'agent',
+        created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+        updated_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+        content_hash TEXT,
+        trigger_command TEXT,
+        status TEXT NOT NULL DEFAULT 'active'
+          CHECK(status IN ('candidate','active','verified','resolved','deprecated')),
+        last_verified_at INTEGER,
+        scope_package TEXT,
+        verified_by TEXT
+      )`);
+      db.run(`INSERT OR IGNORE INTO known_gotchas (id, file_path, description, severity, workaround, added_by, created_at, updated_at, content_hash, trigger_command, status, last_verified_at) SELECT id, file_path, description, severity, workaround, added_by, created_at, updated_at, content_hash, trigger_command, status, last_verified_at FROM known_gotchas_old`);
+      db.run(`DROP TABLE known_gotchas_old`);
+    }
   } catch {
   }
   db.exec(`CREATE INDEX IF NOT EXISTS idx_gotchas_file ON known_gotchas(file_path)`);
@@ -1042,7 +1088,7 @@ async function runGarbageCollection() {
     if (benchCount > 100) {
       db.exec(`DELETE FROM benchmarks WHERE id IN (SELECT id FROM benchmarks ORDER BY created_at ASC LIMIT ${benchCount - 100})`);
     }
-    db.exec(`DELETE FROM known_gotchas WHERE file_path NOT IN (SELECT DISTINCT file_path FROM nodes WHERE file_path IS NOT NULL) AND file_path NOT LIKE '%::%'`);
+    db.exec(`DELETE FROM known_gotchas WHERE status = 'deprecated' AND updated_at < strftime('%s','now', '-30 days')`);
     const costCount = getCount("SELECT COUNT(*) FROM cost_tracking");
     if (costCount > 500) {
       db.exec(`DELETE FROM cost_tracking WHERE id IN (SELECT id FROM cost_tracking ORDER BY created_at ASC LIMIT ${costCount - 500})`);
@@ -1260,6 +1306,7 @@ var init_sessionMemory = __esm({
       init(config) {
         const kumaDir = path3.join(config.projectRoot, ".kuma");
         const sessionFile = path3.join(kumaDir, "memory.json");
+        const currentGitBranch = this.detectCurrentBranch(config.projectRoot);
         const oldFile = path3.join(kumaDir, ".kuma-memory.json");
         if (fs3.existsSync(oldFile) && !fs3.existsSync(sessionFile)) {
           try {
@@ -1280,10 +1327,15 @@ var init_sessionMemory = __esm({
           try {
             const raw = fs3.readFileSync(sessionFile, "utf-8");
             const parsed = JSON.parse(raw);
+            const storedBranch = parsed.currentBranch;
+            const branchSwitched = Boolean(storedBranch && currentGitBranch && storedBranch !== currentGitBranch);
             this.state = {
               projectRoot: parsed.projectRoot || config.projectRoot,
               startTime: parsed.startTime || config.startTime,
               currentGoal: parsed.currentGoal || "",
+              currentBranch: currentGitBranch || storedBranch || void 0,
+              previousBranch: branchSwitched ? storedBranch : parsed.previousBranch,
+              branchSwitched,
               completedSteps: parsed.completedSteps || [],
               modifiedFiles: new Map(parsed.modifiedFiles || []),
               failedFiles: new Map(parsed.failedFiles || []),
@@ -1305,6 +1357,9 @@ var init_sessionMemory = __esm({
           projectRoot: config.projectRoot,
           startTime: config.startTime,
           currentGoal: "",
+          currentBranch: currentGitBranch || void 0,
+          previousBranch: void 0,
+          branchSwitched: false,
           completedSteps: [],
           modifiedFiles: /* @__PURE__ */ new Map(),
           failedFiles: /* @__PURE__ */ new Map(),
@@ -1454,6 +1509,9 @@ No unresolved issues.`;
             projectRoot: this.state.projectRoot,
             startTime: this.state.startTime,
             currentGoal: this.state.currentGoal,
+            currentBranch: this.state.currentBranch,
+            previousBranch: this.state.previousBranch,
+            branchSwitched: this.state.branchSwitched,
             completedSteps: this.state.completedSteps,
             modifiedFiles: Array.from(this.state.modifiedFiles.entries()),
             failedFiles: Array.from(this.state.failedFiles.entries()),
@@ -1464,7 +1522,18 @@ No unresolved issues.`;
             recordings: this.state.recordings,
             metrics: this.state.metrics
           };
-          fs3.writeFileSync(path3.join(kumaDir, "memory.json"), JSON.stringify(serialized, null, 2), "utf-8");
+          const finalPath = path3.join(kumaDir, "memory.json");
+          const tmpPath = path3.join(kumaDir, `memory.json.tmp.${process.pid}.${Date.now()}`);
+          fs3.writeFileSync(tmpPath, JSON.stringify(serialized, null, 2), "utf-8");
+          try {
+            fs3.renameSync(tmpPath, finalPath);
+          } catch {
+            fs3.writeFileSync(finalPath, JSON.stringify(serialized, null, 2), "utf-8");
+            try {
+              if (fs3.existsSync(tmpPath)) fs3.unlinkSync(tmpPath);
+            } catch {
+            }
+          }
         } catch (err) {
           console.error(`[SessionMemory] Failed to save session: ${err}`);
         }
@@ -2008,6 +2077,42 @@ No unresolved issues.`;
           return null;
         }
       }
+      /**
+       * Detect current git branch.
+       */
+      detectCurrentBranch(cwd = process.cwd()) {
+        try {
+          return execSync("git rev-parse --abbrev-ref HEAD", {
+            cwd,
+            encoding: "utf-8",
+            timeout: 3e3,
+            stdio: ["ignore", "pipe", "ignore"]
+          }).trim() || null;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Get the active git branch for the current session.
+       */
+      getCurrentBranch() {
+        this.ensureInit();
+        return this.state.currentBranch || this.detectCurrentBranch(this.state.projectRoot);
+      }
+      /**
+       * Check if git branch transitioned since previous session.
+       */
+      getBranchTransition() {
+        this.ensureInit();
+        if (this.state.branchSwitched && this.state.previousBranch && this.state.currentBranch) {
+          return {
+            switched: true,
+            from: this.state.previousBranch,
+            to: this.state.currentBranch
+          };
+        }
+        return null;
+      }
       /**
        * Get changes for selective undo, grouped by session.
        */
@@ -2033,6 +2138,13 @@ No unresolved issues.`;
 });
 
 // src/engine/kumaSelfHeal.ts
+var kumaSelfHeal_exports = {};
+__export(kumaSelfHeal_exports, {
+  autoDeprecateStaleGotchas: () => autoDeprecateStaleGotchas,
+  formatGotchaStalenessReport: () => formatGotchaStalenessReport,
+  healOnQuery: () => healOnQuery,
+  verifyGotchaStaleness: () => verifyGotchaStaleness
+});
 import { execSync as execSync2 } from "child_process";
 import fs4 from "fs";
 import path4 from "path";
@@ -2093,6 +2205,119 @@ async function healOnQuery(filePaths) {
     return { healed: 0 };
   }
 }
+async function verifyGotchaStaleness() {
+  const db = await getDb();
+  const stale = [];
+  try {
+    const rows = db.exec(`
+      SELECT id, metadata FROM nodes WHERE type = 'gotcha'
+    `);
+    if (rows.length === 0) return stale;
+    const columns = rows[0].columns;
+    const filePathIdx = columns.indexOf("metadata");
+    for (const row of rows[0].values) {
+      const nodeId2 = row[0];
+      let metadata = {};
+      try {
+        metadata = JSON.parse(row[filePathIdx]);
+      } catch {
+      }
+      const filePath = metadata.file_path;
+      if (!filePath || filePath.startsWith("search::") || filePath.startsWith("api_route::")) continue;
+      const fullPath = path4.join(getProjectRoot(), filePath);
+      if (!fs4.existsSync(fullPath)) {
+        stale.push({ gotchaId: nodeId2, file_path: filePath, issue: "file_missing" });
+      } else {
+        const desc = metadata.description || "";
+        const symbolMatch = desc.match(/\b(function|class|method|const|let|var|export)\s+(\w+)/i);
+        if (symbolMatch) {
+          const symbolName = symbolMatch[2];
+          try {
+            const content = fs4.readFileSync(fullPath, "utf-8");
+            if (!content.includes(symbolName)) {
+              stale.push({ gotchaId: nodeId2, file_path: filePath, issue: "symbol_missing" });
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return stale;
+}
+function formatGotchaStalenessReport(stale) {
+  if (stale.length === 0) {
+    return "\u2705 **Gotcha Staleness Check** \u2014 All gotcha references are valid.";
+  }
+  const fileMissing = stale.filter((s) => s.issue === "file_missing");
+  const symbolMissing = stale.filter((s) => s.issue === "symbol_missing");
+  const lines = [
+    `\u26A0\uFE0F **Gotcha Staleness Report**`,
+    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+    "",
+    `\u{1F4CA} ${stale.length} stale gotcha${stale.length > 1 ? "s" : ""} found`,
+    fileMissing.length > 0 ? `  \u{1F5D1}\uFE0F ${fileMissing.length} reference${fileMissing.length > 1 ? "s" : ""} deleted file` : "",
+    symbolMissing.length > 0 ? `  \u{1F50D} ${symbolMissing.length} reference${symbolMissing.length > 1 ? "s" : ""} missing symbol` : "",
+    ""
+  ];
+  for (const s of fileMissing.slice(0, 5)) {
+    lines.push(`  \u{1F5D1}\uFE0F \`${s.gotchaId}\` \u2192 file missing: \`${s.file_path}\``);
+  }
+  for (const s of symbolMissing.slice(0, 5)) {
+    lines.push(`  \u{1F50D} \`${s.gotchaId}\` \u2192 symbol missing in \`${s.file_path}\``);
+  }
+  if (stale.length > 5) lines.push(`  ... and ${stale.length - 5} more`);
+  lines.push("");
+  lines.push("\u{1F4A1} Use `kuma_memory({ action: 'delete_node', target: '<gotchaId>' })` to remove obsolete gotchas.");
+  return lines.join("\n");
+}
+async function autoDeprecateStaleGotchas() {
+  const root = getProjectRoot();
+  const details = [];
+  let deprecated = 0;
+  let resolved = 0;
+  try {
+    const db = await getDb();
+    const stmt = db.prepare(`
+      SELECT id, file_path, description, status, content_hash
+      FROM known_gotchas
+      WHERE status IN ('candidate', 'active', 'verified')
+    `);
+    const rows = [];
+    while (stmt.step()) {
+      rows.push(stmt.getAsObject());
+    }
+    stmt.free();
+    for (const g of rows) {
+      if (!g.file_path || g.file_path.startsWith("search::") || g.file_path.startsWith("api_route::")) continue;
+      const fullPath = path4.join(root, g.file_path);
+      if (!fs4.existsSync(fullPath)) {
+        const renamed = findRenamedPath(g.file_path);
+        if (renamed) {
+          db.run(
+            `UPDATE known_gotchas SET file_path = ?, updated_at = strftime('%s','now') WHERE id = ?`,
+            [renamed, g.id]
+          );
+          details.push(`\u{1F504} Migrated gotcha #${g.id} to renamed file: ${renamed}`);
+        } else {
+          db.run(
+            `UPDATE known_gotchas SET status = 'deprecated', verified_by = 'self_heal:file_deleted', updated_at = strftime('%s','now') WHERE id = ?`,
+            [g.id]
+          );
+          deprecated++;
+          details.push(`\u{1F5D1}\uFE0F Deprecated gotcha #${g.id} (${g.file_path}) \u2014 file deleted`);
+        }
+      }
+    }
+    if (deprecated > 0 || details.length > 0) {
+      saveDb();
+    }
+  } catch (err) {
+    details.push(`\u26A0\uFE0F Self-heal gotcha check encountered an issue: ${err}`);
+  }
+  return { deprecated, resolved, details };
+}
 var init_kumaSelfHeal = __esm({
   "src/engine/kumaSelfHeal.ts"() {
     "use strict";
@@ -2486,6 +2711,564 @@ var init_kumaDriftDetector = __esm({
   }
 });
 
+// src/engine/workspaceIntelligence.ts
+var workspaceIntelligence_exports = {};
+__export(workspaceIntelligence_exports, {
+  clearWorkspaceCache: () => clearWorkspaceCache,
+  findPackageForFile: () => findPackageForFile,
+  formatWorkspaceMap: () => formatWorkspaceMap,
+  getAffectedPackages: () => getAffectedPackages,
+  getReverseDependencies: () => getReverseDependencies,
+  getWorkspaceInfo: () => getWorkspaceInfo
+});
+import fs6 from "fs";
+import path7 from "path";
+import fastGlob from "fast-glob";
+function clearWorkspaceCache() {
+  _cachedWorkspaceInfo = null;
+  _cachedRoot = null;
+}
+function parsePnpmWorkspaceGlobs(content) {
+  const globs = [];
+  const lines = content.split("\n");
+  let inPackages = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("packages:")) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      if (trimmed.startsWith("-")) {
+        const cleaned = trimmed.replace(/^-\s*['"]?/, "").replace(/['"]?\s*$/, "").trim();
+        if (cleaned && !cleaned.startsWith("#")) {
+          globs.push(cleaned);
+        }
+      } else if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("-")) {
+        break;
+      }
+    }
+  }
+  return globs.length > 0 ? globs : ["packages/*"];
+}
+function detectWorkspaceType(root) {
+  const pnpmWs = path7.join(root, "pnpm-workspace.yaml");
+  if (fs6.existsSync(pnpmWs)) {
+    try {
+      const content = fs6.readFileSync(pnpmWs, "utf-8");
+      return { type: "pnpm", globs: parsePnpmWorkspaceGlobs(content) };
+    } catch {
+      return { type: "pnpm", globs: ["packages/*"] };
+    }
+  }
+  const rootPkgPath = path7.join(root, "package.json");
+  if (fs6.existsSync(rootPkgPath)) {
+    try {
+      const pkg = JSON.parse(fs6.readFileSync(rootPkgPath, "utf-8"));
+      if (pkg.workspaces) {
+        let globs = [];
+        if (Array.isArray(pkg.workspaces)) {
+          globs = pkg.workspaces;
+        } else if (Array.isArray(pkg.workspaces.packages)) {
+          globs = pkg.workspaces.packages;
+        }
+        const hasYarnLock = fs6.existsSync(path7.join(root, "yarn.lock"));
+        return { type: hasYarnLock ? "yarn" : "npm", globs };
+      }
+    } catch {
+    }
+  }
+  const cargoToml = path7.join(root, "Cargo.toml");
+  if (fs6.existsSync(cargoToml)) {
+    try {
+      const content = fs6.readFileSync(cargoToml, "utf-8");
+      if (content.includes("[workspace]")) {
+        const memberMatch = content.match(/members\s*=\s*\[([^\]]+)\]/);
+        if (memberMatch) {
+          const members = memberMatch[1].split(",").map((s) => s.trim().replace(/['"]/g, "")).filter(Boolean);
+          return { type: "cargo", globs: members };
+        }
+        return { type: "cargo", globs: ["crates/*", "packages/*"] };
+      }
+    } catch {
+    }
+  }
+  const goWork = path7.join(root, "go.work");
+  if (fs6.existsSync(goWork)) {
+    try {
+      const content = fs6.readFileSync(goWork, "utf-8");
+      const uses = Array.from(content.matchAll(/\buse\s+(?:\(\s*([\s\S]*?)\s*\)|([^\s\n]+))/g));
+      const dirs = [];
+      for (const m of uses) {
+        if (m[1]) {
+          dirs.push(...m[1].split(/\s+/).filter(Boolean));
+        } else if (m[2]) {
+          dirs.push(m[2].trim());
+        }
+      }
+      return { type: "go", globs: dirs.length > 0 ? dirs : ["./*"] };
+    } catch {
+    }
+  }
+  return { type: "standalone", globs: [] };
+}
+function loadNodePackage(pkgJsonPath, root, isRoot = false) {
+  try {
+    const content = fs6.readFileSync(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const absPath = path7.dirname(pkgJsonPath);
+    const relPath = path7.relative(root, absPath) || ".";
+    const name = pkg.name || (isRoot ? path7.basename(root) : path7.basename(relPath));
+    const dependencies = Object.keys(pkg.dependencies || {});
+    const devDependencies = Object.keys(pkg.devDependencies || {});
+    const scripts = pkg.scripts || {};
+    let testCommand = void 0;
+    if (scripts.test) {
+      testCommand = scripts.test;
+    }
+    const entryPoints = [];
+    if (pkg.main) entryPoints.push(path7.normalize(pkg.main));
+    if (pkg.module) entryPoints.push(path7.normalize(pkg.module));
+    if (pkg.exports) {
+      if (typeof pkg.exports === "string") {
+        entryPoints.push(path7.normalize(pkg.exports));
+      } else if (typeof pkg.exports === "object") {
+        for (const val of Object.values(pkg.exports)) {
+          if (typeof val === "string") entryPoints.push(path7.normalize(val));
+          else if (val && typeof val === "object") {
+            const def = val.default || val.import;
+            if (typeof def === "string") entryPoints.push(path7.normalize(def));
+          }
+        }
+      }
+    }
+    if (entryPoints.length === 0) {
+      for (const candidate of ["src/index.ts", "src/index.js", "src/main.ts", "src/main.js", "index.ts", "index.js"]) {
+        if (fs6.existsSync(path7.join(absPath, candidate))) {
+          entryPoints.push(candidate);
+          break;
+        }
+      }
+    }
+    return {
+      name,
+      path: relPath,
+      absPath,
+      version: pkg.version,
+      description: pkg.description,
+      scripts,
+      dependencies,
+      devDependencies,
+      internalDependencies: [],
+      // populated later
+      testCommand,
+      entryPoints,
+      isRoot
+    };
+  } catch {
+    return null;
+  }
+}
+async function getWorkspaceInfo(root, forceRefresh = false) {
+  const projectRoot = root || getProjectRoot();
+  if (_cachedWorkspaceInfo && _cachedRoot === projectRoot && !forceRefresh) {
+    return _cachedWorkspaceInfo;
+  }
+  const { type, globs } = detectWorkspaceType(projectRoot);
+  const packages = [];
+  const packageMap = /* @__PURE__ */ new Map();
+  const rootPkgPath = path7.join(projectRoot, "package.json");
+  if (fs6.existsSync(rootPkgPath)) {
+    const rootPkg = loadNodePackage(rootPkgPath, projectRoot, true);
+    if (rootPkg) {
+      packages.push(rootPkg);
+      packageMap.set(rootPkg.name, rootPkg);
+    }
+  }
+  if (globs.length > 0 && type !== "standalone") {
+    const patterns = globs.map((g) => {
+      if (g.endsWith("package.json")) return g;
+      const clean = g.replace(/\/+$/, "");
+      return `${clean}/package.json`;
+    });
+    try {
+      const matches = await fastGlob(patterns, {
+        cwd: projectRoot,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.kuma/**"],
+        onlyFiles: true
+      });
+      for (const match of matches) {
+        const fullPath = path7.join(projectRoot, match);
+        if (path7.normalize(fullPath) === path7.normalize(rootPkgPath)) continue;
+        const pkg = loadNodePackage(fullPath, projectRoot, false);
+        if (pkg) {
+          packages.push(pkg);
+          packageMap.set(pkg.name, pkg);
+        }
+      }
+    } catch {
+    }
+  }
+  const allNames = new Set(packages.map((p) => p.name));
+  for (const pkg of packages) {
+    const combined = /* @__PURE__ */ new Set([...pkg.dependencies, ...pkg.devDependencies]);
+    pkg.internalDependencies = Array.from(combined).filter((dep) => allNames.has(dep) && dep !== pkg.name);
+  }
+  const isWorkspace = packages.length > 1 || type !== "standalone";
+  _cachedWorkspaceInfo = {
+    isWorkspace,
+    type,
+    root: projectRoot,
+    packages,
+    packageMap
+  };
+  _cachedRoot = projectRoot;
+  return _cachedWorkspaceInfo;
+}
+function findPackageForFile(filePath, wsInfo) {
+  const normFile = path7.normalize(filePath);
+  const relFile = path7.isAbsolute(normFile) ? path7.relative(wsInfo.root, normFile) : normFile;
+  let bestMatch = null;
+  let maxLen = -1;
+  for (const pkg of wsInfo.packages) {
+    if (pkg.isRoot) continue;
+    const pkgRel = path7.normalize(pkg.path);
+    if (relFile === pkgRel || relFile.startsWith(pkgRel + path7.sep)) {
+      if (pkgRel.length > maxLen) {
+        maxLen = pkgRel.length;
+        bestMatch = pkg;
+      }
+    }
+  }
+  if (bestMatch) return bestMatch;
+  const rootPkg = wsInfo.packages.find((p) => p.isRoot);
+  return rootPkg || null;
+}
+function getReverseDependencies(pkgName, wsInfo) {
+  const consumers = [];
+  for (const pkg of wsInfo.packages) {
+    if (pkg.name === pkgName) continue;
+    if (pkg.internalDependencies.includes(pkgName)) {
+      consumers.push(pkg);
+    }
+  }
+  return consumers;
+}
+function getAffectedPackages(modifiedFiles, wsInfo) {
+  const directlyModifiedMap = /* @__PURE__ */ new Map();
+  for (const file of modifiedFiles) {
+    const pkg = findPackageForFile(file, wsInfo);
+    if (pkg) {
+      directlyModifiedMap.set(pkg.name, pkg);
+    }
+  }
+  const directlyModified = Array.from(directlyModifiedMap.values());
+  const downstreamMap = /* @__PURE__ */ new Map();
+  const queue = [...directlyModified];
+  const visited = new Set(queue.map((p) => p.name));
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const revDeps = getReverseDependencies(current.name, wsInfo);
+    for (const dep of revDeps) {
+      if (!visited.has(dep.name)) {
+        visited.add(dep.name);
+        downstreamMap.set(dep.name, dep);
+        queue.push(dep);
+      }
+    }
+  }
+  const downstream = Array.from(downstreamMap.values());
+  const allAffected = [...directlyModified, ...downstream];
+  const testCommands = [];
+  if (allAffected.length > 0) {
+    const nonRootPkgs = allAffected.filter((p) => !p.isRoot);
+    const targetPkgs = nonRootPkgs.length > 0 ? nonRootPkgs : allAffected;
+    if (wsInfo.type === "pnpm") {
+      const filterArgs = targetPkgs.map((p) => `--filter "${p.name}"`).join(" ");
+      testCommands.push(`pnpm ${filterArgs} test`);
+    } else if (wsInfo.type === "npm") {
+      const wsArgs = targetPkgs.map((p) => `--workspace="${p.name}"`).join(" ");
+      testCommands.push(`npm test ${wsArgs}`);
+    } else if (wsInfo.type === "yarn") {
+      for (const p of targetPkgs) {
+        testCommands.push(`yarn workspace ${p.name} test`);
+      }
+    } else {
+      for (const p of targetPkgs) {
+        if (p.testCommand) {
+          testCommands.push(`cd ${p.path} && npm test`);
+        }
+      }
+    }
+  }
+  return {
+    directlyModifiedPackages: directlyModified,
+    downstreamPackages: downstream,
+    allAffectedPackages: allAffected,
+    affectedTestCommands: testCommands
+  };
+}
+function formatWorkspaceMap(wsInfo) {
+  if (!wsInfo.isWorkspace || wsInfo.packages.length <= 1) {
+    const rootPkg = wsInfo.packages[0];
+    return [
+      `\u{1F4E6} **Repository Map (Standalone)**`,
+      `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+      `\u2022 Root: \`${path7.basename(wsInfo.root)}\``,
+      rootPkg?.description ? `\u2022 Description: ${rootPkg.description}` : "",
+      rootPkg?.entryPoints?.length ? `\u2022 Entrypoints: ${rootPkg.entryPoints.map((e) => `\`${e}\``).join(", ")}` : "",
+      rootPkg?.scripts?.test ? `\u2022 Test command: \`${rootPkg.scripts.test}\`` : ""
+    ].filter(Boolean).join("\n");
+  }
+  const lines = [
+    `\u{1F4E6} **Workspace Repository Map (${wsInfo.type.toUpperCase()})**`,
+    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+    `Total packages: ${wsInfo.packages.length}`,
+    ""
+  ];
+  for (const pkg of wsInfo.packages) {
+    lines.push(`\u{1F4E6} **${pkg.name}** \`${pkg.path}\``);
+    if (pkg.description) {
+      lines.push(`   \u{1F4DD} ${pkg.description}`);
+    }
+    if (pkg.entryPoints && pkg.entryPoints.length > 0) {
+      lines.push(`   \u{1F3AF} Entry: ${pkg.entryPoints.slice(0, 3).map((e) => `\`${e}\``).join(", ")}`);
+    }
+    if (pkg.internalDependencies && pkg.internalDependencies.length > 0) {
+      lines.push(`   \u{1F517} Internal deps: ${pkg.internalDependencies.map((d) => `\`${d}\``).join(", ")}`);
+    }
+    const consumers = getReverseDependencies(pkg.name, wsInfo);
+    if (consumers.length > 0) {
+      lines.push(`   \u{1F465} Used by: ${consumers.map((c) => `\`${c.name}\``).join(", ")}`);
+    }
+    if (pkg.scripts && pkg.scripts.test) {
+      lines.push(`   \u{1F9EA} Test: \`${pkg.scripts.test}\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+var _cachedWorkspaceInfo, _cachedRoot;
+var init_workspaceIntelligence = __esm({
+  "src/engine/workspaceIntelligence.ts"() {
+    "use strict";
+    init_pathValidator();
+    _cachedWorkspaceInfo = null;
+    _cachedRoot = null;
+  }
+});
+
+// src/engine/impactAnalysis.ts
+var impactAnalysis_exports = {};
+__export(impactAnalysis_exports, {
+  calculateBlastRadius: () => calculateBlastRadius
+});
+import fs7 from "fs";
+import path8 from "path";
+import fastGlob2 from "fast-glob";
+async function findImportingFiles(targetFile, root) {
+  const normTarget = path8.normalize(targetFile);
+  const baseName = path8.basename(normTarget, path8.extname(normTarget));
+  const relTarget = path8.isAbsolute(normTarget) ? path8.relative(root, normTarget) : normTarget;
+  try {
+    const files = await fastGlob2(
+      ["**/*.{ts,tsx,js,jsx,mjs,cjs,py,go,rs}"],
+      {
+        cwd: root,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**", "**/.kuma/**"],
+        onlyFiles: true
+      }
+    );
+    const dependents = [];
+    const importRegex = new RegExp(
+      `(?:import|from|require\\s*\\(|export\\s+.*from)\\s*['"][^'"]*\\b${baseName}(?:\\.[a-zA-Z0-9]+)?['"]`,
+      "i"
+    );
+    for (const f of files) {
+      if (path8.normalize(f) === path8.normalize(relTarget)) continue;
+      const fullPath = path8.join(root, f);
+      try {
+        const content = fs7.readFileSync(fullPath, "utf-8");
+        if (importRegex.test(content)) {
+          dependents.push(f);
+        }
+      } catch {
+      }
+    }
+    return dependents;
+  } catch {
+    return [];
+  }
+}
+async function findRelatedTests(targetFile, root, owningPackage) {
+  const norm = path8.normalize(targetFile);
+  const baseName = path8.basename(norm, path8.extname(norm));
+  const testFiles = [];
+  const testPatterns = [
+    `**/*${baseName}*.test.*`,
+    `**/*${baseName}*.spec.*`,
+    `**/*${baseName}*_test.*`,
+    `**/tests/**/*${baseName}*.*`,
+    `**/test/**/*${baseName}*.*`,
+    `**/__tests__/**/*${baseName}*.*`
+  ];
+  try {
+    const matches = await fastGlob2(testPatterns, {
+      cwd: root,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.kuma/**"],
+      onlyFiles: true
+    });
+    testFiles.push(...matches);
+  } catch {
+  }
+  if (owningPackage && owningPackage.path !== ".") {
+    try {
+      const pkgTests = await fastGlob2(["**/*.{test,spec}.*"], {
+        cwd: path8.join(root, owningPackage.path),
+        ignore: ["**/node_modules/**", "**/dist/**"],
+        onlyFiles: true
+      });
+      for (const pt of pkgTests) {
+        const fullRel = path8.join(owningPackage.path, pt);
+        if (!testFiles.includes(fullRel)) {
+          testFiles.push(fullRel);
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(new Set(testFiles));
+}
+function assessRisk(target, targetType, directDependents, downstreamPackages, affectedTests, owningPackage) {
+  const riskFlags = [];
+  if (/(database|schema|migration|auth|security|safety|guard|policy|payment|secret|billing)/i.test(target)) {
+    riskFlags.push("Security/Critical domain file");
+  }
+  if (owningPackage?.entryPoints.some((e) => target.endsWith(e) || e.includes(target))) {
+    riskFlags.push("Public package entrypoint/export");
+  }
+  if (downstreamPackages.length > 0) {
+    riskFlags.push(`Cross-package impact: ${downstreamPackages.length} consumer package(s) affected`);
+  }
+  if (directDependents.length > 8) {
+    riskFlags.push(`High fan-in: ${directDependents.length} files depend directly on this`);
+  }
+  if (affectedTests.length === 0) {
+    riskFlags.push("No direct test suite found for this target");
+  }
+  if (targetType === "package") {
+    riskFlags.push("Package-level modification scope");
+  }
+  let risk = "low";
+  if (riskFlags.includes("Security/Critical domain file") || downstreamPackages.length > 2 && riskFlags.includes("Public package entrypoint/export")) {
+    risk = "critical";
+  } else if (targetType === "package" || downstreamPackages.length > 0 || directDependents.length > 5 || riskFlags.includes("Public package entrypoint/export")) {
+    risk = "high";
+  } else if (directDependents.length > 0 || riskFlags.includes("No direct test suite found for this target")) {
+    risk = "medium";
+  }
+  return { risk, riskFlags };
+}
+async function calculateBlastRadius(target, options = {}) {
+  const root = options.root || getProjectRoot();
+  const wsInfo = await getWorkspaceInfo(root);
+  let targetType = "file";
+  const isPkg = wsInfo.packages.some((p) => p.name === target);
+  if (isPkg) {
+    targetType = "package";
+  } else if (target.includes("/") || target.includes(".")) {
+    targetType = "file";
+  } else {
+    targetType = "symbol";
+  }
+  let owningPackage = null;
+  if (targetType === "package") {
+    owningPackage = wsInfo.packageMap.get(target) || null;
+  } else {
+    owningPackage = findPackageForFile(target, wsInfo);
+  }
+  const downstreamPackages = [];
+  if (owningPackage && !owningPackage.isRoot) {
+    const rev = getReverseDependencies(owningPackage.name, wsInfo);
+    downstreamPackages.push(...rev.map((p) => p.name));
+  }
+  let directDependents = [];
+  if (targetType === "file" || targetType === "symbol") {
+    directDependents = await findImportingFiles(target, root);
+  }
+  const affectedTests = await findRelatedTests(target, root, owningPackage);
+  const { risk, riskFlags } = assessRisk(
+    target,
+    targetType,
+    directDependents,
+    downstreamPackages,
+    affectedTests,
+    owningPackage
+  );
+  const summaryLines = [
+    `\u{1F3AF} **Impact / Blast Radius: \`${target}\`**`,
+    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+    `\u26A0\uFE0F **Risk Level: ${risk.toUpperCase()}**`,
+    owningPackage ? `\u{1F4E6} Owning package: \`${owningPackage.name}\` (${owningPackage.path})` : ""
+  ];
+  if (riskFlags.length > 0) {
+    summaryLines.push("");
+    summaryLines.push(`\u{1F6A8} **Risk Flags:**`);
+    for (const flag of riskFlags) {
+      summaryLines.push(`  \u2022 ${flag}`);
+    }
+  }
+  if (downstreamPackages.length > 0) {
+    summaryLines.push("");
+    summaryLines.push(`\u{1F310} **Downstream Consumer Packages (${downstreamPackages.length}):**`);
+    for (const dp of downstreamPackages) {
+      summaryLines.push(`  \u2022 \`${dp}\``);
+    }
+  }
+  if (directDependents.length > 0) {
+    summaryLines.push("");
+    summaryLines.push(`\u{1F4C4} **Direct Dependents (${directDependents.length} file(s)):**`);
+    for (const dep of directDependents.slice(0, 6)) {
+      summaryLines.push(`  \u2022 \`${dep}\``);
+    }
+    if (directDependents.length > 6) {
+      summaryLines.push(`  ... and ${directDependents.length - 6} more`);
+    }
+  }
+  if (affectedTests.length > 0) {
+    summaryLines.push("");
+    summaryLines.push(`\u{1F9EA} **Affected Test Suites (${affectedTests.length}):**`);
+    for (const t of affectedTests.slice(0, 5)) {
+      summaryLines.push(`  \u2022 \`${t}\``);
+    }
+    if (affectedTests.length > 5) {
+      summaryLines.push(`  ... and ${affectedTests.length - 5} more`);
+    }
+  } else {
+    summaryLines.push("");
+    summaryLines.push(`\u26A0\uFE0F **No test suites detected for this scope.** Consider adding tests before editing.`);
+  }
+  return {
+    target,
+    targetType,
+    owningPackage,
+    directDependents,
+    downstreamPackages,
+    affectedTests,
+    risk,
+    riskFlags,
+    summary: summaryLines.filter(Boolean).join("\n"),
+    confidence: 0.85
+  };
+}
+var init_impactAnalysis = __esm({
+  "src/engine/impactAnalysis.ts"() {
+    "use strict";
+    init_pathValidator();
+    init_workspaceIntelligence();
+  }
+});
+
 // src/engine/kumaGraph.ts
 var kumaGraph_exports = {};
 __export(kumaGraph_exports, {
@@ -3382,27 +4165,27 @@ async function codebaseSearchFallback(query, limit = 20) {
         if (results.length >= limit || depth > MAX_WALK_DEPTH) return;
         let entries = [];
         try {
-          entries = fs24.readdirSync(dir);
+          entries = fs27.readdirSync(dir);
         } catch {
           return;
         }
         for (const entry of entries) {
           if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "build") continue;
-          const full = path25.join(dir, entry);
+          const full = path28.join(dir, entry);
           try {
-            const stat = fs24.statSync(full);
+            const stat = fs27.statSync(full);
             if (stat.isDirectory()) {
               walk2(full, depth + 1);
             } else if (entry.toLowerCase().includes(query.toLowerCase())) {
-              results.push(path25.relative(root, full));
+              results.push(path28.relative(root, full));
             }
           } catch {
           }
         }
       };
       var walk = walk2;
-      const fs24 = await import("fs");
-      const path25 = await import("path");
+      const fs27 = await import("fs");
+      const path28 = await import("path");
       const root = process.cwd();
       const results = [];
       const MAX_WALK_DEPTH = 8;
@@ -3473,71 +4256,43 @@ async function getGraphStats() {
 }
 async function analyzeImpact(target) {
   try {
-    const db = await getDb();
-    const nodeCount = db.exec("SELECT COUNT(*) as c FROM nodes")[0]?.values[0][0] ?? 0;
-    if (nodeCount === 0) {
-      return await codebaseImpactFallback(target);
-    }
-    const nodeStmt = db.prepare(`
-      SELECT id, name, type, file_path FROM nodes
-      WHERE name LIKE ? OR file_path = ? OR id = ?
-      LIMIT 1
-    `);
-    nodeStmt.bind([`%${target}%`, target, target]);
-    let nodeId2 = "";
-    let nodeName = "";
-    if (nodeStmt.step()) {
-      const row = nodeStmt.getAsObject();
-      nodeId2 = row.id;
-      nodeName = row.name;
-    }
-    nodeStmt.free();
-    if (!nodeId2) {
-      return await codebaseImpactFallback(target);
-    }
-    const refStmt = db.prepare(`
-      SELECT COUNT(*) as cnt, COUNT(DISTINCT CASE WHEN e.source_id != ? THEN e.source_id ELSE e.target_id END) as file_count
-      FROM edges e WHERE e.source_id = ? OR e.target_id = ?
-    `);
-    refStmt.bind([nodeId2, nodeId2, nodeId2]);
-    let references = 0;
-    let files = 0;
-    if (refStmt.step()) {
-      const row = refStmt.getAsObject();
-      references = row.cnt || 0;
-      files = row.file_count || 0;
-    }
-    refStmt.free();
-    let testFiles = 0;
+    const { calculateBlastRadius: calculateBlastRadius2 } = await Promise.resolve().then(() => (init_impactAnalysis(), impactAnalysis_exports));
+    const blast = await calculateBlastRadius2(target);
+    let graphEntryPoints = [];
     try {
-      const testStmt = db.prepare(
-        `SELECT COUNT(*) as cnt FROM edges e JOIN nodes n ON n.id = e.source_id WHERE (e.source_id = ? OR e.target_id = ?) AND n.type = 'test'`
-      );
-      testStmt.bind([nodeId2, nodeId2]);
-      if (testStmt.step()) {
-        testFiles = testStmt.getAsObject().cnt || 0;
+      const db = await getDb();
+      const nodeStmt = db.prepare(`SELECT id FROM nodes WHERE name LIKE ? OR file_path = ? OR id = ? LIMIT 1`);
+      nodeStmt.bind([`%${target}%`, target, target]);
+      if (nodeStmt.step()) {
+        const row = nodeStmt.getAsObject();
+        const entryStmt = db.prepare(`SELECT n.name, COUNT(*) as cnt FROM edges e JOIN nodes n ON n.id = e.target_id WHERE e.target_id = ? GROUP BY n.name ORDER BY cnt DESC LIMIT 5`);
+        entryStmt.bind([row.id]);
+        while (entryStmt.step()) {
+          const erow = entryStmt.getAsObject();
+          graphEntryPoints.push(`${erow.name} (${erow.cnt} refs)`);
+        }
+        entryStmt.free();
       }
-      testStmt.free();
+      nodeStmt.free();
     } catch {
     }
-    const entryStmt = db.prepare(
-      `SELECT n.name, COUNT(*) as cnt FROM edges e JOIN nodes n ON n.id = e.target_id WHERE e.target_id = ? GROUP BY n.name ORDER BY cnt DESC LIMIT 5`
-    );
-    entryStmt.bind([nodeId2]);
-    const entryRows = [];
-    while (entryStmt.step()) {
-      entryRows.push(entryStmt.getAsObject());
-    }
-    entryStmt.free();
-    const entryPoints = [];
-    for (const row of entryRows) {
-      entryPoints.push(`${row.name} (${row.cnt} refs)`);
-    }
-    const risk = references > 20 ? "high" : references > 5 ? "medium" : "low";
-    return { symbol: nodeName, references, files, testFiles, entryPoints, risk };
+    const allEntryPoints = graphEntryPoints.length > 0 ? graphEntryPoints : blast.directDependents.slice(0, 5);
+    return {
+      symbol: target,
+      references: blast.directDependents.length,
+      files: blast.directDependents.length + (blast.downstreamPackages.length > 0 ? blast.downstreamPackages.length : 1),
+      testFiles: blast.affectedTests.length,
+      entryPoints: allEntryPoints,
+      risk: blast.risk,
+      packageName: blast.owningPackage?.name,
+      downstreamPackages: blast.downstreamPackages,
+      affectedTests: blast.affectedTests,
+      riskFlags: blast.riskFlags,
+      summary: blast.summary
+    };
   } catch (err) {
     console.error(`[KumaGraph] Impact analysis failed: ${err}`);
-    return { symbol: target, references: 0, files: 0, testFiles: 0, entryPoints: [], risk: "low" };
+    return await codebaseImpactFallback(target);
   }
 }
 async function codebaseImpactFallback(target) {
@@ -3569,19 +4324,22 @@ async function codebaseImpactFallback(target) {
   }
 }
 function formatImpact(result) {
-  const icon = result.risk === "high" ? "\u{1F534}" : result.risk === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+  if (result.summary) return result.summary;
+  const icon = result.risk === "critical" ? "\u{1F6A8}" : result.risk === "high" ? "\u{1F534}" : result.risk === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
   const lines = [
     `${icon} **Impact Analysis** \u2014 ${result.symbol}`,
     `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
     "",
     `\u{1F4CA} ${result.references} reference(s) across ${result.files} file(s)`,
     `\u{1F9EA} ${result.testFiles} test file(s)`,
+    result.packageName ? `\u{1F4E6} Package: \`${result.packageName}\`` : "",
+    result.downstreamPackages && result.downstreamPackages.length > 0 ? `\u{1F310} Downstream: ${result.downstreamPackages.join(", ")}` : "",
     result.entryPoints.length > 0 ? `
 \u{1F3AF} Entry Points:
   ${result.entryPoints.join("\n  ")}` : "",
     "",
     `\u26A0\uFE0F Risk Level: **${result.risk.toUpperCase()}**`,
-    result.risk === "high" ? "\u{1F4A1} High impact \u2014 review thoroughly before changing." : ""
+    result.risk === "high" || result.risk === "critical" ? "\u{1F4A1} High impact \u2014 review thoroughly before changing." : ""
   ].filter(Boolean);
   return lines.join("\n");
 }
@@ -3786,19 +4544,19 @@ __export(kumaMemory_exports, {
   scoreMemoryRelevance: () => scoreMemoryRelevance,
   shouldRecordDecision: () => shouldRecordDecision
 });
-import fs6 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path9 from "path";
 function scoreMemoryRelevance(context, limit = 5) {
   const results = [];
-  const kumaDir = path7.join(getProjectRoot(), MEMORY_DIR);
-  if (!fs6.existsSync(kumaDir)) return [];
+  const kumaDir = path9.join(getProjectRoot(), MEMORY_DIR);
+  if (!fs8.existsSync(kumaDir)) return [];
   const terms = context.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
   if (terms.length === 0) return [];
   try {
-    const files = fs6.readdirSync(kumaDir).filter((f) => f.endsWith(".md"));
+    const files = fs8.readdirSync(kumaDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       try {
-        const content = fs6.readFileSync(path7.join(kumaDir, file), "utf-8");
+        const content = fs8.readFileSync(path9.join(kumaDir, file), "utf-8");
         const lower = content.toLowerCase();
         let matchCount = 0;
         for (const term of terms) {
@@ -3961,18 +4719,18 @@ __export(domainRules_exports, {
   readLayer: () => readLayer,
   writeLayer: () => writeLayer
 });
-import fs7 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function layerFilePath(layer) {
-  return path8.join(getProjectRoot(), ".kuma", LAYER_FILES[layer].filename);
+  return path10.join(getProjectRoot(), ".kuma", LAYER_FILES[layer].filename);
 }
 function ensureLayerFile(layer) {
   const fp = layerFilePath(layer);
-  if (!fs7.existsSync(fp)) {
+  if (!fs9.existsSync(fp)) {
     const template = layer === "arch_flow" ? ARCH_FLOW_TEMPLATE : GOTCHAS_TEMPLATE;
-    const dir = path8.dirname(fp);
-    if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
-    fs7.writeFileSync(fp, template, "utf-8");
+    const dir = path10.dirname(fp);
+    if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
+    fs9.writeFileSync(fp, template, "utf-8");
     console.error(`[DomainRules] Auto-created ${LAYER_FILES[layer].filename}`);
   }
   return fp;
@@ -3980,7 +4738,7 @@ function ensureLayerFile(layer) {
 function readLayer(layer) {
   try {
     const fp = ensureLayerFile(layer);
-    return fs7.readFileSync(fp, "utf-8");
+    return fs9.readFileSync(fp, "utf-8");
   } catch (err) {
     return `Error reading ${layer}: ${err}`;
   }
@@ -3988,7 +4746,7 @@ function readLayer(layer) {
 function writeLayer(layer, content) {
   try {
     const fp = ensureLayerFile(layer);
-    fs7.writeFileSync(fp, content, "utf-8");
+    fs9.writeFileSync(fp, content, "utf-8");
     const label = LAYER_FILES[layer].label;
     sessionMemory.recordToolCall("kuma_memory", { action: `write_${layer}` });
     return `\u2705 **${label}** updated successfully.`;
@@ -3999,9 +4757,9 @@ function writeLayer(layer, content) {
 function appendToLayer(layer, entry) {
   try {
     const fp = ensureLayerFile(layer);
-    const existing = fs7.readFileSync(fp, "utf-8");
+    const existing = fs9.readFileSync(fp, "utf-8");
     const newContent = existing.trimEnd() + "\n\n" + entry.trim() + "\n";
-    fs7.writeFileSync(fp, newContent, "utf-8");
+    fs9.writeFileSync(fp, newContent, "utf-8");
     return `\u2705 Entry added to **${LAYER_FILES[layer].label}**.`;
   } catch (err) {
     return `\u274C Failed to append: ${err}`;
@@ -4011,29 +4769,33 @@ function getActiveGotchas() {
   const results = [];
   try {
     const fp = ensureLayerFile("gotcha");
-    const content = fs7.readFileSync(fp, "utf-8");
+    const content = fs9.readFileSync(fp, "utf-8");
     const lines = content.split("\n");
     let currentSection = "";
     let currentFilePath = "";
     let currentDesc = "";
     let currentSeverity = "";
+    let currentStatus = "active";
     for (const line of lines) {
       const fileMatch = line.match(/^###\s+(.+?)\s*[—–-]+\s*(.+)/);
       if (fileMatch) {
-        if (currentFilePath) {
+        if (currentFilePath && currentStatus !== "resolved" && currentStatus !== "deprecated") {
           results.push({ filePath: currentFilePath, description: currentDesc, severity: currentSeverity, content: currentSection });
         }
         currentFilePath = fileMatch[1].trim();
         currentDesc = fileMatch[2].trim();
         currentSeverity = "medium";
+        currentStatus = "active";
         currentSection = line + "\n";
         continue;
       }
       const sevMatch = line.match(/- \*\*Severity\*\*:\s*(\w+)/);
       if (sevMatch) currentSeverity = sevMatch[1].toLowerCase();
+      const statusMatch = line.match(/- \*\*Status\*\*:\s*(\w+)/);
+      if (statusMatch) currentStatus = statusMatch[1].toLowerCase();
       currentSection += line + "\n";
     }
-    if (currentFilePath) {
+    if (currentFilePath && currentStatus !== "resolved" && currentStatus !== "deprecated") {
       results.push({ filePath: currentFilePath, description: currentDesc, severity: currentSeverity, content: currentSection });
     }
   } catch {
@@ -4143,8 +4905,8 @@ __export(kumaInject_exports, {
   parseHookInput: () => parseHookInput,
   trackFileEditLoop: () => trackFileEditLoop
 });
-import fs8 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path11 from "path";
 function hashFileContent(filePath) {
   return hashFile(filePath);
 }
@@ -4156,14 +4918,14 @@ function isGotchaFresh(storedHash, currentHash) {
 async function getFreshGotchasForFile(filePath, limit = 5) {
   const root = getProjectRoot();
   try {
-    const dbFile = path9.join(root, ".kuma", "kuma.db");
-    if (fs8.existsSync(dbFile)) {
+    const dbFile = path11.join(root, ".kuma", "kuma.db");
+    if (fs10.existsSync(dbFile)) {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
       const stmt = db.prepare(`
         SELECT id, file_path, description, severity, workaround, content_hash
         FROM known_gotchas
-        WHERE status = 'active'
+        WHERE status IN ('active', 'verified')
           AND (file_path = ? OR ? LIKE ('%' || file_path || '%'))
         ORDER BY
           CASE WHEN file_path = ? THEN 0 ELSE 1 END, -- exact match first
@@ -4188,7 +4950,7 @@ async function getFreshGotchasForFile(filePath, limit = 5) {
   } catch {
   }
   try {
-    if (!fs8.existsSync(path9.join(root, ".kuma"))) return [];
+    if (!fs10.existsSync(path11.join(root, ".kuma"))) return [];
     const { checkFileGotchas: checkFileGotchas2 } = await Promise.resolve().then(() => (init_domainRules(), domainRules_exports));
     const warnings = checkFileGotchas2(filePath);
     if (warnings.length === 0) return [];
@@ -4206,8 +4968,8 @@ async function getFreshGotchasForFile(filePath, limit = 5) {
 async function getFileTrace(filePath, limit = 8) {
   try {
     const root = getProjectRoot();
-    const dbFile = path9.join(root, ".kuma", "kuma.db");
-    if (!fs8.existsSync(dbFile)) return [];
+    const dbFile = path11.join(root, ".kuma", "kuma.db");
+    if (!fs10.existsSync(dbFile)) return [];
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
     const db = await getDb2();
     const stmt = db.prepare(`
@@ -4217,7 +4979,7 @@ async function getFileTrace(filePath, limit = 8) {
       ORDER BY cl.created_at DESC
       LIMIT ?
     `);
-    stmt.bind([`%${path9.basename(filePath)}%`, limit]);
+    stmt.bind([`%${path11.basename(filePath)}%`, limit]);
     const rows = [];
     while (stmt.step()) rows.push(stmt.getAsObject());
     stmt.free();
@@ -4235,7 +4997,7 @@ async function getFileTrace(filePath, limit = 8) {
 function formatFileTrace(entries, filePath) {
   if (entries.length === 0) return "";
   const lines = [
-    `\u{1F570}\uFE0F **Why is ${path9.basename(filePath)} written this way?** \u2014 ${entries.length} change(s) recorded:`
+    `\u{1F570}\uFE0F **Why is ${path11.basename(filePath)} written this way?** \u2014 ${entries.length} change(s) recorded:`
   ];
   for (const e of entries) {
     const date = new Date((e.createdAt || 0) * 1e3).toLocaleDateString("en-US", {
@@ -4251,7 +5013,7 @@ function formatFileTrace(entries, filePath) {
 async function getDecisionsForFile(filePath, limit = 3) {
   try {
     const { scoreMemoryRelevance: scoreMemoryRelevance2 } = await Promise.resolve().then(() => (init_kumaMemory(), kumaMemory_exports));
-    const base = path9.basename(filePath);
+    const base = path11.basename(filePath);
     const scored = scoreMemoryRelevance2(`${filePath} ${base}`, limit);
     return scored.map((m) => `\u{1F4CC} ${m.topic} \u2014 ${m.score}% match (${m.reason})`);
   } catch {
@@ -4279,13 +5041,13 @@ async function getRelevantContext(filePath, goal) {
   if (traceStr) parts.push(traceStr);
   try {
     const root = getProjectRoot();
-    if (fs8.existsSync(path9.join(root, ".kuma", "kuma.db"))) {
+    if (fs10.existsSync(path11.join(root, ".kuma", "kuma.db"))) {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
       const stmt = db.prepare(
         `SELECT COUNT(*) FROM known_gotchas WHERE status = 'resolved' AND file_path LIKE ?`
       );
-      stmt.bind([`%${path9.basename(filePath)}%`]);
+      stmt.bind([`%${path11.basename(filePath)}%`]);
       const found = stmt.step();
       const count = found ? Number(stmt.getAsObject()["COUNT(*)"]) : 0;
       stmt.free();
@@ -4296,7 +5058,7 @@ async function getRelevantContext(filePath, goal) {
   } catch {
   }
   if (gotchas.length > 0) {
-    const scopeHint = path9.basename(path9.dirname(filePath)) || "current change";
+    const scopeHint = path11.basename(path11.dirname(filePath)) || "current change";
     parts.push(
       `\u2705 AFTER editing, verify: kuma_safety({ action: "verify", scope: "${scopeHint}" })`
     );
@@ -4312,11 +5074,11 @@ async function getRelevantContext(filePath, goal) {
 async function getFileSummary2(filePath) {
   try {
     const root = getProjectRoot();
-    const dbFile = path9.join(root, ".kuma", "kuma.db");
-    if (!fs8.existsSync(dbFile)) return null;
+    const dbFile = path11.join(root, ".kuma", "kuma.db");
+    if (!fs10.existsSync(dbFile)) return null;
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
     const db = await getDb2();
-    const base = path9.basename(filePath);
+    const base = path11.basename(filePath);
     const stmt = db.prepare(`
       SELECT
         (SELECT COUNT(*) FROM known_gotchas WHERE status = 'active' AND (file_path = ? OR file_path LIKE ?)) as active_gotchas,
@@ -4394,9 +5156,9 @@ async function getCommandContext(command) {
 }
 function loadHookState(root) {
   try {
-    const fp = path9.join(root, HOOK_STATE_FILE);
-    if (fs8.existsSync(fp)) {
-      return JSON.parse(fs8.readFileSync(fp, "utf-8"));
+    const fp = path11.join(root, HOOK_STATE_FILE);
+    if (fs10.existsSync(fp)) {
+      return JSON.parse(fs10.readFileSync(fp, "utf-8"));
     }
   } catch {
   }
@@ -4404,10 +5166,10 @@ function loadHookState(root) {
 }
 function saveHookState(root, state) {
   try {
-    const fp = path9.join(root, HOOK_STATE_FILE);
-    const dir = path9.dirname(fp);
-    if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
-    fs8.writeFileSync(fp, JSON.stringify(state), "utf-8");
+    const fp = path11.join(root, HOOK_STATE_FILE);
+    const dir = path11.dirname(fp);
+    if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+    fs10.writeFileSync(fp, JSON.stringify(state), "utf-8");
   } catch {
   }
 }
@@ -4441,7 +5203,7 @@ async function trackFileEditLoop(filePath) {
   saveHookState(root, state);
   if (recorded) {
     try {
-      if (!fs8.existsSync(path9.join(root, ".kuma", "kuma.db"))) return entry.count;
+      if (!fs10.existsSync(path11.join(root, ".kuma", "kuma.db"))) return entry.count;
       const { addGotcha: addGotcha2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
       await addGotcha2({
         filePath,
@@ -4478,16 +5240,20 @@ var kumaGotchas_exports = {};
 __export(kumaGotchas_exports, {
   addGotcha: () => addGotcha,
   checkGotchasForFile: () => checkGotchasForFile,
+  deprecateGotcha: () => deprecateGotcha,
   getActiveGotchasForCommand: () => getActiveGotchasForCommand,
+  getGotchasByStatus: () => getGotchasByStatus,
   getInjectionStats: () => getInjectionStats,
   listGotchas: () => listGotchas,
   recordInjection: () => recordInjection,
+  resolveGotcha: () => resolveGotcha,
   resolveGotchasForScope: () => resolveGotchasForScope,
+  setGotchaStatus: () => setGotchaStatus,
   syncGotchasGraph: () => syncGotchasGraph,
   syncGotchasToDb: () => syncGotchasToDb
 });
-import fs9 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path12 from "path";
 async function ensureGotchasSchema() {
   const db = await getDb();
   db.exec(`
@@ -4504,8 +5270,10 @@ async function ensureGotchasSchema() {
       content_hash TEXT,
       trigger_command TEXT,
       status TEXT NOT NULL DEFAULT 'active'
-        CHECK(status IN ('active','resolved')),
-      last_verified_at INTEGER
+        CHECK(status IN ('candidate','active','verified','resolved','deprecated')),
+      last_verified_at INTEGER,
+      scope_package TEXT,
+      verified_by TEXT
     );
     CREATE INDEX IF NOT EXISTS idx_gotchas_file ON known_gotchas(file_path);
     CREATE INDEX IF NOT EXISTS idx_gotchas_severity ON known_gotchas(severity);
@@ -4525,6 +5293,37 @@ async function ensureGotchasSchema() {
     if (!cols.includes("last_verified_at")) {
       db.run(`ALTER TABLE known_gotchas ADD COLUMN last_verified_at INTEGER`);
     }
+    if (!cols.includes("scope_package")) {
+      db.run(`ALTER TABLE known_gotchas ADD COLUMN scope_package TEXT`);
+    }
+    if (!cols.includes("verified_by")) {
+      db.run(`ALTER TABLE known_gotchas ADD COLUMN verified_by TEXT`);
+    }
+    const schema = db.exec(`SELECT sql FROM sqlite_master WHERE type='table' AND name='known_gotchas'`);
+    const gotchaSql = schema[0]?.values?.[0]?.[0] || "";
+    if (gotchaSql && !gotchaSql.includes("candidate")) {
+      db.run(`ALTER TABLE known_gotchas RENAME TO known_gotchas_old`);
+      db.run(`CREATE TABLE IF NOT EXISTS known_gotchas (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        file_path TEXT NOT NULL,
+        description TEXT NOT NULL,
+        severity TEXT NOT NULL DEFAULT 'medium'
+          CHECK(severity IN ('low','medium','high','critical')),
+        workaround TEXT,
+        added_by TEXT DEFAULT 'agent',
+        created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+        updated_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+        content_hash TEXT,
+        trigger_command TEXT,
+        status TEXT NOT NULL DEFAULT 'active'
+          CHECK(status IN ('candidate','active','verified','resolved','deprecated')),
+        last_verified_at INTEGER,
+        scope_package TEXT,
+        verified_by TEXT
+      )`);
+      db.run(`INSERT OR IGNORE INTO known_gotchas (id, file_path, description, severity, workaround, added_by, created_at, updated_at, content_hash, trigger_command, status, last_verified_at) SELECT id, file_path, description, severity, workaround, added_by, created_at, updated_at, content_hash, trigger_command, status, last_verified_at FROM known_gotchas_old`);
+      db.run(`DROP TABLE known_gotchas_old`);
+    }
   } catch {
   }
   saveDb();
@@ -4534,6 +5333,7 @@ async function addGotcha(entry) {
     await ensureGotchasSchema();
     const db = await getDb();
     const severity = entry.severity || "medium";
+    const status = entry.status || "active";
     const contentHash = hashFileContent(entry.filePath);
     const formatted = [
       `### ${entry.filePath} \u2014 ${entry.description}`,
@@ -4541,6 +5341,8 @@ async function addGotcha(entry) {
       `- **Severity**: ${severity}`,
       entry.workaround ? `- **Workaround**: ${entry.workaround}` : "",
       entry.triggerCommand ? `- **Trigger**: when running \`${entry.triggerCommand}\`` : "",
+      entry.status ? `- **Status**: ${entry.status}` : "",
+      entry.scopePackage ? `- **Scope Package**: ${entry.scopePackage}` : "",
       `- **Added**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
     ].filter(Boolean).join("\n");
     const checkStmt = db.prepare(
@@ -4556,13 +5358,13 @@ async function addGotcha(entry) {
     checkStmt.free();
     if (existingId !== null) {
       db.run(
-        `UPDATE known_gotchas SET severity = ?, workaround = ?, content_hash = ?, trigger_command = ?, status = 'active', updated_at = strftime('%s','now') WHERE id = ?`,
-        [severity, entry.workaround || null, contentHash, entry.triggerCommand || null, existingId]
+        `UPDATE known_gotchas SET severity = ?, workaround = ?, content_hash = ?, trigger_command = ?, status = ?, scope_package = coalesce(?, scope_package), verified_by = coalesce(?, verified_by), updated_at = strftime('%s','now') WHERE id = ?`,
+        [severity, entry.workaround || null, contentHash, entry.triggerCommand || null, status, entry.scopePackage || null, entry.verifiedBy || null, existingId]
       );
     } else {
       db.run(
-        `INSERT INTO known_gotchas (file_path, description, severity, workaround, content_hash, trigger_command) VALUES (?, ?, ?, ?, ?, ?)`,
-        [entry.filePath, entry.description, severity, entry.workaround || null, contentHash, entry.triggerCommand || null]
+        `INSERT INTO known_gotchas (file_path, description, severity, workaround, content_hash, trigger_command, status, scope_package, verified_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [entry.filePath, entry.description, severity, entry.workaround || null, contentHash, entry.triggerCommand || null, status, entry.scopePackage || null, entry.verifiedBy || null]
       );
     }
     const mdResult = appendToLayer("gotcha", formatted);
@@ -4614,7 +5416,12 @@ async function listGotchas(params) {
       sql += " AND severity = ?";
       bind.push(params.severity);
     }
-    sql += " AND status = 'active'";
+    if (params.status && params.status !== "all") {
+      sql += " AND status = ?";
+      bind.push(params.status);
+    } else if (!params.status) {
+      sql += " AND status IN ('active', 'verified')";
+    }
     sql += " ORDER BY severity DESC, created_at DESC LIMIT 50";
     const stmt = db.prepare(sql);
     stmt.bind(bind);
@@ -4692,7 +5499,7 @@ async function syncGotchasGraph() {
     const db = await getDb();
     let created = 0;
     const stmt = db.prepare(
-      `SELECT file_path, description, severity, workaround FROM known_gotchas`
+      `SELECT file_path, description, severity, workaround FROM known_gotchas WHERE status IN ('active', 'verified')`
     );
     const rows = [];
     while (stmt.step()) rows.push(stmt.getAsObject());
@@ -4752,7 +5559,7 @@ async function getActiveGotchasForCommand(command) {
     const stmt = db.prepare(
       `SELECT file_path, description, severity, workaround, trigger_command
        FROM known_gotchas
-       WHERE status = 'active' AND trigger_command IS NOT NULL AND length(trigger_command) > 0
+       WHERE status IN ('active', 'verified') AND trigger_command IS NOT NULL AND length(trigger_command) > 0
        ORDER BY
          CASE severity WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 ELSE 3 END
        LIMIT 30`
@@ -4777,8 +5584,8 @@ async function getActiveGotchasForCommand(command) {
 }
 async function recordInjection(params) {
   try {
-    const fp = path10.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs9.existsSync(path10.dirname(fp))) fs9.mkdirSync(path10.dirname(fp), { recursive: true });
+    const fp = path12.join(getProjectRoot(), ".kuma", "injections.jsonl");
+    if (!fs11.existsSync(path12.dirname(fp))) fs11.mkdirSync(path12.dirname(fp), { recursive: true });
     const line = JSON.stringify({
       filePath: params.filePath || null,
       command: params.command || null,
@@ -4787,16 +5594,16 @@ async function recordInjection(params) {
       // conservative estimate: avoided re-research / re-discovery
       at: Date.now()
     });
-    fs9.appendFileSync(fp, line + "\n", "utf-8");
+    fs11.appendFileSync(fp, line + "\n", "utf-8");
   } catch {
   }
 }
 function getInjectionStats(hours = 24) {
   try {
-    const fp = path10.join(getProjectRoot(), ".kuma", "injections.jsonl");
-    if (!fs9.existsSync(fp)) return { count: 0, savedMs: 0 };
+    const fp = path12.join(getProjectRoot(), ".kuma", "injections.jsonl");
+    if (!fs11.existsSync(fp)) return { count: 0, savedMs: 0 };
     const cutoff = Date.now() - hours * 60 * 60 * 1e3;
-    const lines = fs9.readFileSync(fp, "utf-8").split("\n");
+    const lines = fs11.readFileSync(fp, "utf-8").split("\n");
     let count = 0;
     let savedMs = 0;
     for (const line of lines) {
@@ -4815,6 +5622,104 @@ function getInjectionStats(hours = 24) {
     return { count: 0, savedMs: 0 };
   }
 }
+async function setGotchaStatus(id, status, verifiedBy) {
+  try {
+    const db = await getDb();
+    db.run(
+      `UPDATE known_gotchas SET status = ?, verified_by = coalesce(?, verified_by), last_verified_at = strftime('%s','now'), updated_at = strftime('%s','now') WHERE id = ?`,
+      [status, verifiedBy || null, id]
+    );
+    saveDb();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGotchasByStatus(status, limit = 20) {
+  try {
+    const db = await getDb();
+    const stmt = db.prepare(
+      `SELECT id, file_path, description, severity, workaround, status, scope_package, verified_by, updated_at FROM known_gotchas WHERE status = ? ORDER BY updated_at DESC LIMIT ?`
+    );
+    stmt.bind([status, limit]);
+    const rows = [];
+    while (stmt.step()) {
+      rows.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return rows;
+  } catch {
+    return [];
+  }
+}
+async function resolveGotcha(idOrScope, resolutionReason, verifiedBy = "agent") {
+  try {
+    await ensureGotchasSchema();
+    const db = await getDb();
+    let resolved = 0;
+    const isId = typeof idOrScope === "number" || /^\d+$/.test(String(idOrScope).trim());
+    if (isId) {
+      const id = Number(idOrScope);
+      db.run(
+        `UPDATE known_gotchas SET status = 'resolved', verified_by = ?, last_verified_at = strftime('%s','now'), updated_at = strftime('%s','now') WHERE id = ? AND status != 'resolved'`,
+        [verifiedBy, id]
+      );
+      resolved = Number(db.exec("SELECT changes()")[0]?.values?.[0]?.[0] || 0);
+    } else {
+      const scope = String(idOrScope).trim();
+      db.run(
+        `UPDATE known_gotchas SET status = 'resolved', verified_by = ?, last_verified_at = strftime('%s','now'), updated_at = strftime('%s','now') WHERE (file_path = ? OR file_path LIKE ?) AND status != 'resolved'`,
+        [verifiedBy, scope, `%${scope}%`]
+      );
+      resolved = Number(db.exec("SELECT changes()")[0]?.values?.[0]?.[0] || 0);
+    }
+    if (resolved > 0) {
+      saveDb();
+      rebuildFtsIndex();
+      return {
+        resolved,
+        message: `\u2705 Resolved ${resolved} gotcha(s) for "${idOrScope}"${resolutionReason ? `: ${resolutionReason}` : ""}.`
+      };
+    }
+    return { resolved: 0, message: `\u26A0\uFE0F No active gotchas found matching "${idOrScope}".` };
+  } catch (err) {
+    return { resolved: 0, message: `\u274C Failed to resolve gotcha: ${err}` };
+  }
+}
+async function deprecateGotcha(idOrScope, reason) {
+  try {
+    await ensureGotchasSchema();
+    const db = await getDb();
+    let deprecated = 0;
+    const isId = typeof idOrScope === "number" || /^\d+$/.test(String(idOrScope).trim());
+    if (isId) {
+      const id = Number(idOrScope);
+      db.run(
+        `UPDATE known_gotchas SET status = 'deprecated', verified_by = 'deprecation', last_verified_at = strftime('%s','now'), updated_at = strftime('%s','now') WHERE id = ? AND status != 'deprecated'`,
+        [id]
+      );
+      deprecated = Number(db.exec("SELECT changes()")[0]?.values?.[0]?.[0] || 0);
+    } else {
+      const scope = String(idOrScope).trim();
+      db.run(
+        `UPDATE known_gotchas SET status = 'deprecated', verified_by = 'deprecation', last_verified_at = strftime('%s','now'), updated_at = strftime('%s','now') WHERE (file_path = ? OR file_path LIKE ?) AND status != 'deprecated'`,
+        [scope, `%${scope}%`]
+      );
+      deprecated = Number(db.exec("SELECT changes()")[0]?.values?.[0]?.[0] || 0);
+    }
+    if (deprecated > 0) {
+      saveDb();
+      rebuildFtsIndex();
+      return {
+        deprecated,
+        message: `\u{1F9F9} Deprecated ${deprecated} gotcha(s) for "${idOrScope}"${reason ? `: ${reason}` : ""}.`
+      };
+    }
+    return { deprecated: 0, message: `\u26A0\uFE0F No active gotchas found matching "${idOrScope}".` };
+  } catch (err) {
+    return { deprecated: 0, message: `\u274C Failed to deprecate gotcha: ${err}` };
+  }
+}
 var init_kumaGotchas = __esm({
   "src/engine/kumaGotchas.ts"() {
     "use strict";
@@ -4831,29 +5736,34 @@ var kumaMaintenance_exports = {};
 __export(kumaMaintenance_exports, {
   maybeRunAutoCleanup: () => maybeRunAutoCleanup
 });
-import fs10 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path13 from "path";
 async function maybeRunAutoCleanup() {
   try {
     const root = getProjectRoot();
-    const stateFile = path11.join(root, GC_STATE_FILE);
+    const stateFile = path13.join(root, GC_STATE_FILE);
     const now = Date.now();
     let lastRun = 0;
-    if (fs10.existsSync(stateFile)) {
+    if (fs12.existsSync(stateFile)) {
       try {
-        lastRun = JSON.parse(fs10.readFileSync(stateFile, "utf-8")).lastRun || 0;
+        lastRun = JSON.parse(fs12.readFileSync(stateFile, "utf-8")).lastRun || 0;
       } catch {
         lastRun = 0;
       }
     }
     if (now - lastRun < GC_INTERVAL_MS) return "";
-    fs10.mkdirSync(path11.dirname(stateFile), { recursive: true });
-    fs10.writeFileSync(stateFile, JSON.stringify({ lastRun: now }), "utf-8");
+    fs12.mkdirSync(path13.dirname(stateFile), { recursive: true });
+    fs12.writeFileSync(stateFile, JSON.stringify({ lastRun: now }), "utf-8");
     const { syncGotchasToDb: syncGotchasToDb2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
     await syncGotchasToDb2();
     const { runGarbageCollection: runGarbageCollection2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
     const gcResult = await runGarbageCollection2();
-    const summary = gcResult.replace(/\n/g, " ").substring(0, 80);
+    const { autoDeprecateStaleGotchas: autoDeprecateStaleGotchas2 } = await Promise.resolve().then(() => (init_kumaSelfHeal(), kumaSelfHeal_exports));
+    const deprecateRes = await autoDeprecateStaleGotchas2();
+    let summary = gcResult.replace(/\n/g, " ").substring(0, 80);
+    if (deprecateRes.deprecated > 0) {
+      summary += ` (${deprecateRes.deprecated} gotcha(s) auto-deprecated)`;
+    }
     return `\u{1F9F9} ${summary}`;
   } catch {
     return "";
@@ -4879,22 +5789,22 @@ __export(kumaPathRules_exports, {
   loadPathRules: () => loadPathRules,
   matchRulePath: () => matchRulePath
 });
-import fs11 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path14 from "path";
 function rulesDir() {
-  return path12.join(getProjectRoot(), RULES_DIR);
+  return path14.join(getProjectRoot(), RULES_DIR);
 }
 function ensureRulesDir() {
   try {
     const dir = rulesDir();
-    if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+    if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
   } catch {
   }
 }
 function parseRuleFile(filePath) {
   try {
-    const raw = fs11.readFileSync(filePath, "utf-8");
-    const id = path12.basename(filePath, ".md");
+    const raw = fs13.readFileSync(filePath, "utf-8");
+    const id = path14.basename(filePath, ".md");
     const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
     if (!fm) {
       return { id, description: id, paths: ["*"], content: raw.trim(), filePath };
@@ -4919,7 +5829,7 @@ function loadPathRules() {
   ensureRulesDir();
   try {
     const dir = rulesDir();
-    return fs11.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => parseRuleFile(path12.join(dir, f))).filter((r) => r !== null);
+    return fs13.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => parseRuleFile(path14.join(dir, f))).filter((r) => r !== null);
   } catch {
     return [];
   }
@@ -5006,12 +5916,12 @@ __export(kumaCodeScanner_exports, {
   scanAndFormat: () => scanAndFormat,
   scanCodebase: () => scanCodebase
 });
-import fastGlob from "fast-glob";
-import fs12 from "fs";
-import path13 from "path";
+import fastGlob3 from "fast-glob";
+import fs14 from "fs";
+import path15 from "path";
 function getRoot() {
-  if (!_cachedRoot) _cachedRoot = getProjectRoot();
-  return _cachedRoot;
+  if (!_cachedRoot2) _cachedRoot2 = getProjectRoot();
+  return _cachedRoot2;
 }
 function lineAt(content, index) {
   return content.substring(0, index).split("\n").length;
@@ -5019,10 +5929,10 @@ function lineAt(content, index) {
 function getDirectoryDirs(filePaths) {
   const dirs = /* @__PURE__ */ new Set();
   for (const fp of filePaths) {
-    let dir = path13.dirname(fp);
+    let dir = path15.dirname(fp);
     while (dir && dir !== "." && dir !== "/") {
       dirs.add(dir);
-      dir = path13.dirname(dir);
+      dir = path15.dirname(dir);
     }
   }
   return [...dirs].sort();
@@ -5053,7 +5963,7 @@ async function scanCodebase(options = {}) {
   ];
   let files;
   try {
-    files = await fastGlob(includePatterns, {
+    files = await fastGlob3(includePatterns, {
       cwd: root,
       ignore: ignorePatterns,
       onlyFiles: true,
@@ -5072,16 +5982,16 @@ async function scanCodebase(options = {}) {
   const scannedFilePaths = [];
   for (let i = 0; i < scannedCount; i++) {
     const filePath = files[i];
-    const fullPath = path13.join(root, filePath);
-    if (!fs12.existsSync(fullPath)) continue;
-    const stat = fs12.statSync(fullPath);
+    const fullPath = path15.join(root, filePath);
+    if (!fs14.existsSync(fullPath)) continue;
+    const stat = fs14.statSync(fullPath);
     if (stat.size > maxFileSize) continue;
     const mtime = stat.mtimeMs;
     const cached = fileCache.get(filePath);
     if (cached === mtime && !options.force) continue;
     fileCache.set(filePath, mtime);
     try {
-      const content = fs12.readFileSync(fullPath, "utf-8");
+      const content = fs14.readFileSync(fullPath, "utf-8");
       const parsed = parseFile(filePath, content);
       allParsed.push({ filePath, parsed, content });
       scannedFilePaths.push(filePath);
@@ -5124,7 +6034,7 @@ async function scanCodebase(options = {}) {
         });
         result.nodeCount++;
         for (const fp of scannedFilePaths) {
-          if (path13.dirname(fp) === dir) {
+          if (path15.dirname(fp) === dir) {
             const fileId = nodeId("file", fp);
             try {
               await addEdge({ sourceId: moduleId, targetId: fileId, type: "owns" });
@@ -5481,20 +6391,20 @@ async function recordParsedFile(filePath, parsed, content, result) {
 }
 function resolveImportPath(fromFile, importPath, root) {
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) return null;
-  const fromDir = path13.dirname(path13.join(root, fromFile));
+  const fromDir = path15.dirname(path15.join(root, fromFile));
   const exts = [
     ...SOURCE_EXTENSIONS,
     ...SOURCE_EXTENSIONS.map((e) => `/index${e}`)
   ];
   for (const ext of exts) {
-    const resolved = path13.resolve(fromDir, importPath + ext);
-    if (fs12.existsSync(resolved)) return path13.relative(root, resolved);
+    const resolved = path15.resolve(fromDir, importPath + ext);
+    if (fs14.existsSync(resolved)) return path15.relative(root, resolved);
   }
-  const dirPath = path13.resolve(fromDir, importPath);
-  if (fs12.existsSync(dirPath) && fs12.statSync(dirPath).isDirectory()) {
+  const dirPath = path15.resolve(fromDir, importPath);
+  if (fs14.existsSync(dirPath) && fs14.statSync(dirPath).isDirectory()) {
     for (const ext of SOURCE_EXTENSIONS) {
-      const indexPath = path13.join(dirPath, `index${ext}`);
-      if (fs12.existsSync(indexPath)) return path13.relative(root, indexPath);
+      const indexPath = path15.join(dirPath, `index${ext}`);
+      if (fs14.existsSync(indexPath)) return path15.relative(root, indexPath);
     }
   }
   return null;
@@ -5529,7 +6439,7 @@ async function scanAndFormat(options = {}) {
   const result = await scanCodebase(options);
   return formatScanResult(result);
 }
-var DEFAULT_MAX_FILES, DEFAULT_MAX_FILE_SIZE, fileCache, _cachedRoot, FUNCTION_DECL_RE, ARROW_FN_RE, TYPED_ARROW_RE, CLASS_RE, IMPORT_RE, JSX_RETURN_RE, JSX_ELEMENT_RE, JSX_IMPLICIT_RE, EXPRESS_ROUTE_RE, HONO_ROUTE_RE, EXPORT_RE, CALL_RE, knownComponents, knownFunctions, symbolLocations;
+var DEFAULT_MAX_FILES, DEFAULT_MAX_FILE_SIZE, fileCache, _cachedRoot2, FUNCTION_DECL_RE, ARROW_FN_RE, TYPED_ARROW_RE, CLASS_RE, IMPORT_RE, JSX_RETURN_RE, JSX_ELEMENT_RE, JSX_IMPLICIT_RE, EXPRESS_ROUTE_RE, HONO_ROUTE_RE, EXPORT_RE, CALL_RE, knownComponents, knownFunctions, symbolLocations;
 var init_kumaCodeScanner = __esm({
   "src/engine/kumaCodeScanner.ts"() {
     "use strict";
@@ -5539,7 +6449,7 @@ var init_kumaCodeScanner = __esm({
     DEFAULT_MAX_FILES = 200;
     DEFAULT_MAX_FILE_SIZE = 100 * 1024;
     fileCache = /* @__PURE__ */ new Map();
-    _cachedRoot = null;
+    _cachedRoot2 = null;
     FUNCTION_DECL_RE = /(?:export\s+)?(?:async\s+)?function\s*(?:\*\s*)?(\w+)\s*\(/g;
     ARROW_FN_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]\s*(?:async\s*)?(?:<[^>]+>\s*)?(?:\([\s\S]*?\)|\w+)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/g;
     TYPED_ARROW_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*:\s*(?:\w+(?:<[^>]*>)?)?\s*=\s*(?:async\s*)?(?:<[^>]+>\s*)?\(/g;
@@ -5565,8 +6475,8 @@ __export(kumaFlowCache_exports, {
   getFlowFreshness: () => getFlowFreshness,
   getFreshDomainFlow: () => getFreshDomainFlow
 });
-import fs13 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path16 from "path";
 async function getFlowFreshness(domain) {
   try {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
@@ -5601,26 +6511,26 @@ async function getFlowFreshness(domain) {
 }
 function resolveImport(fromFile, spec) {
   const root = getProjectRoot();
-  const fromDir = path14.dirname(fromFile);
+  const fromDir = path16.dirname(fromFile);
   const candidates = [];
   if (spec.startsWith(".")) {
-    const abs = path14.resolve(fromDir, spec);
+    const abs = path16.resolve(fromDir, spec);
     candidates.push(abs);
   } else {
-    candidates.push(path14.join(root, spec));
+    candidates.push(path16.join(root, spec));
   }
   for (const c of candidates) {
     for (const ext of SOURCE_EXTENSIONS) {
       const withExt = `${c}${ext}`;
-      if (fs13.existsSync(withExt)) return path14.relative(root, withExt);
-      if (fs13.existsSync(c) && fs13.statSync(c).isDirectory()) {
-        const idx = path14.join(c, "index") + ext;
-        if (fs13.existsSync(idx)) return path14.relative(root, idx);
+      if (fs15.existsSync(withExt)) return path16.relative(root, withExt);
+      if (fs15.existsSync(c) && fs15.statSync(c).isDirectory()) {
+        const idx = path16.join(c, "index") + ext;
+        if (fs15.existsSync(idx)) return path16.relative(root, idx);
       }
     }
-    if (fs13.existsSync(c)) {
+    if (fs15.existsSync(c)) {
       try {
-        if (fs13.statSync(c).isFile()) return path14.relative(root, c);
+        if (fs15.statSync(c).isFile()) return path16.relative(root, c);
       } catch {
       }
     }
@@ -5629,13 +6539,13 @@ function resolveImport(fromFile, spec) {
 }
 function deriveHopsFromImports(entryFile, maxHops = 6) {
   const root = getProjectRoot();
-  const absEntry = path14.isAbsolute(entryFile) ? entryFile : path14.resolve(root, entryFile);
-  if (!fs13.existsSync(absEntry)) return [];
+  const absEntry = path16.isAbsolute(entryFile) ? entryFile : path16.resolve(root, entryFile);
+  if (!fs15.existsSync(absEntry)) return [];
   const hops = [];
   const seen = /* @__PURE__ */ new Set([entryFile]);
-  const fromName = path14.basename(absEntry);
+  const fromName = path16.basename(absEntry);
   try {
-    const lines = fs13.readFileSync(absEntry, "utf-8").split("\n");
+    const lines = fs15.readFileSync(absEntry, "utf-8").split("\n");
     for (const line of lines) {
       if (hops.length >= maxHops) break;
       const spec = matchImportPath(line);
@@ -5645,9 +6555,9 @@ function deriveHopsFromImports(entryFile, maxHops = 6) {
       seen.add(resolved);
       hops.push({
         from: fromName,
-        to: path14.basename(resolved),
+        to: path16.basename(resolved),
         relation: "imports",
-        description: `${fromName} imports ${path14.basename(resolved)}`
+        description: `${fromName} imports ${path16.basename(resolved)}`
       });
     }
   } catch {
@@ -5679,7 +6589,7 @@ Record one with kuma_memory({ action: 'arch_flow', content: 'domain: ${domain} |
           hops,
           filePaths: freshness.filePaths
         });
-        lines.push(`\u2705 Re-derived ${hops.length} hop(s) from ${path14.basename(entry)} \u2014 cache refreshed.`);
+        lines.push(`\u2705 Re-derived ${hops.length} hop(s) from ${path16.basename(entry)} \u2014 cache refreshed.`);
       } else {
         lines.push("\u26A0\uFE0F No imports to follow \u2014 cache left as-is (record hops manually if needed).");
       }
@@ -5714,8 +6624,8 @@ __export(kumaSearch_exports, {
   formatHybridResults: () => formatHybridResults,
   hybridSearch: () => hybridSearch
 });
-import fs15 from "fs";
-import path16 from "path";
+import fs17 from "fs";
+import path18 from "path";
 function expandQueryTerms(query) {
   const terms = query.toLowerCase().split(/[\s_-]+/).filter((t) => t.length > 2);
   const expanded = /* @__PURE__ */ new Map();
@@ -5778,13 +6688,13 @@ async function buildSearchVectors() {
   }
   try {
     const root = getProjectRoot();
-    const memDir = path16.join(root, ".kuma", "memories");
-    if (fs15.existsSync(memDir)) {
-      const files = fs15.readdirSync(memDir).filter((f) => f.endsWith(".md")).slice(0, SCALE_LIMITS.maxMemoryFiles);
+    const memDir = path18.join(root, ".kuma", "memories");
+    if (fs17.existsSync(memDir)) {
+      const files = fs17.readdirSync(memDir).filter((f) => f.endsWith(".md")).slice(0, SCALE_LIMITS.maxMemoryFiles);
       for (const file of files) {
         try {
-          const fullPath = path16.join(memDir, file);
-          const content = fs15.readFileSync(fullPath, "utf-8");
+          const fullPath = path18.join(memDir, file);
+          const content = fs17.readFileSync(fullPath, "utf-8");
           const text = content.toLowerCase();
           const rawTerms = extractTerms(text);
           const termCounts = /* @__PURE__ */ new Map();
@@ -5795,7 +6705,7 @@ async function buildSearchVectors() {
             terms: termCounts,
             source: file.replace(/\.md$/, ""),
             sourceType: "memory",
-            recency: recencyScore(Math.floor(fs15.statSync(fullPath).mtimeMs / 1e3))
+            recency: recencyScore(Math.floor(fs17.statSync(fullPath).mtimeMs / 1e3))
           });
         } catch {
         }
@@ -6105,6 +7015,137 @@ var init_kumaSearch = __esm({
   }
 });
 
+// src/guards/architectureGuard.ts
+var architectureGuard_exports = {};
+__export(architectureGuard_exports, {
+  checkArchitectureBoundaries: () => checkArchitectureBoundaries,
+  detectWorkspaceCircularDeps: () => detectWorkspaceCircularDeps,
+  loadArchitectureRules: () => loadArchitectureRules
+});
+import fs21 from "fs";
+import path22 from "path";
+import fastGlob4 from "fast-glob";
+function loadArchitectureRules(root) {
+  const rulesPath = path22.join(root, ".kuma", "architecture.json");
+  if (fs21.existsSync(rulesPath)) {
+    try {
+      const data = JSON.parse(fs21.readFileSync(rulesPath, "utf-8"));
+      if (Array.isArray(data.rules)) {
+        return data.rules;
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+function detectWorkspaceCircularDeps(wsInfo) {
+  const circulars = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recStack = /* @__PURE__ */ new Set();
+  function dfs(current, pathTrace) {
+    visited.add(current);
+    recStack.add(current);
+    pathTrace.push(current);
+    const pkg = wsInfo.packageMap.get(current);
+    if (pkg) {
+      for (const dep of pkg.internalDependencies) {
+        if (!visited.has(dep)) {
+          dfs(dep, [...pathTrace]);
+        } else if (recStack.has(dep)) {
+          const cycleStart = pathTrace.indexOf(dep);
+          circulars.push([...pathTrace.slice(cycleStart), dep]);
+        }
+      }
+    }
+    recStack.delete(current);
+  }
+  for (const pkg of wsInfo.packages) {
+    if (!visited.has(pkg.name)) {
+      dfs(pkg.name, []);
+    }
+  }
+  return circulars;
+}
+async function checkArchitectureBoundaries(filesToCheck, customRoot) {
+  const root = customRoot || getProjectRoot();
+  const wsInfo = await getWorkspaceInfo(root);
+  const violations = [];
+  const circulars = detectWorkspaceCircularDeps(wsInfo);
+  for (const cycle of circulars) {
+    violations.push({
+      sourceFile: cycle[0],
+      targetImport: cycle[cycle.length - 1],
+      rule: "circular-package-dependency",
+      severity: "high",
+      suggestion: `Circular dependency detected: ${cycle.join(" \u2192 ")}. Extract shared interfaces to a separate package.`
+    });
+  }
+  let targetFiles = filesToCheck;
+  if (!targetFiles || targetFiles.length === 0) {
+    targetFiles = await fastGlob4(["**/*.{ts,tsx,js,jsx,mjs,cjs}"], {
+      cwd: root,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**", "**/.kuma/**"],
+      onlyFiles: true
+    });
+  }
+  const customRules = loadArchitectureRules(root);
+  const importRegex = /(?:import|export\s+.*from|require\s*\()\s*['"]([^'"]+)['"]/g;
+  for (const file of targetFiles) {
+    const fullPath = path22.isAbsolute(file) ? file : path22.join(root, file);
+    if (!fs21.existsSync(fullPath)) continue;
+    let content = "";
+    try {
+      content = fs21.readFileSync(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const currentPkg = findPackageForFile(file, wsInfo);
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (wsInfo.isWorkspace && currentPkg && !currentPkg.isRoot) {
+        if (importPath.startsWith("../") && (importPath.includes("/src/") || importPath.includes("/dist/"))) {
+          const resolvedTarget = path22.normalize(path22.resolve(path22.dirname(fullPath), importPath));
+          const targetPkg = findPackageForFile(resolvedTarget, wsInfo);
+          if (targetPkg && targetPkg.name !== currentPkg.name) {
+            violations.push({
+              sourceFile: file,
+              targetImport: importPath,
+              rule: "no-deep-cross-package-import",
+              severity: "high",
+              suggestion: `Do not deep-import private files from '${targetPkg.name}'. Use the public package name \`${targetPkg.name}\` or its exported API.`
+            });
+          }
+        }
+      }
+      for (const rule of customRules) {
+        const matchesFrom = file.includes(rule.from) || currentPkg && currentPkg.name === rule.from;
+        if (matchesFrom) {
+          for (const disallowed of rule.disallow) {
+            if (importPath.includes(disallowed) || currentPkg && disallowed === currentPkg.name) {
+              violations.push({
+                sourceFile: file,
+                targetImport: importPath,
+                rule: `disallowed-boundary: ${rule.from} \u2192 ${disallowed}`,
+                severity: "high",
+                suggestion: rule.message || `Import from '${disallowed}' is forbidden in '${rule.from}'.`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return violations;
+}
+var init_architectureGuard = __esm({
+  "src/guards/architectureGuard.ts"() {
+    "use strict";
+    init_pathValidator();
+    init_workspaceIntelligence();
+  }
+});
+
 // src/engine/kumaCheckpoint.ts
 var kumaCheckpoint_exports = {};
 __export(kumaCheckpoint_exports, {
@@ -6113,16 +7154,16 @@ __export(kumaCheckpoint_exports, {
   pruneCheckpoints: () => pruneCheckpoints,
   rollbackToCheckpoint: () => rollbackToCheckpoint
 });
-import fs19 from "fs";
-import path20 from "path";
+import fs22 from "fs";
+import path23 from "path";
 async function createCheckpoint(label, description) {
   try {
     const root = getProjectRoot();
-    const cpDir = path20.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
-    if (fs19.existsSync(cpDir)) {
+    const cpDir = path23.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
+    if (fs22.existsSync(cpDir)) {
       return `\u26A0\uFE0F Checkpoint "${label}" already exists. Use a different label or remove it first.`;
     }
-    fs19.mkdirSync(cpDir, { recursive: true });
+    fs22.mkdirSync(cpDir, { recursive: true });
     const db = await getDb();
     const filesStmt = db.prepare(
       "SELECT DISTINCT file_path FROM change_log ORDER BY id DESC LIMIT 100"
@@ -6131,19 +7172,19 @@ async function createCheckpoint(label, description) {
     while (filesStmt.step()) {
       const row = filesStmt.getAsObject();
       const fp = row.file_path;
-      const fullPath = path20.resolve(root, fp);
-      if (fs19.existsSync(fullPath)) {
-        const content = fs19.readFileSync(fullPath, "utf-8");
+      const fullPath = path23.resolve(root, fp);
+      if (fs22.existsSync(fullPath)) {
+        const content = fs22.readFileSync(fullPath, "utf-8");
         const hash = simpleHash2(content);
-        const fileDir = path20.dirname(path20.join(cpDir, "files", fp));
-        if (!fs19.existsSync(fileDir)) fs19.mkdirSync(fileDir, { recursive: true });
-        fs19.writeFileSync(path20.join(cpDir, "files", fp), content, "utf-8");
+        const fileDir = path23.dirname(path23.join(cpDir, "files", fp));
+        if (!fs22.existsSync(fileDir)) fs22.mkdirSync(fileDir, { recursive: true });
+        fs22.writeFileSync(path23.join(cpDir, "files", fp), content, "utf-8");
         files.push({ path: fp, hash });
       }
     }
     filesStmt.free();
     const dbData = db.export();
-    fs19.writeFileSync(path20.join(cpDir, "kuma.db"), Buffer.from(dbData));
+    fs22.writeFileSync(path23.join(cpDir, "kuma.db"), Buffer.from(dbData));
     const manifest = {
       label,
       timestamp: Date.now(),
@@ -6151,8 +7192,8 @@ async function createCheckpoint(label, description) {
       dbSnapshot: true,
       description
     };
-    fs19.writeFileSync(
-      path20.join(cpDir, "manifest.json"),
+    fs22.writeFileSync(
+      path23.join(cpDir, "manifest.json"),
       JSON.stringify(manifest, null, 2),
       "utf-8"
     );
@@ -6178,39 +7219,39 @@ async function createCheckpoint(label, description) {
 async function rollbackToCheckpoint(label) {
   try {
     const root = getProjectRoot();
-    const cpDir = path20.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
-    const manifestPath = path20.join(cpDir, "manifest.json");
-    if (!fs19.existsSync(manifestPath)) {
+    const cpDir = path23.join(root, CHECKPOINT_DIR, sanitizeLabel(label));
+    const manifestPath = path23.join(cpDir, "manifest.json");
+    if (!fs22.existsSync(manifestPath)) {
       return `\u274C Checkpoint "${label}" not found. Available checkpoints:
 
 ${listCheckpoints()}`;
     }
     const manifest = JSON.parse(
-      fs19.readFileSync(manifestPath, "utf-8")
+      fs22.readFileSync(manifestPath, "utf-8")
     );
     let restored = 0;
     let failed = 0;
     for (const f of manifest.files) {
-      const snapshotPath = path20.join(cpDir, "files", f.path);
-      if (fs19.existsSync(snapshotPath)) {
+      const snapshotPath = path23.join(cpDir, "files", f.path);
+      if (fs22.existsSync(snapshotPath)) {
         try {
-          const content = fs19.readFileSync(snapshotPath, "utf-8");
-          const targetPath = path20.resolve(root, f.path);
-          const targetDir = path20.dirname(targetPath);
-          if (!fs19.existsSync(targetDir)) fs19.mkdirSync(targetDir, { recursive: true });
-          fs19.writeFileSync(targetPath, content, "utf-8");
+          const content = fs22.readFileSync(snapshotPath, "utf-8");
+          const targetPath = path23.resolve(root, f.path);
+          const targetDir = path23.dirname(targetPath);
+          if (!fs22.existsSync(targetDir)) fs22.mkdirSync(targetDir, { recursive: true });
+          fs22.writeFileSync(targetPath, content, "utf-8");
           restored++;
         } catch {
           failed++;
         }
       }
     }
-    const dbSnapshotPath = path20.join(cpDir, "kuma.db");
-    if (fs19.existsSync(dbSnapshotPath)) {
-      const kumaDir = path20.join(root, ".kuma");
-      const dbPath = path20.join(kumaDir, "kuma.db");
-      const snapshotData = fs19.readFileSync(dbSnapshotPath);
-      fs19.writeFileSync(dbPath, snapshotData);
+    const dbSnapshotPath = path23.join(cpDir, "kuma.db");
+    if (fs22.existsSync(dbSnapshotPath)) {
+      const kumaDir = path23.join(root, ".kuma");
+      const dbPath = path23.join(kumaDir, "kuma.db");
+      const snapshotData = fs22.readFileSync(dbSnapshotPath);
+      fs22.writeFileSync(dbPath, snapshotData);
       resetDbInstance();
     }
     sessionMemory.recordToolCall("kuma_checkpoint_rollback", {
@@ -6235,18 +7276,18 @@ ${listCheckpoints()}`;
 function listCheckpoints() {
   try {
     const root = getProjectRoot();
-    const cpDir = path20.join(root, CHECKPOINT_DIR);
-    if (!fs19.existsSync(cpDir)) {
+    const cpDir = path23.join(root, CHECKPOINT_DIR);
+    if (!fs22.existsSync(cpDir)) {
       return "\u{1F4ED} No checkpoints found. Use kuma_safety({ action: 'checkpoint', label: 'pre-feature-x' }) to create one.";
     }
-    const entries = fs19.readdirSync(cpDir);
+    const entries = fs22.readdirSync(cpDir);
     const checkpoints = [];
     for (const entry of entries) {
-      const manifestPath = path20.join(cpDir, entry, "manifest.json");
-      if (fs19.existsSync(manifestPath)) {
+      const manifestPath = path23.join(cpDir, entry, "manifest.json");
+      if (fs22.existsSync(manifestPath)) {
         try {
           const manifest = JSON.parse(
-            fs19.readFileSync(manifestPath, "utf-8")
+            fs22.readFileSync(manifestPath, "utf-8")
           );
           checkpoints.push({ label: entry, manifest });
         } catch {
@@ -6278,12 +7319,12 @@ function listCheckpoints() {
 function pruneCheckpoints(keep = 5) {
   try {
     const root = getProjectRoot();
-    const cpDir = path20.join(root, CHECKPOINT_DIR);
-    if (!fs19.existsSync(cpDir)) return "\u{1F4ED} No checkpoints to prune.";
-    const entries = fs19.readdirSync(cpDir).map((e) => ({ name: e, time: fs19.statSync(path20.join(cpDir, e)).mtimeMs })).sort((a, b) => b.time - a.time);
+    const cpDir = path23.join(root, CHECKPOINT_DIR);
+    if (!fs22.existsSync(cpDir)) return "\u{1F4ED} No checkpoints to prune.";
+    const entries = fs22.readdirSync(cpDir).map((e) => ({ name: e, time: fs22.statSync(path23.join(cpDir, e)).mtimeMs })).sort((a, b) => b.time - a.time);
     let removed = 0;
     for (let i = keep; i < entries.length; i++) {
-      fs19.rmSync(path20.join(cpDir, entries[i].name), { recursive: true, force: true });
+      fs22.rmSync(path23.join(cpDir, entries[i].name), { recursive: true, force: true });
       removed++;
     }
     return removed > 0 ? `\u{1F9F9} Pruned **${removed} old checkpoint(s)**. Kept ${Math.min(keep, entries.length)} most recent.` : "\u2705 No checkpoints needed pruning.";
@@ -6324,16 +7365,16 @@ __export(kumaAutoGotcha_exports, {
   saveAutoGotchaState: () => saveAutoGotchaState,
   trackVerificationResult: () => trackVerificationResult
 });
-import fs20 from "fs";
-import path21 from "path";
+import fs23 from "fs";
+import path24 from "path";
 function statePath() {
-  return path21.join(getProjectRoot(), STATE_FILE);
+  return path24.join(getProjectRoot(), STATE_FILE);
 }
 function loadAutoGotchaState() {
   try {
     const fp = statePath();
-    if (fs20.existsSync(fp)) {
-      const parsed = JSON.parse(fs20.readFileSync(fp, "utf-8"));
+    if (fs23.existsSync(fp)) {
+      const parsed = JSON.parse(fs23.readFileSync(fp, "utf-8"));
       return {
         failures: parsed?.failures ?? {},
         lastRecorded: parsed?.lastRecorded ?? {}
@@ -6346,9 +7387,9 @@ function loadAutoGotchaState() {
 function saveAutoGotchaState(state) {
   try {
     const fp = statePath();
-    const dir = path21.dirname(fp);
-    if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
-    fs20.writeFileSync(fp, JSON.stringify(state, null, 2), "utf-8");
+    const dir = path24.dirname(fp);
+    if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
+    fs23.writeFileSync(fp, JSON.stringify(state, null, 2), "utf-8");
   } catch {
   }
 }
@@ -6388,6 +7429,7 @@ async function trackVerificationResult(scope, passed) {
       filePath: scope,
       description: `Verification keeps failing for scope "${scope}"`,
       severity,
+      status: "candidate",
       workaround: `Run tests locally before touching this area. Failing scope: "${scope}" \u2014 ${failureCount} consecutive failures. Verify with kuma_safety({ action: "verify", scope: "${scope}" }) after fixes.`
     });
     state.lastRecorded[scope] = failureCount;
@@ -6431,37 +7473,37 @@ __export(kumaVerifier_exports, {
   getRunningVerificationPid: () => getRunningVerificationPid,
   runAutoVerification: () => runAutoVerification
 });
-import fs21 from "fs";
-import path22 from "path";
+import fs24 from "fs";
+import path25 from "path";
 import { exec } from "child_process";
 function getLockDir(root = process.cwd()) {
-  return path22.resolve(root, LOCK_DIR_NAME);
+  return path25.resolve(root, LOCK_DIR_NAME);
 }
 function getPidFile(root = process.cwd()) {
-  return path22.join(getLockDir(root), "pid");
+  return path25.join(getLockDir(root), "pid");
 }
 function acquireFileLock(root) {
   const lockDir = getLockDir(root);
   try {
-    fs21.mkdirSync(lockDir, { recursive: false });
-    fs21.writeFileSync(getPidFile(root), String(process.pid), "utf-8");
+    fs24.mkdirSync(lockDir, { recursive: false });
+    fs24.writeFileSync(getPidFile(root), String(process.pid), "utf-8");
     return true;
   } catch {
     try {
-      if (fs21.existsSync(getPidFile(root))) {
-        const pid = parseInt(fs21.readFileSync(getPidFile(root), "utf-8"), 10);
+      if (fs24.existsSync(getPidFile(root))) {
+        const pid = parseInt(fs24.readFileSync(getPidFile(root), "utf-8"), 10);
         try {
           process.kill(pid, 0);
           return false;
         } catch {
-          fs21.rmSync(lockDir, { recursive: true, force: true });
+          fs24.rmSync(lockDir, { recursive: true, force: true });
           return acquireFileLock(root);
         }
       }
     } catch {
     }
     try {
-      fs21.rmSync(lockDir, { recursive: true, force: true });
+      fs24.rmSync(lockDir, { recursive: true, force: true });
       return acquireFileLock(root);
     } catch {
       return false;
@@ -6470,7 +7512,7 @@ function acquireFileLock(root) {
 }
 function releaseFileLock(root) {
   try {
-    fs21.rmSync(getLockDir(root), { recursive: true, force: true });
+    fs24.rmSync(getLockDir(root), { recursive: true, force: true });
   } catch {
   }
 }
@@ -6493,36 +7535,36 @@ function getRunningVerificationPid() {
   return _currentProcess?.pid ?? null;
 }
 function detectTestRunner(root = process.cwd()) {
-  const pkgPath = path22.join(root, "package.json");
-  if (fs21.existsSync(pkgPath)) {
+  const pkgPath = path25.join(root, "package.json");
+  if (fs24.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts && pkg.scripts.test) {
-        if (fs21.existsSync(path22.join(root, "pnpm-lock.yaml"))) return { runner: "pnpm", baseCommand: "pnpm test" };
-        if (fs21.existsSync(path22.join(root, "yarn.lock"))) return { runner: "yarn", baseCommand: "yarn test" };
+        if (fs24.existsSync(path25.join(root, "pnpm-lock.yaml"))) return { runner: "pnpm", baseCommand: "pnpm test" };
+        if (fs24.existsSync(path25.join(root, "yarn.lock"))) return { runner: "yarn", baseCommand: "yarn test" };
         return { runner: "npm", baseCommand: "npm test" };
       }
     } catch {
     }
   }
-  if (fs21.existsSync(path22.join(root, "pytest.ini")) || fs21.existsSync(path22.join(root, "pyproject.toml"))) return { runner: "pytest", baseCommand: "pytest" };
-  if (fs21.existsSync(path22.join(root, "Cargo.toml"))) return { runner: "cargo", baseCommand: "cargo test" };
-  if (fs21.existsSync(path22.join(root, "go.mod"))) return { runner: "go", baseCommand: "go test ./..." };
-  if (fs21.existsSync(path22.join(root, "Makefile"))) {
+  if (fs24.existsSync(path25.join(root, "pytest.ini")) || fs24.existsSync(path25.join(root, "pyproject.toml"))) return { runner: "pytest", baseCommand: "pytest" };
+  if (fs24.existsSync(path25.join(root, "Cargo.toml"))) return { runner: "cargo", baseCommand: "cargo test" };
+  if (fs24.existsSync(path25.join(root, "go.mod"))) return { runner: "go", baseCommand: "go test ./..." };
+  if (fs24.existsSync(path25.join(root, "Makefile"))) {
     try {
-      const makefileContent = fs21.readFileSync(path22.join(root, "Makefile"), "utf-8");
+      const makefileContent = fs24.readFileSync(path25.join(root, "Makefile"), "utf-8");
       const hasTestTarget = /^test:/m.test(makefileContent) || /^\s+test:/.test(makefileContent);
       if (hasTestTarget) return { runner: "make", baseCommand: "make test" };
     } catch {
     }
   }
-  if (fs21.existsSync(path22.join(root, "package.json"))) {
+  if (fs24.existsSync(path25.join(root, "package.json"))) {
     try {
-      const pkg = JSON.parse(fs21.readFileSync(path22.join(root, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs24.readFileSync(path25.join(root, "package.json"), "utf-8"));
       if (pkg.dependencies || pkg.devDependencies) {
-        if (fs21.existsSync(path22.join(root, "tsconfig.json"))) return { runner: "tsc", baseCommand: "npx tsc --noEmit" };
-        const srcDir = path22.join(root, "src");
-        if (fs21.existsSync(srcDir)) return { runner: "node", baseCommand: `node -c "${srcDir}/**/*.js" 2>/dev/null || node --check $(find src -name '*.js' 2>/dev/null | head -5)` };
+        if (fs24.existsSync(path25.join(root, "tsconfig.json"))) return { runner: "tsc", baseCommand: "npx tsc --noEmit" };
+        const srcDir = path25.join(root, "src");
+        if (fs24.existsSync(srcDir)) return { runner: "node", baseCommand: `node -c "${srcDir}/**/*.js" 2>/dev/null || node --check $(find src -name '*.js' 2>/dev/null | head -5)` };
       }
     } catch {
     }
@@ -6600,24 +7642,52 @@ async function runAutoVerification(options = {}) {
         "\u{1F4A1} **Tip:** This is NOT a pass \u2014 it means nothing was verified. Run your tests manually or install a test framework."
       ].join("\n");
     }
+    let fullCommand = baseCommand;
     let testFiles = [];
     const modified = sessionMemory.getModifiedFiles().map((f) => f.filePath);
-    if (options.scope) {
-      const term = options.scope.toLowerCase();
-      testFiles = modified.filter((f) => f.toLowerCase().includes(term));
-      if (testFiles.length === 0) {
-        try {
-          const { default: glob } = await import("fast-glob");
-          testFiles = await glob([`**/*${term}*test*.*`, `**/*test*/*${term}*.*`], { cwd: root, ignore: ["node_modules/**", "dist/**"] });
-        } catch {
+    let workspaceScoped = false;
+    try {
+      const { getWorkspaceInfo: getWorkspaceInfo2, getAffectedPackages: getAffectedPackages2 } = await Promise.resolve().then(() => (init_workspaceIntelligence(), workspaceIntelligence_exports));
+      const wsInfo = await getWorkspaceInfo2(root);
+      if (wsInfo.isWorkspace && modified.length > 0 && !options.scope) {
+        const affected = getAffectedPackages2(modified, wsInfo);
+        if (affected.affectedTestCommands.length > 0) {
+          fullCommand = affected.affectedTestCommands[0];
+          workspaceScoped = true;
         }
       }
-    } else {
-      testFiles = modified.filter((f) => f.includes(".test.") || f.includes(".spec.") || f.includes("_test."));
+    } catch {
     }
-    let fullCommand = baseCommand;
-    if (testFiles.length > 0 && runner === "npm") {
-      fullCommand = `${baseCommand} -- ${testFiles.map((f) => `"${f}"`).join(" ")}`;
+    if (!workspaceScoped) {
+      if (options.scope) {
+        const term = options.scope.toLowerCase();
+        testFiles = modified.filter((f) => f.toLowerCase().includes(term));
+        if (testFiles.length === 0) {
+          try {
+            const { default: glob } = await import("fast-glob");
+            testFiles = await glob([`**/*${term}*test*.*`, `**/*test*/*${term}*.*`], { cwd: root, ignore: ["node_modules/**", "dist/**"] });
+          } catch {
+          }
+        }
+      } else {
+        const directTests = modified.filter((f) => f.includes(".test.") || f.includes(".spec.") || f.includes("_test."));
+        if (directTests.length > 0) {
+          testFiles = directTests;
+        } else if (modified.length > 0) {
+          try {
+            const { default: glob } = await import("fast-glob");
+            for (const f of modified.slice(0, 5)) {
+              const base = path25.basename(f, path25.extname(f));
+              const matches = await glob([`**/*${base}*.test.*`, `**/*${base}*.spec.*`], { cwd: root, ignore: ["node_modules/**", "dist/**"] });
+              testFiles.push(...matches);
+            }
+          } catch {
+          }
+        }
+      }
+      if (testFiles.length > 0 && (runner === "npm" || runner === "pnpm" || runner === "yarn")) {
+        fullCommand = `${baseCommand} -- ${Array.from(new Set(testFiles)).map((f) => `"${f}"`).join(" ")}`;
+      }
     }
     return await new Promise((resolve) => {
       const killTimer = setTimeout(() => {
@@ -6641,7 +7711,7 @@ async function runAutoVerification(options = {}) {
       const heartbeatTimer = setInterval(() => {
         if (getLockDir(root)) {
           try {
-            fs21.writeFileSync(getPidFile(root), String(process.pid), "utf-8");
+            fs24.writeFileSync(getPidFile(root), String(process.pid), "utf-8");
           } catch {
           }
         }
@@ -6761,8 +7831,8 @@ __export(init_exports, {
   generateInitMdContent: () => generateInitMdContent,
   runInit: () => runInit
 });
-import fs22 from "fs";
-import path23 from "path";
+import fs25 from "fs";
+import path26 from "path";
 function configFilePath(type) {
   switch (type) {
     case "claude":
@@ -6860,27 +7930,31 @@ function aiderTemplate() {
 }
 function opencodeAgentsMdTemplate() {
   const opencodeLines = [
-    "Kuma MCP tools: kuma_kuma_context, kuma_kuma_memory, kuma_kuma_safety.",
+    "Kuma MCP tools: kuma_kuma_context (or kuma_context), kuma_kuma_memory (or kuma_memory), kuma_kuma_safety (or kuma_safety).",
     "Record what matters, skip what doesn't.",
     "",
     "<kuma_obedience>",
     "## \u{1F512} Obedience (non-negotiable)",
-    '- MUST call `kuma_kuma_context({ action: "init" })` at session start.',
+    '- MUST call `kuma_kuma_context({ action: "init" })` (or `kuma_context({ action: "init" })`) at session start.',
     "- MUST record gotchas IMMEDIATELY when a bug/quirk is found.",
-    '- MUST call `kuma_kuma_safety({ action: "verify" })` after edits.',
-    "- MUST NOT call actions outside the 13 core actions.",
+    '- MUST call `kuma_kuma_safety({ action: "verify" })` (or `kuma_safety({ action: "verify" })`) after edits.',
+    "- MUST NOT call actions outside the core actions.",
     "</kuma_obedience>",
     "",
     "<kuma_workflow>",
     '\u{1F9E0} **Before coding:** `kuma_kuma_context({ action: "init" })`',
-    '\u{1F52C} **Unfamiliar code:** `kuma_kuma_context({ action: "research", scope: "<area>" })`',
+    '\u{1F5FA}\uFE0F **Monorepo map:** `kuma_kuma_context({ action: "map" })`',
+    '\u{1F52C} **Blast radius / impact:** `kuma_kuma_context({ action: "impact", target: "<file>" })` or `kuma_kuma_context({ action: "research", scope: "<area>" })`',
     '\u{1F41B} **Found a bug/quirk:** `kuma_kuma_memory({ action: "gotcha" })` (IMMEDIATELY)',
     '\u{1F9ED} **Chose between options:** `kuma_kuma_memory({ action: "decision" })`',
     '\u{1F500} **Traced a flow:** `kuma_kuma_memory({ action: "arch_flow" })` (max 5 files)',
     '\u{1F6E1}\uFE0F **Before risky work / after edits:** `kuma_kuma_safety({ action: "guard" | "verify" })`',
     "</kuma_workflow>",
     "",
-    "\u26A0\uFE0F **OpenCode note:** Tool names use `kuma_kuma_*` prefix.",
+    "\u26A0\uFE0F **OpenCode note:** Depending on OpenCode MCP registration, tool names may be prefixed with server name (`kuma_kuma_*`) or bare (`kuma_*`). Both are valid.",
+    "",
+    "### \u{1F375} Companion: Matcha & Kuma Harmony",
+    "If Matcha is active: Matcha provides Intent Discovery (`.agents/plan/current.md`); Kuma provides blast radius, gotchas memory, and test verification.",
     ""
   ].join("\n");
   return [
@@ -6888,7 +7962,8 @@ function opencodeAgentsMdTemplate() {
     "",
     opencodeLines,
     "\u{1F4D6} Rules: `.kuma/init.md`",
-    "\u{1F9E0} Skill: `.agents/skills/kuma/SKILL.md`"
+    "\u{1F9E0} Skills: `.agents/skills/kuma/SKILL.md` \xB7 `.opencode/skills/kuma/SKILL.md`",
+    "\u{1F50C} Plugin: `.opencode/plugins/kuma.js`"
   ].join("\n");
 }
 function codexTemplate() {
@@ -6996,6 +8071,150 @@ function antigravityMcpConfigTemplate() {
   };
   return JSON.stringify(config, null, 2) + "\n";
 }
+function antigravityRuleTemplate() {
+  return [
+    "# \u{1F43B} Kuma MCP \u2014 Antigravity Rules",
+    "",
+    "This project uses **Kuma MCP** for runtime safety, blast radius analysis, and codebase memory.",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "### \u{1F375} Companion: Matcha & Kuma Harmony",
+    "If Matcha is active in this workspace:",
+    "- **Matcha** governs engineering philosophy, intent discovery, reuse checks, and review gates.",
+    "- **Kuma** governs blast radius calculation, monorepo workspace dependencies, known gotchas memory, architecture boundary guards, and scoped test verification.",
+    "- Workflow: Use Matcha to plan (Intent Discovery) \u2192 Use Kuma to inspect dependencies & blast radius (`kuma_context({ action: 'impact' })`) \u2192 Use Kuma to verify after edits (`kuma_safety({ action: 'verify' })`).",
+    "",
+    "\u{1F4D6} Rules: `.kuma/init.md`",
+    "\u{1F4C2} Readable state: `.kuma/KNOWN_GOTCHAS.md` (gotchas) \xB7 `.kuma/memories/decisions.md` (decisions)"
+  ].join("\n");
+}
+function geminiTemplate() {
+  return [
+    "# \u{1F43B} Kuma MCP \u2014 Workspace Instructions",
+    "",
+    "This workspace uses **Kuma MCP** for runtime safety, monorepo intelligence, blast radius calculation, and memory.",
+    "",
+    "<kuma_obedience>",
+    "## \u{1F512} Kuma MCP Safety & Memory (non-negotiable)",
+    '- **Session Start:** Call `kuma_context({ action: "init" })` before reading or editing code.',
+    '- **Monorepo / Blast Radius:** Call `kuma_context({ action: "impact", target: "<file>" })` or `kuma_context({ action: "research", scope: "<area>" })` before modifying unfamiliar code.',
+    '- **Gotchas:** Call `kuma_memory({ action: "gotcha", scope: "<file>", content: "<description>" })` IMMEDIATELY when any quirk/bug is discovered.',
+    '- **Decisions:** Call `kuma_memory({ action: "decision", title: "...", rationale: "..." })` when choosing between options.',
+    '- **Post-Edits:** Call `kuma_safety({ action: "verify" })` after modifying code to run affected package/unit tests.',
+    "</kuma_obedience>",
+    "",
+    "### \u{1F375} Matcha & Kuma Harmony",
+    "If Matcha is active: Matcha provides Intent Discovery & review; Kuma provides blast radius, gotchas memory, architecture guards, and test verification.",
+    "",
+    "\u{1F4D6} Full rules: `.kuma/init.md`"
+  ].join("\n");
+}
+function opencodePluginTemplate() {
+  return [
+    "/**",
+    " * \u{1F43B} Kuma MCP \u2014 OpenCode Plugin",
+    " * Auto-injects gotcha warnings and safety guidance before file edits and commands in OpenCode.",
+    " * OpenCode loads all plugins from .opencode/plugins/*.js automatically.",
+    " */",
+    'import fs from "node:fs";',
+    'import path from "node:path";',
+    "",
+    "function getProjectRoot() {",
+    "  let curr = process.cwd();",
+    "  while (curr !== path.dirname(curr)) {",
+    '    if (fs.existsSync(path.join(curr, ".kuma")) || fs.existsSync(path.join(curr, ".git"))) {',
+    "      return curr;",
+    "    }",
+    "    curr = path.dirname(curr);",
+    "  }",
+    "  return process.cwd();",
+    "}",
+    "",
+    "function getActiveGotchasForFile(filePath) {",
+    "  try {",
+    "    const root = getProjectRoot();",
+    '    const gotchasPath = path.join(root, ".kuma", "KNOWN_GOTCHAS.md");',
+    "    if (!fs.existsSync(gotchasPath)) return [];",
+    '    const content = fs.readFileSync(gotchasPath, "utf-8");',
+    "    const gotchas = [];",
+    '    const normalizedTarget = filePath.replace(/^[./]+/, "");',
+    "    const sections = content.split(/###\\s+/);",
+    "    for (const section of sections) {",
+    "      if (!section.trim()) continue;",
+    '      const lines = section.split("\\n");',
+    '      const title = lines[0] || "";',
+    "      if (title.includes(normalizedTarget) || section.includes(normalizedTarget)) {",
+    "        gotchas.push(title.trim());",
+    "      }",
+    "    }",
+    "    return gotchas;",
+    "  } catch {",
+    "    return [];",
+    "  }",
+    "}",
+    "",
+    "export const KumaPlugin = async () => {",
+    "  return {",
+    '    "tool.execute.before": async (input, output) => {',
+    '      const tool = (input.tool || "").toLowerCase();',
+    "      const args = output.args || {};",
+    '      const targetPath = args.filePath || args.targetFile || args.path || args.file || "";',
+    '      if (targetPath && (tool.includes("edit") || tool.includes("write") || tool.includes("patch"))) {',
+    "        const gotchas = getActiveGotchasForFile(String(targetPath));",
+    "        if (gotchas.length > 0) {",
+    "          console.warn(",
+    "            `\\n\u{1F43B} [Kuma Alert] Active gotchas found for ${targetPath}:\\n` +",
+    '            gotchas.map((g) => `  \u26A0\uFE0F ${g}`).join("\\n") +',
+    '            `\\n\u{1F449} Remember to record any new gotchas via kuma_memory({ action: "gotcha" })\\n`',
+    "          );",
+    "        }",
+    "      }",
+    "    },",
+    "  };",
+    "};",
+    ""
+  ].join("\n");
+}
+function rooRulesTemplate() {
+  return [
+    "---",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "alwaysApply: true",
+    "---",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function traeRulesTemplate() {
+  return [
+    "# Kuma MCP \u2014 Trae Rules",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function qoderRulesTemplate() {
+  return [
+    "# Kuma MCP \u2014 Qoder Rules",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function windsurfrulesTemplate() {
+  return [
+    "# Kuma MCP \u2014 Windsurf Rules",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
 function generateInitMdContent() {
   return [
     "# Kuma Init \u2014 Workflow & Rules",
@@ -7016,7 +8235,7 @@ function generateInitMdContent() {
     '1. **MUST call `kuma_context({ action: "init" })`** at session start \u2014 before any code edit.',
     '2. **MUST record gotchas IMMEDIATELY** when a bug/quirk is found (`kuma_memory({ action: "gotcha" })`).',
     '3. **MUST call `kuma_safety({ action: "verify" })`** after code edits.',
-    "4. **MUST NOT call actions outside the 13 core actions** in this file \u2014 anything else is rejected by the MCP schema.",
+    "4. **MUST NOT call actions outside the core actions** in this file \u2014 anything else is rejected by the MCP schema.",
     "5. If a Kuma call fails or returns an error, **re-read this file and retry** \u2014 do not silently continue.",
     "",
     "> These rules are enforced: the MCP schema rejects unknown actions, and Claude Code hooks inject gotchas before every edit.",
@@ -7027,10 +8246,11 @@ function generateInitMdContent() {
     "<kuma_workflow>",
     "## SESSION WORKFLOW",
     "",
-    "### Core Actions (13)",
+    "### Core Actions (15)",
     "",
     '\u{1F9E0} **Before coding:** `kuma_context({ action: "init" })`',
-    '\u{1F52C} **Unfamiliar code:** `kuma_context({ action: "research", scope: "<area>" })`',
+    '\u{1F5FA}\uFE0F **Monorepo map:** `kuma_context({ action: "map" })`',
+    '\u{1F52C} **Blast radius / impact:** `kuma_context({ action: "impact", target: "<file>" })` or `kuma_context({ action: "research", scope: "<area>" })`',
     '\u{1F570}\uFE0F **Why this file?** `kuma_context({ action: "history", target: "<file>" })`',
     '\u{1F5C2}\uFE0F **Read a flow:** `kuma_context({ action: "flow", target: "<domain>" })`',
     '\u{1F41B} **Found a bug/quirk:** `kuma_memory({ action: "gotcha" })` (IMMEDIATELY)',
@@ -7075,6 +8295,19 @@ function generateInitMdContent() {
     "",
     "---",
     "",
+    "## \u{1F375} Companion: Matcha & Kuma Harmony",
+    "",
+    "If **Matcha** is active in this workspace:",
+    "- **Matcha** governs engineering philosophy, intent discovery, reuse checks, and review gates.",
+    "- **Kuma** governs blast radius calculation, monorepo workspace dependencies, known gotchas memory, architecture boundary guards, and scoped test verification.",
+    "- **Workflow:**",
+    "  1. Use Matcha's Intent Discovery (`.agents/plan/current.md`) to define Problem / Goals / Success Criteria.",
+    '  2. Use Kuma (`kuma_context({ action: "map" })` and `kuma_context({ action: "impact", target: "..." })`) to analyze blast radius and package dependents before modifying code.',
+    '  3. When encountering quirks or architectural boundaries, record immediately with `kuma_memory({ action: "gotcha" | "decision" })`.',
+    '  4. After changes, verify with `kuma_safety({ action: "verify" })` to run scoped tests.',
+    "",
+    "---",
+    "",
     "## \u26A0\uFE0F HONEST LIMITATIONS",
     "",
     "- **Node IDs are text-based** \u2014 same file recorded with slightly different paths can create duplicates.",
@@ -7090,7 +8323,9 @@ function generateInitMdContent() {
     "",
     "| Action | Description |",
     "|--------|-------------|",
-    "| `init` | Lean project brief, restore session |",
+    "| `init` | Lean project brief, restore session, monorepo brief |",
+    "| `map` | Repository workspace map & package dependency graph |",
+    "| `impact` | Direct blast radius analysis (dependents, consumers, tests) |",
     "| `research` | 5-step pipeline before editing unfamiliar code |",
     "| `history` | Why is this file written this way (cross-session trace) |",
     "| `flow` | Read a recorded architecture flow |",
@@ -7099,7 +8334,7 @@ function generateInitMdContent() {
     "",
     "| Action | Description |",
     "|--------|-------------|",
-    "| `gotcha` | Record bug/quirk (IMMEDIATELY when found) |",
+    "| `gotcha` | Record bug/quirk (candidate -> active -> verified) |",
     "| `arch_flow` | Record architecture flow (max 5 core files) |",
     "| `decision` | Record ADR / decision rationale |",
     "| `research_save` | Cache research findings |",
@@ -7109,8 +8344,8 @@ function generateInitMdContent() {
     "",
     "| Action | Description |",
     "|--------|-------------|",
-    "| `guard` | Anti-pattern detection before edits |",
-    "| `verify` | Auto-run scoped tests after edits |",
+    "| `guard` | Anti-pattern detection & architecture boundary check |",
+    "| `verify` | Auto-run scoped tests for affected packages/files |",
     "| `checkpoint` | Labeled snapshot before risky work |",
     "| `rollback_label` | Restore a labeled snapshot |",
     "",
@@ -7170,79 +8405,132 @@ function generateInitMdContent() {
   ].join("\n");
 }
 function handleOpencodeSecondary(root, results) {
-  const skillPath = path23.resolve(root, ".agents", "skills", "kuma", "SKILL.md");
-  if (results.some((r) => r.filePath === ".agents/skills/kuma/SKILL.md")) return;
-  try {
-    const dir = path23.dirname(skillPath);
-    const content = [
-      "---",
-      "name: kuma-mcp",
-      "description: Kuma MCP \u2014 safety toolkit for AI coding agents. Research, memory, and safety guard.",
-      "---",
-      "",
-      "Kuma MCP tools: kuma_kuma_context, kuma_kuma_memory, kuma_kuma_safety.",
-      "Record what matters, skip what doesn't.",
-      "",
-      "<kuma_obedience>",
-      "## \u{1F512} Obedience (non-negotiable)",
-      '- MUST call `kuma_kuma_context({ action: "init" })` at session start.',
-      "- MUST record gotchas IMMEDIATELY when a bug/quirk is found.",
-      '- MUST call `kuma_kuma_safety({ action: "verify" })` after edits.',
-      "- MUST NOT call actions outside the 13 core actions.",
-      "</kuma_obedience>",
-      "",
-      "<kuma_workflow>",
-      '\u{1F9E0} **Before coding:** `kuma_kuma_context({ action: "init" })`',
-      '\u{1F52C} **Unfamiliar code:** `kuma_kuma_context({ action: "research", scope: "<area>" })`',
-      '\u{1F41B} **Found a bug/quirk:** `kuma_kuma_memory({ action: "gotcha" })` (IMMEDIATELY)',
-      '\u{1F9ED} **Chose between options:** `kuma_kuma_memory({ action: "decision" })`',
-      '\u{1F500} **Traced a flow:** `kuma_kuma_memory({ action: "arch_flow" })` (max 5 files)',
-      '\u{1F6E1}\uFE0F **Before risky work / after edits:** `kuma_kuma_safety({ action: "guard" | "verify" })`',
-      "</kuma_workflow>",
-      "",
-      "\u26A0\uFE0F **OpenCode note:** Tool names use `kuma_kuma_*` prefix.",
-      "",
-      "\u{1F4D6} Full rules: `.kuma/init.md`"
-    ].join("\n");
-    if (fs22.existsSync(skillPath)) {
-      const existing = fs22.readFileSync(skillPath, "utf-8");
-      if (existing.includes("kuma-mcp")) {
-        results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "skipped" });
-        return;
+  const opencodeContent = [
+    "---",
+    "name: kuma-mcp",
+    "description: Kuma MCP \u2014 safety toolkit for AI coding agents. Research, memory, and safety guard.",
+    "---",
+    "",
+    "Kuma MCP tools: kuma_kuma_context (or kuma_context), kuma_kuma_memory (or kuma_memory), kuma_kuma_safety (or kuma_safety).",
+    "Record what matters, skip what doesn't.",
+    "",
+    "<kuma_obedience>",
+    "## \u{1F512} Obedience (non-negotiable)",
+    '- MUST call `kuma_kuma_context({ action: "init" })` at session start.',
+    "- MUST record gotchas IMMEDIATELY when a bug/quirk is found.",
+    '- MUST call `kuma_kuma_safety({ action: "verify" })` after edits.',
+    "- MUST NOT call actions outside the core actions.",
+    "</kuma_obedience>",
+    "",
+    "<kuma_workflow>",
+    '\u{1F9E0} **Before coding:** `kuma_kuma_context({ action: "init" })`',
+    '\u{1F5FA}\uFE0F **Monorepo map:** `kuma_kuma_context({ action: "map" })`',
+    '\u{1F52C} **Blast radius / impact:** `kuma_kuma_context({ action: "impact", target: "<file>" })` or `kuma_kuma_context({ action: "research", scope: "<area>" })`',
+    '\u{1F41B} **Found a bug/quirk:** `kuma_kuma_memory({ action: "gotcha" })` (IMMEDIATELY)',
+    '\u{1F9ED} **Chose between options:** `kuma_kuma_memory({ action: "decision" })`',
+    '\u{1F500} **Traced a flow:** `kuma_kuma_memory({ action: "arch_flow" })` (max 5 files)',
+    '\u{1F6E1}\uFE0F **Before risky work / after edits:** `kuma_kuma_safety({ action: "guard" | "verify" })`',
+    "</kuma_workflow>",
+    "",
+    "\u26A0\uFE0F **OpenCode note:** Tool names use `kuma_kuma_*` or `kuma_*` prefix depending on server registration.",
+    "",
+    "\u{1F4D6} Full rules: `.kuma/init.md`"
+  ].join("\n");
+  const skillPath = path26.resolve(root, ".agents", "skills", "kuma", "SKILL.md");
+  if (!results.some((r) => r.filePath === ".agents/skills/kuma/SKILL.md")) {
+    try {
+      const dir = path26.dirname(skillPath);
+      if (fs25.existsSync(skillPath)) {
+        const existing = fs25.readFileSync(skillPath, "utf-8");
+        if (existing.includes("kuma-mcp")) {
+          results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "skipped" });
+        } else {
+          fs25.writeFileSync(skillPath, existing.trimEnd() + "\n\n---\n\n" + opencodeContent, "utf-8");
+          results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "appended" });
+        }
+      } else {
+        if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+        fs25.writeFileSync(skillPath, opencodeContent, "utf-8");
+        results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "created" });
       }
-      const newContent = existing.trimEnd() + "\n\n---\n\n" + content;
-      fs22.writeFileSync(skillPath, newContent, "utf-8");
-      results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "appended" });
-    } else {
-      if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-      fs22.writeFileSync(skillPath, content, "utf-8");
-      results.push({ type: "opencode", filePath: ".agents/skills/kuma/SKILL.md", action: "created" });
+    } catch (err) {
+      results.push({
+        type: "opencode",
+        filePath: ".agents/skills/kuma/SKILL.md",
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const opencodeSkillPath = path26.resolve(root, ".opencode", "skills", "kuma", "SKILL.md");
+  if (!results.some((r) => r.filePath === ".opencode/skills/kuma/SKILL.md")) {
+    try {
+      const dir = path26.dirname(opencodeSkillPath);
+      if (fs25.existsSync(opencodeSkillPath)) {
+        const existing = fs25.readFileSync(opencodeSkillPath, "utf-8");
+        if (existing.includes("kuma-mcp")) {
+          results.push({ type: "opencode", filePath: ".opencode/skills/kuma/SKILL.md", action: "skipped" });
+        } else {
+          fs25.writeFileSync(opencodeSkillPath, existing.trimEnd() + "\n\n---\n\n" + opencodeContent, "utf-8");
+          results.push({ type: "opencode", filePath: ".opencode/skills/kuma/SKILL.md", action: "appended" });
+        }
+      } else {
+        if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+        fs25.writeFileSync(opencodeSkillPath, opencodeContent, "utf-8");
+        results.push({ type: "opencode", filePath: ".opencode/skills/kuma/SKILL.md", action: "created" });
+      }
+    } catch (err) {
+      results.push({
+        type: "opencode",
+        filePath: ".opencode/skills/kuma/SKILL.md",
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const pluginPath = path26.resolve(root, ".opencode", "plugins", "kuma.js");
+  if (!results.some((r) => r.filePath === ".opencode/plugins/kuma.js")) {
+    try {
+      const dir = path26.dirname(pluginPath);
+      if (fs25.existsSync(pluginPath)) {
+        const existing = fs25.readFileSync(pluginPath, "utf-8");
+        if (existing.includes("KumaPlugin") || existing.includes("kuma")) {
+          results.push({ type: "opencode", filePath: ".opencode/plugins/kuma.js", action: "skipped" });
+        } else {
+          fs25.writeFileSync(pluginPath, existing.trimEnd() + "\n\n" + opencodePluginTemplate(), "utf-8");
+          results.push({ type: "opencode", filePath: ".opencode/plugins/kuma.js", action: "appended" });
+        }
+      } else {
+        if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+        fs25.writeFileSync(pluginPath, opencodePluginTemplate(), "utf-8");
+        results.push({ type: "opencode", filePath: ".opencode/plugins/kuma.js", action: "created" });
+      }
+    } catch (err) {
+      results.push({
+        type: "opencode",
+        filePath: ".opencode/plugins/kuma.js",
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
-  } catch (err) {
-    results.push({
-      type: "opencode",
-      filePath: ".agents/skills/kuma/SKILL.md",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
   }
 }
 function handleCodexSecondary(root, results) {
-  const tomlPath = path23.resolve(root, ".codex/config.toml");
+  const tomlPath = path26.resolve(root, ".codex/config.toml");
   if (results.some((r) => r.filePath === ".codex/config.toml")) return;
   try {
-    const dir = path23.dirname(tomlPath);
-    if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-    if (fs22.existsSync(tomlPath)) {
-      const existingContent = fs22.readFileSync(tomlPath, "utf-8");
+    const dir = path26.dirname(tomlPath);
+    if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+    if (fs25.existsSync(tomlPath)) {
+      const existingContent = fs25.readFileSync(tomlPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "codex", filePath: ".codex/config.toml", action: "skipped" });
         return;
       }
-      fs22.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
+      fs25.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
       results.push({ type: "codex", filePath: ".codex/config.toml", action: "appended" });
     } else {
-      fs22.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
+      fs25.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
       results.push({ type: "codex", filePath: ".codex/config.toml", action: "created" });
     }
   } catch (err) {
@@ -7255,11 +8543,11 @@ function handleCodexSecondary(root, results) {
   }
 }
 function handleQwenSecondary(root, results) {
-  const settingsPath = path23.resolve(root, "settings.json");
+  const settingsPath = path26.resolve(root, "settings.json");
   if (results.some((r) => r.filePath === "settings.json")) return;
   try {
-    if (fs22.existsSync(settingsPath)) {
-      const existingContent = fs22.readFileSync(settingsPath, "utf-8");
+    if (fs25.existsSync(settingsPath)) {
+      const existingContent = fs25.readFileSync(settingsPath, "utf-8");
       if (existingContent.includes("kuma")) {
         if (!existingContent.includes("_Generated by Kuma MCP_")) {
           try {
@@ -7267,7 +8555,7 @@ function handleQwenSecondary(root, results) {
             parsed.mcpServers = parsed.mcpServers || {};
             if (!parsed.mcpServers.kuma) {
               parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-              fs22.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+              fs25.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
               results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
               return;
             }
@@ -7282,13 +8570,13 @@ function handleQwenSecondary(root, results) {
         parsed.mcpServers = parsed.mcpServers || {};
         if (!parsed.mcpServers.kuma) {
           parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-          fs22.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+          fs25.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
           results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
         }
       } catch {
       }
     } else {
-      fs22.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
+      fs25.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
       results.push({ type: "qwen", filePath: "settings.json", action: "created" });
     }
   } catch (err) {
@@ -7391,12 +8679,12 @@ function getCombinedAgentsMd(selectedTypes) {
   return lines.join("\n");
 }
 function handleAntigravityMcpConfig(root, results) {
-  const mcpPath = path23.resolve(root, ".agents/mcp_config.json");
+  const mcpPath = path26.resolve(root, ".agents/mcp_config.json");
   if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
   try {
-    const mcpDir = path23.dirname(mcpPath);
-    if (fs22.existsSync(mcpPath)) {
-      const existingContent = fs22.readFileSync(mcpPath, "utf-8");
+    const mcpDir = path26.dirname(mcpPath);
+    if (fs25.existsSync(mcpPath)) {
+      const existingContent = fs25.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "skipped" });
         return;
@@ -7405,14 +8693,14 @@ function handleAntigravityMcpConfig(root, results) {
         const parsed = JSON.parse(existingContent);
         parsed.mcpServers = parsed.mcpServers || {};
         parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-        fs22.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+        fs25.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
         results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
       } catch {
         results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "error", error: "Invalid JSON in existing mcp_config.json" });
       }
     } else {
-      if (!fs22.existsSync(mcpDir)) fs22.mkdirSync(mcpDir, { recursive: true });
-      fs22.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      if (!fs25.existsSync(mcpDir)) fs25.mkdirSync(mcpDir, { recursive: true });
+      fs25.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "created" });
     }
   } catch (err) {
@@ -7424,19 +8712,181 @@ function handleAntigravityMcpConfig(root, results) {
     });
   }
 }
+function handleAntigravityRules(root, results) {
+  const rulePath = path26.resolve(root, ".agents", "rules", "kuma.md");
+  if (results.some((r) => r.filePath === ".agents/rules/kuma.md")) return;
+  try {
+    const dir = path26.dirname(rulePath);
+    if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+    if (fs25.existsSync(rulePath)) {
+      const existing = fs25.readFileSync(rulePath, "utf-8");
+      if (existing.includes("Kuma MCP") || existing.includes("kuma-mcp")) {
+        results.push({ type: "antigravity", filePath: ".agents/rules/kuma.md", action: "skipped" });
+        return;
+      }
+      fs25.writeFileSync(rulePath, existing.trimEnd() + "\n\n---\n\n" + antigravityRuleTemplate(), "utf-8");
+      results.push({ type: "antigravity", filePath: ".agents/rules/kuma.md", action: "appended" });
+    } else {
+      fs25.writeFileSync(rulePath, antigravityRuleTemplate(), "utf-8");
+      results.push({ type: "antigravity", filePath: ".agents/rules/kuma.md", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "antigravity",
+      filePath: ".agents/rules/kuma.md",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleGeminiMd(root, results) {
+  const geminiPath = path26.resolve(root, "GEMINI.md");
+  if (results.some((r) => r.filePath === "GEMINI.md")) return;
+  try {
+    if (fs25.existsSync(geminiPath)) {
+      const existing = fs25.readFileSync(geminiPath, "utf-8");
+      if (existing.includes("Kuma MCP") || existing.includes("kuma_context")) {
+        results.push({ type: "antigravity", filePath: "GEMINI.md", action: "skipped" });
+        return;
+      }
+      fs25.writeFileSync(geminiPath, existing.trimEnd() + "\n\n---\n\n" + geminiTemplate(), "utf-8");
+      results.push({ type: "antigravity", filePath: "GEMINI.md", action: "appended" });
+    } else {
+      fs25.writeFileSync(geminiPath, geminiTemplate(), "utf-8");
+      results.push({ type: "antigravity", filePath: "GEMINI.md", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "antigravity",
+      filePath: "GEMINI.md",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleAntigravitySecondary(root, results) {
+  handleAntigravityMcpConfig(root, results);
+  handleAntigravityRules(root, results);
+  handleGeminiMd(root, results);
+}
+function handleWindsurfSecondary(root, results) {
+  const rulesPath = path26.resolve(root, ".windsurfrules");
+  if (results.some((r) => r.filePath === ".windsurfrules")) return;
+  try {
+    if (fs25.existsSync(rulesPath)) {
+      const existing = fs25.readFileSync(rulesPath, "utf-8");
+      if (existing.includes("Kuma MCP") || existing.includes("kuma_context")) {
+        results.push({ type: "windsurf", filePath: ".windsurfrules", action: "skipped" });
+        return;
+      }
+      fs25.writeFileSync(rulesPath, existing.trimEnd() + "\n\n---\n\n" + windsurfrulesTemplate(), "utf-8");
+      results.push({ type: "windsurf", filePath: ".windsurfrules", action: "appended" });
+    } else {
+      fs25.writeFileSync(rulesPath, windsurfrulesTemplate(), "utf-8");
+      results.push({ type: "windsurf", filePath: ".windsurfrules", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "windsurf",
+      filePath: ".windsurfrules",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleClineSecondary(root, results) {
+  const rooPath = path26.resolve(root, ".roo", "rules", "kuma.md");
+  if (!results.some((r) => r.filePath === ".roo/rules/kuma.md")) {
+    try {
+      const dir = path26.dirname(rooPath);
+      if (fs25.existsSync(rooPath)) {
+        const existing = fs25.readFileSync(rooPath, "utf-8");
+        if (existing.includes("kuma-mcp") || existing.includes("Kuma MCP")) {
+          results.push({ type: "cline", filePath: ".roo/rules/kuma.md", action: "skipped" });
+        } else {
+          fs25.writeFileSync(rooPath, existing.trimEnd() + "\n\n---\n\n" + rooRulesTemplate(), "utf-8");
+          results.push({ type: "cline", filePath: ".roo/rules/kuma.md", action: "appended" });
+        }
+      } else {
+        if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+        fs25.writeFileSync(rooPath, rooRulesTemplate(), "utf-8");
+        results.push({ type: "cline", filePath: ".roo/rules/kuma.md", action: "created" });
+      }
+    } catch (err) {
+      results.push({
+        type: "cline",
+        filePath: ".roo/rules/kuma.md",
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const traePath = path26.resolve(root, ".trae", "rules", "kuma.md");
+  if (!results.some((r) => r.filePath === ".trae/rules/kuma.md")) {
+    try {
+      const dir = path26.dirname(traePath);
+      if (fs25.existsSync(traePath)) {
+        const existing = fs25.readFileSync(traePath, "utf-8");
+        if (existing.includes("Kuma MCP")) {
+          results.push({ type: "cline", filePath: ".trae/rules/kuma.md", action: "skipped" });
+        } else {
+          fs25.writeFileSync(traePath, existing.trimEnd() + "\n\n---\n\n" + traeRulesTemplate(), "utf-8");
+          results.push({ type: "cline", filePath: ".trae/rules/kuma.md", action: "appended" });
+        }
+      } else {
+        if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+        fs25.writeFileSync(traePath, traeRulesTemplate(), "utf-8");
+        results.push({ type: "cline", filePath: ".trae/rules/kuma.md", action: "created" });
+      }
+    } catch (err) {
+      results.push({
+        type: "cline",
+        filePath: ".trae/rules/kuma.md",
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const qoderPath = path26.resolve(root, ".qoder", "rules", "kuma.md");
+  if (!results.some((r) => r.filePath === ".qoder/rules/kuma.md")) {
+    try {
+      const dir = path26.dirname(qoderPath);
+      if (fs25.existsSync(qoderPath)) {
+        const existing = fs25.readFileSync(qoderPath, "utf-8");
+        if (existing.includes("Kuma MCP")) {
+          results.push({ type: "cline", filePath: ".qoder/rules/kuma.md", action: "skipped" });
+        } else {
+          fs25.writeFileSync(qoderPath, existing.trimEnd() + "\n\n---\n\n" + qoderRulesTemplate(), "utf-8");
+          results.push({ type: "cline", filePath: ".qoder/rules/kuma.md", action: "appended" });
+        }
+      } else {
+        if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+        fs25.writeFileSync(qoderPath, qoderRulesTemplate(), "utf-8");
+        results.push({ type: "cline", filePath: ".qoder/rules/kuma.md", action: "created" });
+      }
+    } catch (err) {
+      results.push({
+        type: "cline",
+        filePath: ".qoder/rules/kuma.md",
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
 function handleAiderSecondary(root, results) {
-  const ymlPath = path23.resolve(root, ".aider.conf.yml");
+  const ymlPath = path26.resolve(root, ".aider.conf.yml");
   if (results.some((r) => r.filePath === ".aider.conf.yml")) return;
   try {
     const conventionsRef = "read: CONVENTIONS.md";
-    if (fs22.existsSync(ymlPath)) {
-      const existingContent = fs22.readFileSync(ymlPath, "utf-8");
+    if (fs25.existsSync(ymlPath)) {
+      const existingContent = fs25.readFileSync(ymlPath, "utf-8");
       if (existingContent.includes("CONVENTIONS.md") || existingContent.includes("kuma")) {
         results.push({ type: "aider", filePath: ".aider.conf.yml", action: "skipped" });
         return;
       }
       const newContent = existingContent.trimEnd() + "\n\n# Kuma MCP conventions\n" + conventionsRef + "\n";
-      fs22.writeFileSync(ymlPath, newContent, "utf-8");
+      fs25.writeFileSync(ymlPath, newContent, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "appended" });
     } else {
       const content = [
@@ -7446,7 +8896,7 @@ function handleAiderSecondary(root, results) {
         conventionsRef,
         ""
       ].join("\n");
-      fs22.writeFileSync(ymlPath, content, "utf-8");
+      fs25.writeFileSync(ymlPath, content, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "created" });
     }
   } catch (err) {
@@ -7459,10 +8909,10 @@ function handleAiderSecondary(root, results) {
   }
 }
 function handleCopilotSecondary(root, results) {
-  const skillPath = path23.resolve(root, ".github/skills/kuma/SKILL.md");
+  const skillPath = path26.resolve(root, ".github/skills/kuma/SKILL.md");
   if (results.some((r) => r.filePath === ".github/skills/kuma/SKILL.md")) return;
   try {
-    const dir = path23.dirname(skillPath);
+    const dir = path26.dirname(skillPath);
     const content = [
       "---",
       "name: kuma-mcp",
@@ -7473,17 +8923,17 @@ function handleCopilotSecondary(root, results) {
       "",
       "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
     ].join("\n");
-    if (fs22.existsSync(skillPath)) {
-      const existingContent = fs22.readFileSync(skillPath, "utf-8");
+    if (fs25.existsSync(skillPath)) {
+      const existingContent = fs25.readFileSync(skillPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "skipped" });
         return;
       }
-      fs22.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
+      fs25.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
       results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "appended" });
     } else {
-      if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-      fs22.writeFileSync(skillPath, content, "utf-8");
+      if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+      fs25.writeFileSync(skillPath, content, "utf-8");
       results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "created" });
     }
   } catch (err) {
@@ -7496,21 +8946,21 @@ function handleCopilotSecondary(root, results) {
   }
 }
 function handleOpenclawSecondary(root, results) {
-  const mcpPath = path23.resolve(root, ".agents/mcp_config.json");
+  const mcpPath = path26.resolve(root, ".agents/mcp_config.json");
   if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
   try {
-    const dir = path23.dirname(mcpPath);
-    if (fs22.existsSync(mcpPath)) {
-      const existingContent = fs22.readFileSync(mcpPath, "utf-8");
+    const dir = path26.dirname(mcpPath);
+    if (fs25.existsSync(mcpPath)) {
+      const existingContent = fs25.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) return;
       const parsed = JSON.parse(existingContent);
       parsed.mcpServers = parsed.mcpServers || {};
       parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs22.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      fs25.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
       results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "appended" });
     } else {
-      if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-      fs22.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+      fs25.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
       results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "created" });
     }
   } catch (err) {
@@ -7523,20 +8973,20 @@ function handleOpenclawSecondary(root, results) {
   }
 }
 function handleInitMdGeneration(root, results) {
-  const initMdPath = path23.resolve(root, ".kuma/init.md");
+  const initMdPath = path26.resolve(root, ".kuma/init.md");
   try {
-    const kumaDir = path23.dirname(initMdPath);
-    if (!fs22.existsSync(kumaDir)) fs22.mkdirSync(kumaDir, { recursive: true });
-    if (fs22.existsSync(initMdPath)) {
-      const existing = fs22.readFileSync(initMdPath, "utf-8");
+    const kumaDir = path26.dirname(initMdPath);
+    if (!fs25.existsSync(kumaDir)) fs25.mkdirSync(kumaDir, { recursive: true });
+    if (fs25.existsSync(initMdPath)) {
+      const existing = fs25.readFileSync(initMdPath, "utf-8");
       if (existing.includes("_Generated by Kuma MCP_")) {
         results.push({ type: "claude", filePath: ".kuma/init.md", action: "skipped" });
         return;
       }
-      fs22.writeFileSync(initMdPath, existing.trimEnd() + "\n\n" + generateInitMdContent(), "utf-8");
+      fs25.writeFileSync(initMdPath, existing.trimEnd() + "\n\n" + generateInitMdContent(), "utf-8");
       results.push({ type: "claude", filePath: ".kuma/init.md", action: "appended" });
     } else {
-      fs22.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
+      fs25.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
       results.push({ type: "claude", filePath: ".kuma/init.md", action: "created" });
     }
   } catch (err) {
@@ -7549,20 +8999,20 @@ function handleInitMdGeneration(root, results) {
   }
 }
 function handleCodewhaleSecondary(root, results) {
-  const mcpPath = path23.resolve(root, ".codewhale/mcp.json");
+  const mcpPath = path26.resolve(root, ".codewhale/mcp.json");
   if (results.some((r) => r.filePath === ".codewhale/mcp.json")) return;
   try {
-    const dir = path23.dirname(mcpPath);
-    if (fs22.existsSync(mcpPath)) {
-      const existingContent = fs22.readFileSync(mcpPath, "utf-8");
+    const dir = path26.dirname(mcpPath);
+    if (fs25.existsSync(mcpPath)) {
+      const existingContent = fs25.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) return;
       const parsed = JSON.parse(existingContent);
       parsed.mcpServers = parsed.mcpServers || {};
       parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs22.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      fs25.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
       results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "appended" });
     } else {
-      if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
+      if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
       const config = {
         mcpServers: {
           kuma: {
@@ -7572,7 +9022,7 @@ function handleCodewhaleSecondary(root, results) {
           }
         }
       };
-      fs22.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      fs25.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
       results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "created" });
     }
   } catch (err) {
@@ -7585,7 +9035,7 @@ function handleCodewhaleSecondary(root, results) {
   }
 }
 function handleClaudeSecondary(root, results) {
-  const settingsPath = path23.resolve(root, ".claude", "settings.json");
+  const settingsPath = path26.resolve(root, ".claude", "settings.json");
   const hookBlock = {
     hooks: {
       PreToolUse: [
@@ -7601,8 +9051,8 @@ function handleClaudeSecondary(root, results) {
     }
   };
   try {
-    if (fs22.existsSync(settingsPath)) {
-      const existing = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+    if (fs25.existsSync(settingsPath)) {
+      const existing = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
       const merged = {
         ...existing,
         hooks: {
@@ -7617,12 +9067,12 @@ function handleClaudeSecondary(root, results) {
           matchers.add(entry.matcher);
         }
       }
-      fs22.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      fs25.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       results.push({ type: "claude", filePath: ".claude/settings.json", action: "appended" });
     } else {
-      const dir = path23.dirname(settingsPath);
-      if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-      fs22.writeFileSync(settingsPath, JSON.stringify(hookBlock, null, 2) + "\n", "utf-8");
+      const dir = path26.dirname(settingsPath);
+      if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+      fs25.writeFileSync(settingsPath, JSON.stringify(hookBlock, null, 2) + "\n", "utf-8");
       results.push({ type: "claude", filePath: ".claude/settings.json", action: "created" });
     }
   } catch (err) {
@@ -7633,20 +9083,57 @@ function handleClaudeSecondary(root, results) {
       error: err instanceof Error ? err.message : String(err)
     });
   }
+  const skillPath = path26.resolve(root, ".claude", "skills", "kuma", "SKILL.md");
+  if (!results.some((r) => r.filePath === ".claude/skills/kuma/SKILL.md")) {
+    try {
+      const dir = path26.dirname(skillPath);
+      const content = [
+        "---",
+        "name: kuma-mcp",
+        "description: Kuma MCP \u2014 safety toolkit for AI coding agents",
+        "---",
+        "",
+        KUMA_CORE_INSTRUCTIONS,
+        "",
+        "\u{1F4D6} Read `.kuma/init.md` for detailed rules.",
+        "\u{1F4C2} Readable state: `.kuma/KNOWN_GOTCHAS.md` (gotchas) \xB7 `.kuma/memories/decisions.md` (decisions)"
+      ].join("\n");
+      if (fs25.existsSync(skillPath)) {
+        const existing = fs25.readFileSync(skillPath, "utf-8");
+        if (existing.includes("kuma-mcp")) {
+          results.push({ type: "claude", filePath: ".claude/skills/kuma/SKILL.md", action: "skipped" });
+        } else {
+          fs25.writeFileSync(skillPath, existing.trimEnd() + "\n\n---\n\n" + content, "utf-8");
+          results.push({ type: "claude", filePath: ".claude/skills/kuma/SKILL.md", action: "appended" });
+        }
+      } else {
+        if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+        fs25.writeFileSync(skillPath, content, "utf-8");
+        results.push({ type: "claude", filePath: ".claude/skills/kuma/SKILL.md", action: "created" });
+      }
+    } catch (err) {
+      results.push({
+        type: "claude",
+        filePath: ".claude/skills/kuma/SKILL.md",
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
 }
 function handleCursorGotchaRules(root, results) {
-  const rulesDir2 = path23.resolve(root, ".cursor", "rules", "kuma-gotchas");
+  const rulesDir2 = path26.resolve(root, ".cursor", "rules", "kuma-gotchas");
   try {
     let gotchas = [];
     try {
       gotchas = getActiveGotchas().filter((g) => g.severity === "high" || g.severity === "critical");
     } catch {
     }
-    if (fs22.existsSync(rulesDir2)) {
-      for (const f of fs22.readdirSync(rulesDir2)) {
+    if (fs25.existsSync(rulesDir2)) {
+      for (const f of fs25.readdirSync(rulesDir2)) {
         if (f.endsWith(".mdc")) {
           try {
-            fs22.rmSync(path23.join(rulesDir2, f), { force: true });
+            fs25.rmSync(path26.join(rulesDir2, f), { force: true });
           } catch {
           }
         }
@@ -7656,7 +9143,7 @@ function handleCursorGotchaRules(root, results) {
       results.push({ type: "cursor", filePath: ".cursor/rules/kuma-gotchas/", action: "skipped" });
       return;
     }
-    fs22.mkdirSync(rulesDir2, { recursive: true });
+    fs25.mkdirSync(rulesDir2, { recursive: true });
     const seen = /* @__PURE__ */ new Set();
     let created = 0;
     for (const g of gotchas) {
@@ -7677,7 +9164,7 @@ function handleCursorGotchaRules(root, results) {
         "`kuma_context({ action: 'history', target: '<file>' })`",
         ""
       ].join("\n");
-      fs22.writeFileSync(path23.join(rulesDir2, `${slug}.mdc`), md, "utf-8");
+      fs25.writeFileSync(path26.join(rulesDir2, `${slug}.mdc`), md, "utf-8");
       created++;
     }
     results.push({
@@ -7704,28 +9191,28 @@ function runInit(options) {
   let agentsMdHandled = false;
   for (const type of selected) {
     const relativePath = configFilePath(type);
-    const fullPath = path23.resolve(root, relativePath);
+    const fullPath = path26.resolve(root, relativePath);
     const getTemplate = TEMPLATES[type];
     try {
       if (AGENTS_MD_TYPES.includes(type) && !agentsMdHandled) {
         agentsMdHandled = true;
         const combinedContent = getCombinedAgentsMd(new Set(agentsMdSelected));
-        if (fs22.existsSync(fullPath)) {
+        if (fs25.existsSync(fullPath)) {
           if (options.skipExisting) {
             results.push({ type, filePath: relativePath, action: "skipped" });
           } else {
-            const existingContent = fs22.readFileSync(fullPath, "utf-8");
+            const existingContent = fs25.readFileSync(fullPath, "utf-8");
             if (existingContent.includes("_Generated by Kuma MCP_")) {
               results.push({ type, filePath: relativePath, action: "skipped" });
             } else {
-              fs22.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
+              fs25.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
               results.push({ type, filePath: relativePath, action: "appended" });
             }
           }
         } else {
-          const dir = path23.dirname(fullPath);
-          if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-          fs22.writeFileSync(fullPath, combinedContent, "utf-8");
+          const dir = path26.dirname(fullPath);
+          if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+          fs25.writeFileSync(fullPath, combinedContent, "utf-8");
           results.push({ type, filePath: relativePath, action: "created" });
         }
         if (selectedSet.has("opencode")) handleOpencodeSecondary(root, results);
@@ -7737,42 +9224,50 @@ function runInit(options) {
         continue;
       } else {
         const template = getTemplate();
-        if (fs22.existsSync(fullPath)) {
+        if (fs25.existsSync(fullPath)) {
           if (options.skipExisting) {
             results.push({ type, filePath: relativePath, action: "skipped" });
             continue;
           }
-          const existingContent = fs22.readFileSync(fullPath, "utf-8");
+          const existingContent = fs25.readFileSync(fullPath, "utf-8");
           if (existingContent.includes("_Generated by Kuma MCP_")) {
             if (type === "antigravity") {
-              handleAntigravityMcpConfig(root, results);
+              handleAntigravitySecondary(root, results);
             } else if (type === "openclaw") {
               handleOpenclawSecondary(root, results);
             } else if (type === "codewhale") {
               handleCodewhaleSecondary(root, results);
+            } else if (type === "windsurf") {
+              handleWindsurfSecondary(root, results);
+            } else if (type === "cline") {
+              handleClineSecondary(root, results);
             }
             results.push({ type, filePath: relativePath, action: "skipped" });
             continue;
           }
           const newContent = existingContent.trimEnd() + APPEND_SEPARATOR + template;
-          fs22.writeFileSync(fullPath, newContent, "utf-8");
+          fs25.writeFileSync(fullPath, newContent, "utf-8");
           results.push({ type, filePath: relativePath, action: "appended" });
         } else {
-          const dir = path23.dirname(fullPath);
-          if (!fs22.existsSync(dir)) {
-            fs22.mkdirSync(dir, { recursive: true });
+          const dir = path26.dirname(fullPath);
+          if (!fs25.existsSync(dir)) {
+            fs25.mkdirSync(dir, { recursive: true });
           }
-          fs22.writeFileSync(fullPath, template, "utf-8");
+          fs25.writeFileSync(fullPath, template, "utf-8");
           results.push({ type, filePath: relativePath, action: "created" });
         }
         if (type === "antigravity") {
-          handleAntigravityMcpConfig(root, results);
+          handleAntigravitySecondary(root, results);
         } else if (type === "openclaw") {
           handleOpenclawSecondary(root, results);
         } else if (type === "codewhale") {
           handleCodewhaleSecondary(root, results);
         } else if (type === "aider") {
           handleAiderSecondary(root, results);
+        } else if (type === "windsurf") {
+          handleWindsurfSecondary(root, results);
+        } else if (type === "cline") {
+          handleClineSecondary(root, results);
         }
       }
     } catch (err) {
@@ -7877,12 +9372,13 @@ var init_init = __esm({
       '- MUST call `kuma_context({ action: "init" })` at session start.',
       "- MUST record gotchas IMMEDIATELY when a bug/quirk is found.",
       '- MUST call `kuma_safety({ action: "verify" })` after edits.',
-      "- MUST NOT call actions outside the 13 core actions.",
+      "- MUST NOT call actions outside the core actions.",
       "</kuma_obedience>",
       "",
       "<kuma_workflow>",
       '\u{1F9E0} **Before coding:** `kuma_context({ action: "init" })`',
-      '\u{1F52C} **Unfamiliar code:** `kuma_context({ action: "research", scope: "<area>" })`',
+      '\u{1F5FA}\uFE0F **Monorepo map:** `kuma_context({ action: "map" })`',
+      '\u{1F52C} **Unfamiliar code / blast radius:** `kuma_context({ action: "research", scope: "<area>" })` or `kuma_context({ action: "impact", target: "<file>" })`',
       '\u{1F41B} **Found a bug/quirk:** `kuma_memory({ action: "gotcha" })` (IMMEDIATELY)',
       '\u{1F9ED} **Chose between options:** `kuma_memory({ action: "decision" })`',
       '\u{1F500} **Traced a flow:** `kuma_memory({ action: "arch_flow" })` (max 5 files)',
@@ -7923,19 +9419,19 @@ __export(agentDetector_exports, {
   getSkillPath: () => getSkillPath,
   skillExists: () => skillExists
 });
-import fs23 from "fs";
-import path24 from "path";
+import fs26 from "fs";
+import path27 from "path";
 function checkFile(root, filePath) {
   try {
-    return fs23.existsSync(path24.join(root, filePath));
+    return fs26.existsSync(path27.join(root, filePath));
   } catch {
     return false;
   }
 }
 function checkDir(root, dirPath) {
   try {
-    const fullPath = path24.join(root, dirPath);
-    return fs23.existsSync(fullPath) && fs23.statSync(fullPath).isDirectory();
+    const fullPath = path27.join(root, dirPath);
+    return fs26.existsSync(fullPath) && fs26.statSync(fullPath).isDirectory();
   } catch {
     return false;
   }
@@ -8003,7 +9499,7 @@ function getAgentLabel(type) {
 function skillExists(type, projectRoot) {
   const root = projectRoot ?? getProjectRoot();
   const skillPath = getSkillPath(type);
-  return fs23.existsSync(path24.join(root, skillPath));
+  return fs26.existsSync(path27.join(root, skillPath));
 }
 var AGENT_DETECTORS;
 var init_agentDetector = __esm({
@@ -8034,25 +9530,25 @@ var init_agentDetector = __esm({
       },
       {
         type: "antigravity",
-        checkFiles: [],
+        checkFiles: ["GEMINI.md", ".agents/rules/kuma.md"],
         checkDirs: [".agents"],
         priority: 75,
         label: "Antigravity CLI (.agents/)"
       },
+      {
+        type: "opencode",
+        checkFiles: ["opencode.json", ".opencode/opencode.json", ".opencode/plugins/kuma.js"],
+        checkDirs: [".opencode"],
+        priority: 78,
+        label: "OpenCode (.opencode/)"
+      },
       {
         type: "windsurf",
-        checkFiles: [],
+        checkFiles: [".windsurfrules"],
         checkDirs: [".windsurf"],
         priority: 70,
         label: "Windsurf (.windsurf/)"
       },
-      {
-        type: "opencode",
-        checkFiles: [".agents/skills/kuma/SKILL.md"],
-        checkDirs: [".agents"],
-        priority: 65,
-        label: "OpenCode (.agents/skills/kuma/SKILL.md)"
-      },
       {
         type: "kiro",
         checkFiles: [],
@@ -8145,7 +9641,30 @@ function generateSkill(type) {
 function getSecondaryFiles(type) {
   switch (type) {
     case "antigravity":
-      return [{ path: ".agents/mcp_config.json", content: generateAntigravityMcpConfig() }];
+      return [
+        { path: ".agents/mcp_config.json", content: generateAntigravityMcpConfig() },
+        { path: ".agents/rules/kuma.md", content: generateAntigravityRule() },
+        { path: "GEMINI.md", content: generateGeminiMd() }
+      ];
+    case "opencode":
+      return [
+        { path: ".opencode/plugins/kuma.js", content: generateOpencodePlugin() },
+        { path: ".opencode/skills/kuma/SKILL.md", content: generateOpencodeSkill() },
+        { path: ".agents/skills/kuma/SKILL.md", content: generateOpencodeSkill() }
+      ];
+    case "claude":
+      return [
+        { path: ".claude/skills/kuma/SKILL.md", content: generateClaudeSkill() }
+      ];
+    case "windsurf":
+      return [
+        { path: ".windsurfrules", content: generateWindsurfrules() }
+      ];
+    case "cline":
+      return [
+        { path: ".roo/rules/kuma.md", content: generateRooRule() },
+        { path: ".trae/rules/kuma.md", content: generateTraeRule() }
+      ];
     case "codex":
       return [{ path: ".codex/config.toml", content: generateCodexConfigToml() }];
     case "qwen":
@@ -8158,6 +9677,132 @@ function getSecondaryFiles(type) {
       return [];
   }
 }
+function generateAntigravityRule() {
+  return [
+    "# \u{1F43B} Kuma MCP \u2014 Antigravity Rules",
+    "",
+    "This project uses **Kuma MCP** for runtime safety, blast radius analysis, and codebase memory.",
+    "",
+    BOOTSTRAP,
+    "",
+    "### \u{1F375} Companion: Matcha & Kuma Harmony",
+    "If Matcha is active in this workspace:",
+    "- **Matcha** governs engineering philosophy, intent discovery, reuse checks, and review gates.",
+    "- **Kuma** governs blast radius calculation, monorepo workspace dependencies, known gotchas memory, architecture boundary guards, and scoped test verification.",
+    "- Workflow: Use Matcha to plan (Intent Discovery) \u2192 Use Kuma to inspect dependencies & blast radius (`kuma_context({ action: 'impact' })`) \u2192 Use Kuma to verify after edits (`kuma_safety({ action: 'verify' })`).",
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function generateGeminiMd() {
+  return [
+    "# \u{1F43B} Kuma MCP \u2014 Workspace Instructions",
+    "",
+    "This workspace uses **Kuma MCP** for runtime safety, monorepo intelligence, blast radius calculation, and memory.",
+    "",
+    BOOTSTRAP,
+    "",
+    "### \u{1F375} Matcha & Kuma Harmony",
+    "If Matcha is active: Matcha provides Intent Discovery & review; Kuma provides blast radius, gotchas memory, architecture guards, and test verification.",
+    "",
+    "\u{1F4D6} Full rules: `.kuma/init.md`"
+  ].join("\n");
+}
+function generateOpencodePlugin() {
+  return [
+    "/**",
+    " * \u{1F43B} Kuma MCP \u2014 OpenCode Plugin",
+    " * Auto-injects gotcha warnings and safety checks before file edits and commands in OpenCode.",
+    " */",
+    'import fs from "node:fs";',
+    'import path from "node:path";',
+    "",
+    "function getProjectRoot() {",
+    "  let curr = process.cwd();",
+    "  while (curr !== path.dirname(curr)) {",
+    '    if (fs.existsSync(path.join(curr, ".kuma")) || fs.existsSync(path.join(curr, ".git"))) {',
+    "      return curr;",
+    "    }",
+    "    curr = path.dirname(curr);",
+    "  }",
+    "  return process.cwd();",
+    "}",
+    "",
+    "function getActiveGotchasForFile(filePath) {",
+    "  try {",
+    "    const root = getProjectRoot();",
+    '    const gotchasPath = path.join(root, ".kuma", "KNOWN_GOTCHAS.md");',
+    "    if (!fs.existsSync(gotchasPath)) return [];",
+    '    const content = fs.readFileSync(gotchasPath, "utf-8");',
+    "    const gotchas = [];",
+    '    const normalizedTarget = filePath.replace(/^[./]+/, "");',
+    "    const sections = content.split(/###\\s+/);",
+    "    for (const section of sections) {",
+    "      if (!section.trim()) continue;",
+    '      const lines = section.split("\\n");',
+    '      const title = lines[0] || "";',
+    "      if (title.includes(normalizedTarget) || section.includes(normalizedTarget)) {",
+    "        gotchas.push(title.trim());",
+    "      }",
+    "    }",
+    "    return gotchas;",
+    "  } catch {",
+    "    return [];",
+    "  }",
+    "}",
+    "",
+    "export const KumaPlugin = async () => {",
+    "  return {",
+    '    "tool.execute.before": async (input, output) => {',
+    '      const tool = (input.tool || "").toLowerCase();',
+    "      const args = output.args || {};",
+    '      const targetPath = args.filePath || args.targetFile || args.path || args.file || "";',
+    '      if (targetPath && (tool.includes("edit") || tool.includes("write") || tool.includes("patch"))) {',
+    "        const gotchas = getActiveGotchasForFile(String(targetPath));",
+    "        if (gotchas.length > 0) {",
+    "          console.warn(",
+    "            `\\n\u{1F43B} [Kuma Alert] Active gotchas found for ${targetPath}:\\n` +",
+    '            gotchas.map((g) => `  \u26A0\uFE0F ${g}`).join("\\n") +',
+    '            `\\n\u{1F449} Remember to record any new gotchas via kuma_memory({ action: "gotcha" })\\n`',
+    "          );",
+    "        }",
+    "      }",
+    "    },",
+    "  };",
+    "};",
+    ""
+  ].join("\n");
+}
+function generateWindsurfrules() {
+  return [
+    "# Kuma MCP \u2014 Windsurf Rules",
+    "",
+    BOOTSTRAP,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function generateRooRule() {
+  return [
+    "---",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "alwaysApply: true",
+    "---",
+    "",
+    BOOTSTRAP,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function generateTraeRule() {
+  return [
+    "# Kuma MCP \u2014 Trae Rules",
+    "",
+    BOOTSTRAP,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
 function generateClaudeSkill() {
   return [
     "---",
@@ -8399,12 +10044,13 @@ var init_skillGenerator = __esm({
       '- MUST call `kuma_context({ action: "init" })` at session start.',
       "- MUST record gotchas IMMEDIATELY when a bug/quirk is found.",
       '- MUST call `kuma_safety({ action: "verify" })` after edits.',
-      "- MUST NOT call actions outside the 13 core actions.",
+      "- MUST NOT call actions outside the core actions.",
       "</kuma_obedience>",
       "",
       "<kuma_workflow>",
       '\u{1F9E0} **Before coding:** `kuma_context({ action: "init" })`',
-      '\u{1F52C} **Unfamiliar code:** `kuma_context({ action: "research", scope: "<area>" })`',
+      '\u{1F5FA}\uFE0F **Monorepo map:** `kuma_context({ action: "map" })`',
+      '\u{1F52C} **Unfamiliar code / blast radius:** `kuma_context({ action: "research", scope: "<area>" })` or `kuma_context({ action: "impact", target: "<file>" })`',
       '\u{1F41B} **Found a bug/quirk:** `kuma_memory({ action: "gotcha" })` (IMMEDIATELY)',
       '\u{1F9ED} **Chose between options:** `kuma_memory({ action: "decision" })`',
       '\u{1F500} **Traced a flow:** `kuma_memory({ action: "arch_flow" })` (max 5 files)',
@@ -8446,8 +10092,8 @@ init_kumaDb();
 init_kumaGraph();
 init_kumaMemory();
 init_pathValidator();
-import fs14 from "fs";
-import path15 from "path";
+import fs16 from "fs";
+import path17 from "path";
 import crypto3 from "crypto";
 var CONTEXT_ALIASES = {
   "research": "research",
@@ -8466,7 +10112,16 @@ var CONTEXT_ALIASES = {
   "history": "history",
   "why": "history",
   "touched": "history",
-  "provenance": "history"
+  "provenance": "history",
+  "map": "map",
+  "repo-map": "map",
+  "repo_map": "map",
+  "workspace": "map",
+  "topology": "map",
+  "impact": "impact",
+  "blast-radius": "impact",
+  "blast_radius": "impact",
+  "blast": "impact"
 };
 async function handleContext(params) {
   const rawAction = params.action || "init";
@@ -8481,20 +10136,41 @@ async function handleContext(params) {
       return handleHistory(params);
     case "flow":
       return handleFlow(params);
+    case "map":
+      return handleMap(params);
+    case "impact":
+      return handleImpact(params);
     default:
-      return `Unknown action "${action}". Use: init, research, history, flow`;
+      return `Unknown action "${action}". Use: init, research, history, flow, map, impact`;
   }
 }
 async function handleInit(_params) {
   sessionMemory.setGoal(_params.goal || "Exploring project");
   sessionMemory.recordToolCall("kuma_context_init", {});
+  const branch = sessionMemory.getCurrentBranch();
+  const branchTag = branch ? ` [git: \`${branch}\`]` : "";
   const lines = [
     "\u{1F9E0} **Kuma \u2014 Project Brief (lean)**",
     `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
     "",
-    `\u{1F4C1} Project: ${getProjectRoot().split("/").pop() || "unknown"}`,
+    `\u{1F4C1} Project: ${getProjectRoot().split("/").pop() || "unknown"}${branchTag}`,
     ""
   ];
+  const branchTransition = sessionMemory.getBranchTransition();
+  if (branchTransition?.switched) {
+    lines.push(`\u{1F500} **Branch switched**: from \`${branchTransition.from}\` to \`${branchTransition.to}\`. Session context updated.`);
+    lines.push("");
+  }
+  try {
+    const { getWorkspaceInfo: getWorkspaceInfo2 } = await Promise.resolve().then(() => (init_workspaceIntelligence(), workspaceIntelligence_exports));
+    const wsInfo = await getWorkspaceInfo2();
+    if (wsInfo.isWorkspace) {
+      lines.push(`\u{1F4E6} **Workspace**: ${wsInfo.packages.length} package(s) detected (${wsInfo.type.toUpperCase()})`);
+      lines.push(`   ${wsInfo.packages.slice(0, 5).map((p) => `\`${p.name}\``).join(", ")}${wsInfo.packages.length > 5 ? ` +${wsInfo.packages.length - 5} more` : ""}`);
+      lines.push("");
+    }
+  } catch {
+  }
   const goal = _params.goal || sessionMemory.getSummary().currentGoal || "";
   try {
     const { maybeRunAutoCleanup: maybeRunAutoCleanup2 } = await Promise.resolve().then(() => (init_kumaMaintenance(), kumaMaintenance_exports));
@@ -8519,21 +10195,73 @@ async function handleInit(_params) {
   }
   try {
     const { getFreshGotchasForFile: getFreshGotchasForFile2 } = await Promise.resolve().then(() => (init_kumaInject(), kumaInject_exports));
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
     const modified = summary.modifiedFiles || [];
     const seen = /* @__PURE__ */ new Set();
-    let gotchasPushed = 0;
+    const collectedGotchas = [];
     for (const f of modified.slice(0, 4)) {
       if (!f.filePath || seen.has(f.filePath)) continue;
       seen.add(f.filePath);
       const gotchas = await getFreshGotchasForFile2(f.filePath, 3);
       for (const g of gotchas) {
-        if (gotchasPushed === 0) lines.push("**Active Gotchas (fresh)**");
-        gotchasPushed++;
+        const key = `${g.filePath}::${g.description.substring(0, 30)}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          collectedGotchas.push({
+            filePath: g.filePath,
+            description: g.description,
+            severity: g.severity
+          });
+        }
+      }
+    }
+    let totalActiveCount = 0;
+    try {
+      const db = await getDb2();
+      const countStmt = db.prepare(`SELECT COUNT(*) as cnt FROM known_gotchas WHERE status IN ('active', 'verified')`);
+      if (countStmt.step()) totalActiveCount = countStmt.getAsObject().cnt || 0;
+      countStmt.free();
+      if (collectedGotchas.length < 5) {
+        const stmt = db.prepare(`
+          SELECT file_path, description, severity
+          FROM known_gotchas
+          WHERE status IN ('active', 'verified')
+          ORDER BY
+            CASE severity WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 ELSE 3 END,
+            updated_at DESC
+          LIMIT 10
+        `);
+        while (stmt.step()) {
+          const row = stmt.getAsObject();
+          const key = `${row.file_path}::${row.description.substring(0, 30)}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            collectedGotchas.push({
+              filePath: row.file_path,
+              description: row.description,
+              severity: row.severity
+            });
+          }
+          if (collectedGotchas.length >= 5) break;
+        }
+        stmt.free();
+      }
+    } catch {
+    }
+    const severityRank = { critical: 0, high: 1, medium: 2, low: 3 };
+    collectedGotchas.sort((a, b) => (severityRank[a.severity] ?? 2) - (severityRank[b.severity] ?? 2));
+    const budgetedGotchas = collectedGotchas.slice(0, 5);
+    if (budgetedGotchas.length > 0) {
+      lines.push("**Active Gotchas (fresh & budgeted)**");
+      for (const g of budgetedGotchas) {
         const icon = g.severity === "critical" ? "\u{1F534}" : g.severity === "high" ? "\u{1F7E0}" : g.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
-        lines.push(`  ${icon} ${g.filePath} \u2014 ${g.description.substring(0, 90)}`);
+        lines.push(`  ${icon} [${g.severity}] ${g.filePath} \u2014 ${g.description.substring(0, 90)}`);
       }
+      if (totalActiveCount > budgetedGotchas.length) {
+        lines.push(`  \u2139\uFE0F +${totalActiveCount - budgetedGotchas.length} more active gotchas in DB (query: kuma_memory({ action: 'gotcha' }))`);
+      }
+      lines.push("");
     }
-    if (gotchasPushed > 0) lines.push("");
   } catch {
   }
   try {
@@ -8552,7 +10280,7 @@ async function handleInit(_params) {
     }
   } catch {
   }
-  lines.push("\u{1F4A1} Deeper: kuma_context({ action: 'history', target: '<file>' }) \xB7 Flow: kuma_context({ action: 'flow', target: '<domain>' }) \xB7 Research: kuma_context({ action: 'research', scope: '<area>' })");
+  lines.push("\u{1F4A1} Deeper: kuma_context({ action: 'history', target: '<file>' }) \xB7 Flow: kuma_context({ action: 'flow', target: '<domain>' }) \xB7 Map: kuma_context({ action: 'map' }) \xB7 Impact: kuma_context({ action: 'impact', target: '<file>' })");
   return lines.join("\n");
 }
 function detectSessionFocus(goal) {
@@ -8645,13 +10373,20 @@ async function handleResearch(params) {
   } catch {
   }
   lines.push("");
-  lines.push("**Step 4/5: Impact Analysis**");
+  lines.push("**Step 4/5: Impact Analysis (Blast Radius)**");
   try {
     const impact = await analyzeImpact(scope);
     lines.push(`  \u{1F4CA} ${impact.references} reference(s) across ${impact.files} file(s)`);
+    if (impact.packageName) lines.push(`  \u{1F4E6} Package: \`${impact.packageName}\``);
+    if (impact.downstreamPackages && impact.downstreamPackages.length > 0) {
+      lines.push(`  \u{1F310} Downstream consumers (${impact.downstreamPackages.length}): ${impact.downstreamPackages.slice(0, 4).join(", ")}`);
+    }
     lines.push(`  \u{1F9EA} ${impact.testFiles} test file(s) related`);
     lines.push(`  \u26A0\uFE0F Risk: ${impact.risk.toUpperCase()}`);
-    if (impact.entryPoints.length > 0) lines.push(`  \u{1F3AF} Entry: ${impact.entryPoints.slice(0, 3).join(", ")}`);
+    if (impact.riskFlags && impact.riskFlags.length > 0) {
+      for (const rf of impact.riskFlags) lines.push(`     \u2022 ${rf}`);
+    }
+    if (impact.entryPoints && impact.entryPoints.length > 0) lines.push(`  \u{1F3AF} Entry: ${impact.entryPoints.slice(0, 3).join(", ")}`);
   } catch {
     lines.push("  \u26A0\uFE0F Impact analysis unavailable");
   }
@@ -8706,7 +10441,7 @@ async function handleHistory(params) {
       const { getDb: getDb2 } = await Promise.resolve().then(() => (init_kumaDb(), kumaDb_exports));
       const db = await getDb2();
       const stmt = db.prepare(`SELECT description, last_verified_at FROM known_gotchas WHERE status = 'resolved' AND file_path LIKE ? ORDER BY last_verified_at DESC LIMIT 3`);
-      stmt.bind([`%${path15.basename(target)}%`]);
+      stmt.bind([`%${path17.basename(target)}%`]);
       const resolved = [];
       while (stmt.step()) resolved.push(stmt.getAsObject());
       stmt.free();
@@ -8735,15 +10470,28 @@ async function handleFlow(params) {
   const { getFreshDomainFlow: getFreshDomainFlow2 } = await Promise.resolve().then(() => (init_kumaFlowCache(), kumaFlowCache_exports));
   return await getFreshDomainFlow2(domain);
 }
+async function handleMap(_params) {
+  sessionMemory.recordToolCall("kuma_context_map", {});
+  const { getWorkspaceInfo: getWorkspaceInfo2, formatWorkspaceMap: formatWorkspaceMap2 } = await Promise.resolve().then(() => (init_workspaceIntelligence(), workspaceIntelligence_exports));
+  const wsInfo = await getWorkspaceInfo2();
+  return formatWorkspaceMap2(wsInfo);
+}
+async function handleImpact(params) {
+  const target = params.target || params.scope || "project";
+  sessionMemory.recordToolCall("kuma_context_impact", { target });
+  const { analyzeImpact: analyzeImpact2, formatImpact: formatImpact2 } = await Promise.resolve().then(() => (init_kumaGraph(), kumaGraph_exports));
+  const impact = await analyzeImpact2(target);
+  return formatImpact2(impact);
+}
 function computeProjectHash(scope) {
   try {
     const root = getProjectRoot();
-    const files = fs14.readdirSync(root).slice(0, 20);
+    const files = fs16.readdirSync(root).slice(0, 20);
     const hash = crypto3.createHash("md5");
     hash.update(scope);
     for (const f of files) {
       try {
-        const stat = fs14.statSync(path15.join(root, f));
+        const stat = fs16.statSync(path17.join(root, f));
         hash.update(`${f}:${stat.mtimeMs}`);
       } catch {
       }
@@ -8760,8 +10508,8 @@ init_kumaDb();
 init_kumaMemory();
 init_pathValidator();
 init_pathValidator();
-import fs16 from "fs";
-import path17 from "path";
+import fs18 from "fs";
+import path19 from "path";
 var MEMORY_ALIASES = {
   "decision": "decision",
   "adr": "decision",
@@ -8777,7 +10525,13 @@ var MEMORY_ALIASES = {
   "architecture": "arch_flow",
   "gotcha": "gotcha",
   "gotchas": "gotcha",
-  "quirk": "gotcha"
+  "quirk": "gotcha",
+  "resolve_gotcha": "gotcha",
+  "resolve-gotcha": "gotcha",
+  "resolve": "gotcha",
+  "deprecate_gotcha": "gotcha",
+  "deprecate-gotcha": "gotcha",
+  "deprecate": "gotcha"
 };
 async function handleMemory(params) {
   const rawAction = params.action || "search";
@@ -8844,9 +10598,9 @@ async function handleResearchSave(params) {
   } catch {
   }
   try {
-    const researchDir = path17.join(getProjectRoot(), ".kuma", "research");
-    if (!fs16.existsSync(researchDir)) fs16.mkdirSync(researchDir, { recursive: true });
-    fs16.writeFileSync(path17.join(researchDir, `${scope}.json`), JSON.stringify(JSON.parse(record), null, 2), "utf-8");
+    const researchDir = path19.join(getProjectRoot(), ".kuma", "research");
+    if (!fs18.existsSync(researchDir)) fs18.mkdirSync(researchDir, { recursive: true });
+    fs18.writeFileSync(path19.join(researchDir, `${scope}.json`), JSON.stringify(JSON.parse(record), null, 2), "utf-8");
   } catch {
   }
   sessionMemory.recordMemoryAction("research_save");
@@ -8966,28 +10720,70 @@ async function handleArchFlow(params) {
   return readLayer2("arch_flow");
 }
 async function handleGotchaAction(params) {
+  const rawStatus = (params.status || "").toLowerCase().trim();
+  const rawAction = (params.action || "").toLowerCase().trim();
+  const isResolution = rawStatus === "resolved" || rawStatus === "resolve" || rawAction === "resolve_gotcha" || rawAction === "resolve";
+  const isDeprecation = rawStatus === "deprecated" || rawStatus === "deprecate" || rawAction === "deprecate_gotcha" || rawAction === "deprecate";
+  const target = params.target || params.id || params.scope;
+  if (isResolution && target) {
+    const { resolveGotcha: resolveGotcha2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
+    const res = await resolveGotcha2(
+      target,
+      params.content || params.rationale || params.description,
+      "agent"
+    );
+    sessionMemory.recordMemoryAction("gotcha");
+    return res.message;
+  }
+  if (isDeprecation && target) {
+    const { deprecateGotcha: deprecateGotcha2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
+    const res = await deprecateGotcha2(
+      target,
+      params.content || params.rationale || params.description
+    );
+    sessionMemory.recordMemoryAction("gotcha");
+    return res.message;
+  }
   const content = (params.content ?? params.description ?? "").trim();
   const scope = (params.scope ?? "").trim();
+  const validSeverities = ["low", "medium", "high", "critical"];
+  const validStatuses = ["candidate", "active", "verified", "resolved", "deprecated"];
+  let severity = "medium";
+  if (params.severity && validSeverities.includes(params.severity.toLowerCase())) {
+    severity = params.severity.toLowerCase();
+  } else if (rawStatus && validSeverities.includes(rawStatus)) {
+    severity = rawStatus;
+  }
+  let status = "active";
+  if (rawStatus && validStatuses.includes(rawStatus)) {
+    status = rawStatus;
+  }
   if (content && scope) {
     const normalizedScope = normalizeScope(scope) || scope;
     const { addGotcha: addGotcha2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
     const result = await addGotcha2({
       filePath: normalizedScope,
       description: content,
-      severity: params.status || "medium",
+      severity,
+      status,
       // `description` doubles as workaround only when the canonical `content` field was used.
       workaround: params.content ? params.description : void 0,
-      triggerCommand: params.trigger_command
+      triggerCommand: params.trigger_command,
+      scopePackage: params.scopePackage
     });
     sessionMemory.recordMemoryAction("gotcha");
     return result;
   }
   if (scope || params.title || params.status || params.trigger_command || params.description) {
-    return '\u274C **Gotcha NOT saved** \u2014 missing `content` (bug description).\n\u2705 Use: kuma_memory({ action: "gotcha", scope: "<file_path>", content: "<what went wrong>", status: "high" })\n- `scope` \u2014 file path where the bug was found\n- `content` \u2014 bug description (required to save)\n- `status` \u2014 low | medium | high | critical';
+    return '\u274C **Gotcha NOT saved** \u2014 missing `content` (bug description).\n\u2705 Use: kuma_memory({ action: "gotcha", scope: "<file_path>", content: "<what went wrong>", status: "high" })\n- `scope` \u2014 file path where the bug was found\n- `content` \u2014 bug description (required to save)\n- `status` \u2014 low | medium | high | critical (or \'resolved\' to mark fixed)';
   }
   const { listGotchas: listGotchas2, syncGotchasToDb: syncGotchasToDb2 } = await Promise.resolve().then(() => (init_kumaGotchas(), kumaGotchas_exports));
   await syncGotchasToDb2();
-  return await listGotchas2({ filePath: params.scope, severity: params.status });
+  return await listGotchas2({
+    filePath: params.scope,
+    severity: validSeverities.includes(rawStatus) ? rawStatus : void 0,
+    status: validStatuses.includes(rawStatus) ? rawStatus : void 0
+  });
 }
 
 // src/tools/kumaSafetyTool.ts
@@ -9000,8 +10796,8 @@ init_sessionMemory();
 init_pathValidator();
 init_sessionMemory();
 init_kumaShared();
-import fs17 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path20 from "path";
 import { execSync as execSync4 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
@@ -9028,20 +10824,20 @@ function findPatchScripts(projectRoot) {
   const warnings = [];
   const recentFiles = scanRecentFiles(projectRoot);
   for (const file of recentFiles) {
-    const ext = path18.extname(file).toLowerCase();
+    const ext = path20.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
-    const relativePath = path18.relative(projectRoot, file);
+    const relativePath = path20.relative(projectRoot, file);
     if (relativePath.startsWith("src") || relativePath.startsWith("test") || relativePath.startsWith("node_modules") || relativePath.startsWith(".") || relativePath.startsWith(".kuma/scratch")) {
       continue;
     }
     try {
-      const content = fs17.readFileSync(file, "utf-8").toLowerCase();
+      const content = fs19.readFileSync(file, "utf-8").toLowerCase();
       const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
       if (matchedPattern) {
         warnings.push({
           severity: "high",
           pattern: "script-patching",
-          message: `Created script file that modifies other files: ${path18.basename(file)}`,
+          message: `Created script file that modifies other files: ${path20.basename(file)}`,
           suggestion: "Use your native edit tools instead \u2014 targeted edits with auto-backup and rollback",
           evidence: `File: ${relativePath} contains '${matchedPattern}'`,
           filePath: relativePath
@@ -9075,15 +10871,15 @@ function detectBashGrepUsage() {
 function scanRecentFiles(projectRoot) {
   const recent = [];
   try {
-    const entries = fs17.readdirSync(projectRoot, { withFileTypes: true });
+    const entries = fs19.readdirSync(projectRoot, { withFileTypes: true });
     const now = Date.now();
     const recentThreshold = 30 * 60 * 1e3;
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       try {
-        const stat = fs17.statSync(path18.join(projectRoot, entry.name));
+        const stat = fs19.statSync(path20.join(projectRoot, entry.name));
         if (now - stat.mtimeMs < recentThreshold || now - stat.ctimeMs < recentThreshold) {
-          recent.push(path18.join(projectRoot, entry.name));
+          recent.push(path20.join(projectRoot, entry.name));
         }
       } catch {
         continue;
@@ -9107,14 +10903,14 @@ function detectGitPatchScripts(projectRoot) {
         const prefix = line.substring(0, 2);
         if (prefix !== "??" && prefix !== "A ") continue;
         const file = line.substring(3).trim();
-        const ext = path18.extname(file).toLowerCase();
+        const ext = path20.extname(file).toLowerCase();
         if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
         const isRootLevel = !file.includes("/");
         const isScriptsDir = file.startsWith("scripts/") || file.startsWith("patches/");
         if (!isRootLevel && !isScriptsDir) continue;
-        const fullPath = path18.join(projectRoot, file);
-        if (fs17.existsSync(fullPath)) {
-          const content = fs17.readFileSync(fullPath, "utf-8").toLowerCase();
+        const fullPath = path20.join(projectRoot, file);
+        if (fs19.existsSync(fullPath)) {
+          const content = fs19.readFileSync(fullPath, "utf-8").toLowerCase();
           const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
           if (matchedPattern) {
             warnings.push({
@@ -9137,7 +10933,7 @@ function detectGitPatchScripts(projectRoot) {
     if (deletedStdout) {
       const deletedFiles = deletedStdout.split("\n").filter(Boolean);
       for (const file of deletedFiles) {
-        const ext = path18.extname(file).toLowerCase();
+        const ext = path20.extname(file).toLowerCase();
         if (SCRIPT_EXTENSIONS.includes(ext)) {
           warnings.push({
             severity: "high",
@@ -9199,21 +10995,21 @@ function detectAllAntiPatterns() {
 // src/engine/contextSnapshot.ts
 init_sessionMemory();
 init_pathValidator();
-import fs18 from "fs";
-import path19 from "path";
+import fs20 from "fs";
+import path21 from "path";
 import { execSync as execSync5 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
-  return path19.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
+  return path21.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
 }
 function ensureSnapshotDir() {
   const dir = snapshotDir();
-  if (!fs18.existsSync(dir)) {
-    fs18.mkdirSync(dir, { recursive: true });
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true });
   }
 }
 function snapshotFilePath(timestamp) {
-  return path19.join(snapshotDir(), `${timestamp}.json`);
+  return path21.join(snapshotDir(), `${timestamp}.json`);
 }
 function saveSnapshot(goal) {
   try {
@@ -9234,7 +11030,7 @@ function saveSnapshot(goal) {
     hasConventions: !!summary.hasConventions
   };
   try {
-    fs18.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
+    fs20.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
   } catch {
   }
   sessionMemory.recordToolCall("kuma_context", { action: "save", goal: snapshot.goal });
@@ -9294,6 +11090,22 @@ async function handleKumaGuard(params) {
   if (check === "all" || check === "anti-pattern") {
     warnings.push(...detectAllAntiPatterns());
   }
+  if (check === "all" || check === "architecture") {
+    try {
+      const { checkArchitectureBoundaries: checkArchitectureBoundaries2 } = await Promise.resolve().then(() => (init_architectureGuard(), architectureGuard_exports));
+      const modifiedPaths = stats.modifiedFiles.map((f) => f.filePath);
+      const violations = await checkArchitectureBoundaries2(modifiedPaths.length > 0 ? modifiedPaths : void 0);
+      for (const v of violations) {
+        warnings.push({
+          severity: v.severity,
+          pattern: `arch-boundary:${v.rule}`,
+          message: `Architecture violation in ${v.sourceFile}: ${v.targetImport}`,
+          suggestion: v.suggestion
+        });
+      }
+    } catch {
+    }
+  }
   const loop = check === "all" || check === "loop" ? sessionMemory.detectLoop() : { isLooping: false };
   if (loop.isLooping) {
     warnings.push({
@@ -9754,14 +11566,14 @@ async function main() {
     } catch {
     }
     try {
-      const path25 = await import("path");
-      const fs24 = await import("fs");
-      const lockDir = path25.resolve(process.cwd(), ".kuma/verifier.lock");
-      if (fs24.existsSync(lockDir)) {
-        const pidFile = path25.join(lockDir, "pid");
-        if (fs24.existsSync(pidFile)) {
+      const path28 = await import("path");
+      const fs27 = await import("fs");
+      const lockDir = path28.resolve(process.cwd(), ".kuma/verifier.lock");
+      if (fs27.existsSync(lockDir)) {
+        const pidFile = path28.join(lockDir, "pid");
+        if (fs27.existsSync(pidFile)) {
           try {
-            const pid = parseInt(fs24.readFileSync(pidFile, "utf-8"), 10);
+            const pid = parseInt(fs27.readFileSync(pidFile, "utf-8"), 10);
             if (pid && pid !== process.pid) {
               try {
                 process.kill(-pid, "SIGKILL");
@@ -9777,7 +11589,7 @@ async function main() {
           } catch {
           }
         }
-        fs24.rmSync(lockDir, { recursive: true, force: true });
+        fs27.rmSync(lockDir, { recursive: true, force: true });
       }
       if (killedCount === 0) {
         console.error("\u2705 No running verifications found to kill.");
@@ -9976,23 +11788,23 @@ async function main() {
     });
     const output = formatInitResults(results);
     console.log(output);
-    const fs24 = await import("fs");
-    const path25 = await import("path");
-    const matchaSkills = path25.resolve(process.cwd(), "skills/matcha/SKILL.md");
-    const matchaAgents = path25.resolve(
+    const fs27 = await import("fs");
+    const path28 = await import("path");
+    const matchaSkills = path28.resolve(process.cwd(), "skills/matcha/SKILL.md");
+    const matchaAgents = path28.resolve(
       process.cwd(),
       ".agents/skills/matcha/SKILL.md"
     );
-    const matchaRootSkills = path25.resolve(
+    const matchaRootSkills = path28.resolve(
       process.cwd(),
       "skills/matcha/SKILL.md"
     );
-    const matchaAgentsMd = path25.resolve(process.cwd(), "AGENTS.md");
-    const matchaWindsurfRules = path25.resolve(
+    const matchaAgentsMd = path28.resolve(process.cwd(), "AGENTS.md");
+    const matchaWindsurfRules = path28.resolve(
       process.cwd(),
       ".windsurf"
     );
-    if (fs24.existsSync(matchaSkills) || fs24.existsSync(matchaAgents) || fs24.existsSync(matchaRootSkills) || fs24.existsSync(matchaAgentsMd) || fs24.existsSync(matchaWindsurfRules)) {
+    if (fs27.existsSync(matchaSkills) || fs27.existsSync(matchaAgents) || fs27.existsSync(matchaRootSkills) || fs27.existsSync(matchaAgentsMd) || fs27.existsSync(matchaWindsurfRules)) {
       console.error(
         "\n\u{1F375} Hey, I see matcha is installed \u2014 they pair well together!"
       );
@@ -10006,13 +11818,13 @@ async function main() {
   (async () => {
     try {
       const { generateInitMdContent: generateInitMdContent2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-      const fs24 = await import("fs");
-      const path25 = await import("path");
-      const initMdPath = path25.resolve(process.cwd(), ".kuma/init.md");
-      if (!fs24.existsSync(initMdPath)) {
-        const kumaDir = path25.dirname(initMdPath);
-        if (!fs24.existsSync(kumaDir)) fs24.mkdirSync(kumaDir, { recursive: true });
-        fs24.writeFileSync(initMdPath, generateInitMdContent2(), "utf-8");
+      const fs27 = await import("fs");
+      const path28 = await import("path");
+      const initMdPath = path28.resolve(process.cwd(), ".kuma/init.md");
+      if (!fs27.existsSync(initMdPath)) {
+        const kumaDir = path28.dirname(initMdPath);
+        if (!fs27.existsSync(kumaDir)) fs27.mkdirSync(kumaDir, { recursive: true });
+        fs27.writeFileSync(initMdPath, generateInitMdContent2(), "utf-8");
         console.error(`[${SERVER_NAME}] Auto-generated .kuma/init.md`);
       }
     } catch (err) {
@@ -10023,8 +11835,8 @@ async function main() {
     try {
       const { detectAgent: detectAgent2, getSkillPath: getSkillPath2, getAgentLabel: getAgentLabel2 } = await Promise.resolve().then(() => (init_agentDetector(), agentDetector_exports));
       const { generateSkill: generateSkill2, getSecondaryFiles: getSecondaryFiles2 } = await Promise.resolve().then(() => (init_skillGenerator(), skillGenerator_exports));
-      const fs24 = await import("fs");
-      const path25 = await import("path");
+      const fs27 = await import("fs");
+      const path28 = await import("path");
       const detection = detectAgent2();
       if (!detection.primary) {
         console.error(`[${SERVER_NAME}] No AI agent detected \u2014 skipping auto-skill creation`);
@@ -10032,22 +11844,22 @@ async function main() {
       }
       const agentType = detection.primary;
       const skillPath = getSkillPath2(agentType);
-      const fullPath = path25.resolve(process.cwd(), skillPath);
-      if (fs24.existsSync(fullPath)) {
+      const fullPath = path28.resolve(process.cwd(), skillPath);
+      if (fs27.existsSync(fullPath)) {
         console.error(`[${SERVER_NAME}] Skill exists for ${getAgentLabel2(agentType)} \u2014 skipping`);
         return;
       }
-      const dir = path25.dirname(fullPath);
-      if (!fs24.existsSync(dir)) fs24.mkdirSync(dir, { recursive: true });
-      fs24.writeFileSync(fullPath, generateSkill2(agentType), "utf-8");
+      const dir = path28.dirname(fullPath);
+      if (!fs27.existsSync(dir)) fs27.mkdirSync(dir, { recursive: true });
+      fs27.writeFileSync(fullPath, generateSkill2(agentType), "utf-8");
       console.error(`[${SERVER_NAME}] Auto-created ${skillPath} for ${getAgentLabel2(agentType)}`);
       const secondaryFiles = getSecondaryFiles2(agentType);
       for (const sf of secondaryFiles) {
-        const sfPath = path25.resolve(process.cwd(), sf.path);
-        const sfDir = path25.dirname(sfPath);
-        if (!fs24.existsSync(sfPath)) {
-          if (!fs24.existsSync(sfDir)) fs24.mkdirSync(sfDir, { recursive: true });
-          fs24.writeFileSync(sfPath, sf.content, "utf-8");
+        const sfPath = path28.resolve(process.cwd(), sf.path);
+        const sfDir = path28.dirname(sfPath);
+        if (!fs27.existsSync(sfPath)) {
+          if (!fs27.existsSync(sfDir)) fs27.mkdirSync(sfDir, { recursive: true });
+          fs27.writeFileSync(sfPath, sf.content, "utf-8");
           console.error(`[${SERVER_NAME}] Auto-created ${sf.path}`);
         }
       }