knit-mcp 0.9.0 → 0.11.2

package/dist/{chunk-4K4FHOKE.js → chunk-HROSQ5MS.js}

@@ -1,79 +1,21 @@
 import {
-  installAgentsForProject,
-  prewarmLatestVersion,
-  pruneSessionsByAge
-} from "./chunk-BU3VHX3W.js";
-import {
-  buildKnowledge,
-  buildReverseDependencies
-} from "./chunk-MOOVNMIN.js";
-import {
-  scanProject
-} from "./chunk-7PPC6IG6.js";
-import {
-  readLearnings
-} from "./chunk-M3YZOJNW.js";
-import {
-  persistScanResult,
-  scanIntegrations
-} from "./chunk-FLNV2IQC.js";
-import {
-  KNIT_MARKER_START,
-  generateClaudeMd,
-  spliceKnitBlock
-} from "./chunk-KLNUEE3O.js";
-import {
-  importFromMarkdown,
-  loadKnowledgeBase,
-  saveKnowledgeBase
-} from "./chunk-BAUQEFYY.js";
-import {
+  claimMarkerPath,
   classificationMarkerPath,
   knowledgePath,
   knowledgebasePath,
   learningsDir,
   learningsFilePath,
-  legacyClaudeDir,
-  legacyKnowledgePath,
-  legacyKnowledgebasePath,
-  legacyLearningsDir,
-  legacyTeamsPath,
-  migrationBreadcrumbPath,
   projectDataDir,
   protocolConfigPath,
   searchMarkerPath,
   sessionMarkerPath,
   sessionsJsonlPath,
   sessionsLogPath,
-  teamsPath
-} from "./chunk-XFS2XGZI.js";
-
-// src/mcp/cache.ts
-import { execSync } from "child_process";
-import { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join, basename, dirname } from "path";
-
-// src/generators/learnings.ts
-function generateLearningsContent(config) {
-  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return `# Project Learnings \u2014 ${config.name}
-
-> Recursive learning log. Check this BEFORE starting any task.
-> Grep by \`#tag\` to find relevant lessons for the domain you're working in.
-
----
-
-## ${date} Project initialized with Knit workflow
-**Domain(s):** All \u2014 workflow infrastructure
-**Approach:** Auto-detected stack (${config.stack.language}${config.stack.framework ? " + " + config.stack.framework : ""}), generated ${config.domains.length} domains, wired hooks for ${config.targetAgent}.
-**Outcome:** Success \u2014 workflow infrastructure in place
-**Lesson:** This learnings file is the institutional memory. Every task should append an entry. Every session should check relevant tags before starting work. The LEARN phase is a hard exit gate \u2014 no task completes without updating this file.
-**Tags:** #workflow #all #bootstrap
-`;
-}
+  turnEditLogPath
+} from "./chunk-27TA2ZQZ.js";
 
 // src/generators/settings.ts
-var HOOKS_VERSION = 7;
+var HOOKS_VERSION = 11;
 function generateSettings(config, rootPath) {
   return {
     mcpServers: {
@@ -120,6 +62,8 @@ function generateHooks(config, rootPath) {
   const CLASSIFIED_MARKER = classificationMarkerPath(rootPath);
   const SESSION_MARKER = sessionMarkerPath(rootPath);
   const SEARCH_MARKER = searchMarkerPath(rootPath);
+  const CLAIM_MARKER = claimMarkerPath(rootPath);
+  const TURN_EDIT_LOG = turnEditLogPath(rootPath);
   const CLAUDE_MD = `${rootPath}/CLAUDE.md`;
   void knowledgePath;
   const hooks = {
@@ -164,6 +108,14 @@ function generateHooks(config, rootPath) {
                 // so the next non-trivial task has to call knit_search_learnings again.
                 const sm = ${jsLit(SEARCH_MARKER)};
                 if (fs.existsSync(sm)) fs.rmSync(sm, { force: true });
+                // v0.11 slice 1: per-turn claim-verified marker \u2014 Stop-hook gate
+                // requires fresh verify_claim per non-trivial task.
+                const cm = ${jsLit(CLAIM_MARKER)};
+                if (fs.existsSync(cm)) fs.rmSync(cm, { force: true });
+                // v0.11 slice 3: per-turn edit log \u2014 the Stop-hook drift detector
+                // re-classifies the actual touched set and surfaces scope creep.
+                const tl = ${jsLit(TURN_EDIT_LOG)};
+                if (fs.existsSync(tl)) fs.rmSync(tl, { force: true });
               } catch (e) {}
             `),
             timeout: 5
@@ -309,6 +261,155 @@ function generateHooks(config, rootPath) {
     PostToolUse: [],
     Stop: []
   };
+  hooks.PostToolUse.push({
+    _knitOwned: true,
+    matcher: "Write|Edit|MultiEdit",
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          let d = "";
+          process.stdin.on("data", (c) => d += c);
+          process.stdin.on("end", () => {
+            try {
+              const fs = require("fs");
+              const path = require("path");
+              const i = JSON.parse(d);
+              const ti = i.tool_input || {};
+              const f = ti.file_path || (i.tool_response && i.tool_response.filePath) || "";
+              if (!f) return;
+              const logPath = ${jsLit(TURN_EDIT_LOG)};
+              fs.mkdirSync(path.dirname(logPath), { recursive: true });
+              fs.appendFileSync(logPath, JSON.stringify({ file: f, ts: new Date().toISOString() }) + "\\n");
+            } catch (e) { try { process.stderr.write('[knit] turn-edit appender hook failed: ' + (e && e.message ? e.message : e) + '\\n'); } catch {} }
+          });
+        `),
+        timeout: 5
+      }
+    ]
+  });
+  hooks.PostToolUse.push({
+    _knitOwned: true,
+    matcher: "Write|Edit|MultiEdit",
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          let d = "";
+          process.stdin.on("data", (c) => d += c);
+          process.stdin.on("end", () => {
+            try {
+              const fs = require("fs");
+              const i = JSON.parse(d);
+              const toolName = i.tool_name || "";
+              const ti = i.tool_input || {};
+              const f = ti.file_path || (i.tool_response && i.tool_response.filePath) || "";
+              if (!f || !fs.existsSync(f)) return;
+              const cur = fs.readFileSync(f, "utf-8");
+              if (toolName === "Write") {
+                const intended = ti.content || "";
+                if (cur === intended) {
+                  console.error("[knit] verify: write landed \u2014 " + f);
+                } else {
+                  const lenDelta = cur.length - intended.length;
+                  console.error("[knit] verify: write DRIFTED \u2014 " + f + " differs by " + lenDelta + " char(s) from intent. Something modified the file after Write.");
+                }
+              } else if (toolName === "Edit") {
+                const newStr = ti.new_string || "";
+                const oldStr = ti.old_string || "";
+                if (newStr && cur.indexOf(newStr) !== -1) {
+                  console.error("[knit] verify: edit landed \u2014 " + f);
+                } else if (oldStr && cur.indexOf(oldStr) !== -1) {
+                  console.error("[knit] verify: edit DRIFTED \u2014 " + f + " still contains the old_string. Edit may have silently failed.");
+                } else {
+                  console.error("[knit] verify: edit ambiguous \u2014 " + f + " contains neither new_string nor old_string. Inspect manually.");
+                }
+              } else if (toolName === "MultiEdit") {
+                const edits = Array.isArray(ti.edits) ? ti.edits : [];
+                let landed = 0;
+                let drifted = 0;
+                for (const e of edits) {
+                  if (e && e.new_string && cur.indexOf(e.new_string) !== -1) landed++;
+                  else drifted++;
+                }
+                if (drifted === 0) {
+                  console.error("[knit] verify: all " + landed + " edits landed \u2014 " + f);
+                } else {
+                  console.error("[knit] verify: " + drifted + " of " + (landed + drifted) + " edits DRIFTED \u2014 " + f + ". Some new_string values not found in file post-edit.");
+                }
+              }
+            } catch (e) { try { process.stderr.write('[knit] diff verifier hook failed: ' + (e && e.message ? e.message : e) + '\\n'); } catch {} }
+          });
+        `),
+        timeout: 5,
+        statusMessage: "Knit: verifying edit landed..."
+      }
+    ]
+  });
+  hooks.PostToolUse.push({
+    _knitOwned: true,
+    matcher: "Write|Edit|MultiEdit",
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          let d = "";
+          process.stdin.on("data", (c) => d += c);
+          process.stdin.on("end", () => {
+            try {
+              const fs = require("fs");
+              const path = require("path");
+              const cp = require("child_process");
+              const i = JSON.parse(d);
+              const ti = i.tool_input || {};
+              const f = ti.file_path || (i.tool_response && i.tool_response.filePath) || "";
+              if (!/\\.(?:ts|tsx|mts|cts)$/.test(f)) return;
+              // Walk up to find tsconfig.json (project root).
+              let dir = path.dirname(f);
+              let projectRoot = null;
+              for (let depth = 0; depth < 10; depth++) {
+                if (fs.existsSync(path.join(dir, "tsconfig.json"))) { projectRoot = dir; break; }
+                const parent = path.dirname(dir);
+                if (parent === dir) break;
+                dir = parent;
+              }
+              if (!projectRoot) return;
+              // Prefer local tsc; fall back to npx.
+              const localTsc = path.join(projectRoot, "node_modules", ".bin", "tsc");
+              const tscBin = fs.existsSync(localTsc) ? localTsc : "npx";
+              const tscArgs = fs.existsSync(localTsc) ? ["--noEmit", "--pretty", "false"] : ["--no-install", "tsc", "--noEmit", "--pretty", "false"];
+              let out = "";
+              let failed = false;
+              try {
+                cp.execFileSync(tscBin, tscArgs, { cwd: projectRoot, stdio: ["ignore", "pipe", "pipe"], timeout: 15000, encoding: "utf-8" });
+              } catch (err) {
+                failed = true;
+                out = (err && (err.stdout || err.stderr) || "").toString();
+              }
+              if (!failed) {
+                console.error("[knit] tsc check: clean \u2014 " + f);
+                return;
+              }
+              // Filter tsc output to errors mentioning the touched file (or its dir).
+              const touched = path.basename(f);
+              const lines = out.split("\\n").map((s) => s.trim()).filter(Boolean);
+              const relevant = lines.filter((l) => l.indexOf(touched) !== -1 || l.indexOf(f) !== -1);
+              const errorCount = lines.filter((l) => /error TS\\d+:/.test(l)).length;
+              if (relevant.length > 0) {
+                console.error("[knit] tsc check: " + relevant.length + " error(s) referencing " + touched + ":");
+                for (const l of relevant.slice(0, 6)) console.error("  " + l);
+                if (relevant.length > 6) console.error("  ... and " + (relevant.length - 6) + " more");
+              } else if (errorCount > 0) {
+                console.error("[knit] tsc check: project has " + errorCount + " type error(s) (none in " + touched + " directly \u2014 likely a cross-file ripple). Run \`npx tsc --noEmit\` for full output.");
+              }
+            } catch (e) { try { process.stderr.write('[knit] tsc check hook failed: ' + (e && e.message ? e.message : e) + '\\n'); } catch {} }
+          });
+        `),
+        timeout: 20,
+        statusMessage: "Knit: tsc on edit..."
+      }
+    ]
+  });
   hooks.PostToolUse.push({
     _knitOwned: true,
     matcher: "Write|Edit|MultiEdit",
@@ -352,32 +453,6 @@ function generateHooks(config, rootPath) {
       }
     ]
   });
-  if (config.stack.language === "typescript" && config.stack.typecheckCommand) {
-    hooks.PostToolUse.push({
-      _knitOwned: true,
-      matcher: "Write|Edit",
-      hooks: [
-        {
-          type: "command",
-          command: nodeHook(`
-            let d = "";
-            process.stdin.on("data", (c) => d += c);
-            process.stdin.on("end", () => {
-              try {
-                const i = JSON.parse(d);
-                const f = (i.tool_input && i.tool_input.file_path) || (i.tool_response && i.tool_response.filePath) || "";
-                if (!/\\.tsx?$/.test(f)) return;
-                ${REPO_ROOT_JS}
-                require("child_process").execSync("npx tsc --noEmit --pretty false", { cwd: __getRoot(), stdio: "inherit" });
-              } catch (e) {}
-            });
-          `),
-          timeout: 30,
-          statusMessage: "Type checking..."
-        }
-      ]
-    });
-  }
   if (config.stack.language === "python") {
     hooks.PostToolUse.push({
       _knitOwned: true,
@@ -482,6 +557,97 @@ function generateHooks(config, rootPath) {
       ]
     });
   }
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            const path = require("path");
+            const classifiedPath = ${jsLit(CLASSIFIED_MARKER)};
+            const logPath = ${jsLit(TURN_EDIT_LOG)};
+            if (!fs.existsSync(classifiedPath) || !fs.existsSync(logPath)) return;
+            let marker;
+            try {
+              marker = JSON.parse(fs.readFileSync(classifiedPath, "utf-8"));
+            } catch (e) { return; }
+            const originalScope = (marker && (marker.scopeTier || marker.tier)) || "";
+            const originalRisk = (marker && marker.riskTier) || "low";
+            if (!originalScope) return;
+            // Parse turn-edit log \u2192 unique file set.
+            const seen = new Set();
+            const raw = fs.readFileSync(logPath, "utf-8");
+            for (const line of raw.split("\\n")) {
+              if (!line.trim()) continue;
+              try { const e = JSON.parse(line); if (e.file) seen.add(e.file); } catch (e2) {}
+            }
+            const touched = Array.from(seen);
+            const n = touched.length;
+            if (n === 0) return;
+            // Scope drift: trivial classification but turn touched 3+ files.
+            const scopeDrift = (originalScope === "trivial" && n >= 3) ||
+                               (originalScope === "standard" && n >= 6);
+            // Risk drift: low-risk classification but turn touched risky files.
+            const riskyPatterns = /(\\btypes?\\.tsx?|\\bschema\\.|\\bauth\\.|\\bsecurity\\.|migrations?\\/)/i;
+            const riskyHit = touched.find((f) => riskyPatterns.test(f));
+            const riskDrift = originalRisk === "low" && !!riskyHit;
+            if (!scopeDrift && !riskDrift) return;
+            console.error("[knit] drift detector \u2014 turn touched " + n + " file(s); classification was scope=" + originalScope + ", risk=" + originalRisk);
+            if (scopeDrift) {
+              console.error("  scope drift: " + n + " files exceeds the " + originalScope + " threshold. Next time, re-classify when scope grows.");
+            }
+            if (riskDrift) {
+              console.error("  risk drift: low-risk classification but touched " + riskyHit + " \u2014 high-risk pattern (types/schema/auth/migrations). Should have triggered plan mode.");
+            }
+            console.error("  touched: " + touched.slice(0, 8).join(", ") + (touched.length > 8 ? " ... and " + (touched.length - 8) + " more" : ""));
+          } catch (e) {}
+        `),
+        timeout: 5,
+        statusMessage: "Knit: drift detector..."
+      }
+    ]
+  });
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            const cfgPath = ${jsLit(PROTOCOL_CONFIG)};
+            const classifiedPath = ${jsLit(CLASSIFIED_MARKER)};
+            const claimPath = ${jsLit(CLAIM_MARKER)};
+            let level = "warn";
+            if (fs.existsSync(cfgPath)) {
+              try {
+                const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+                if (cfg && (cfg.level === "off" || cfg.level === "warn" || cfg.level === "block")) level = cfg.level;
+              } catch (parseErr) {}
+            }
+            if (level === "off") return;
+            if (!fs.existsSync(classifiedPath)) return;
+            let scope;
+            try {
+              const marker = JSON.parse(fs.readFileSync(classifiedPath, "utf-8"));
+              scope = (marker && (marker.scopeTier || marker.tier)) || "";
+            } catch (e) { return; }
+            if (scope !== "standard" && scope !== "complex") return;
+            if (fs.existsSync(claimPath)) return;
+            if (level === "block") {
+              console.error("[knit] BLOCKED: " + scope + " task ended without verify_claim. The REVIEW gate requires \u22651 knit_verify_claim call before LEARN \u2014 verify the agent's claims against the knowledge graph or rerun.");
+              process.exit(2);
+            }
+            console.error("[knit] reminder: " + scope + " task ended without knit_verify_claim. The REVIEW gate is the anti-slop guard \u2014 verify the agent's claims against the graph before declaring done. Set strictness=block via knit_set_protocol_strictness to make this hard.");
+          } catch (e) {}
+        `),
+        timeout: 5,
+        statusMessage: "Knit: REVIEW claim-gate..."
+      }
+    ]
+  });
   hooks.Stop.push({
     _knitOwned: true,
     hooks: [
@@ -628,261 +794,7 @@ function generateHooks(config, rootPath) {
   return hooks;
 }
 
-// src/mcp/cache.ts
-var cache = null;
-var hooksRefreshed = /* @__PURE__ */ new Set();
-function maybeRefreshHooks(rootPath, config) {
-  if (hooksRefreshed.has(rootPath)) return;
-  hooksRefreshed.add(rootPath);
-  const settingsPath = join(rootPath, ".claude", "settings.local.json");
-  if (!existsSync(settingsPath)) return;
-  try {
-    const existing = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    const storedVersion = existing?._knitHooks?.version ?? (existing?._engramHooks ? 0 : 0);
-    if (storedVersion < HOOKS_VERSION) {
-      writeKnitHooks(rootPath, config);
-    }
-  } catch {
-  }
-}
-function getBrain(rootPath) {
-  if (cache && cache.rootPath === rootPath) {
-    return cache;
-  }
-  void prewarmLatestVersion();
-  let autoInitialized = false;
-  const haveCentralized = existsSync(knowledgePath(rootPath));
-  const haveLegacy = existsSync(legacyKnowledgePath(rootPath));
-  if (!haveCentralized) {
-    if (haveLegacy) {
-      migrateLegacyData(rootPath);
-    } else {
-      autoInitialize(rootPath);
-      autoInitialized = true;
-    }
-  }
-  const scan = scanProject(rootPath);
-  const knowledge = buildKnowledge(rootPath, scan);
-  const reverseDeps = buildReverseDependencies(knowledge.importGraph);
-  const projectName = detectProjectName(rootPath);
-  const knowledgeBase = loadKnowledgeBase(knowledgebasePath(rootPath), projectName);
-  const config = {
-    name: projectName,
-    packageManager: scan.packageManager,
-    stack: scan.stack,
-    domains: scan.domains,
-    targetAgent: "claude-code",
-    tokenOptimization: "standard"
-  };
-  writeFileSync(knowledgePath(rootPath), JSON.stringify(knowledge, null, 2), "utf-8");
-  saveKnowledgeBase(knowledgebasePath(rootPath), knowledgeBase);
-  if (!autoInitialized) {
-    maybeRefreshHooks(rootPath, config);
-  }
-  cache = {
-    rootPath,
-    knowledge,
-    reverseDeps,
-    knowledgeBase,
-    config,
-    loadedAt: Date.now(),
-    autoInitialized
-  };
-  return cache;
-}
-function autoInitialize(rootPath) {
-  const scan = scanProject(rootPath);
-  const knowledge = buildKnowledge(rootPath, scan);
-  const projectName = detectProjectName(rootPath);
-  const config = {
-    name: projectName,
-    packageManager: scan.packageManager,
-    stack: scan.stack,
-    domains: scan.domains,
-    targetAgent: "claude-code",
-    tokenOptimization: "standard"
-  };
-  mkdirSync(projectDataDir(rootPath), { recursive: true });
-  mkdirSync(learningsDir(rootPath), { recursive: true });
-  writeProjectClaudeMd(rootPath, config, knowledge);
-  writeKnitHooks(rootPath, config);
-  installAgentsForProject(rootPath, config, knowledge, null).catch((err) => {
-    process.stderr.write(`[knit] agent install background error: ${err?.message ?? err}
-`);
-  });
-  Promise.resolve().then(() => {
-    try {
-      pruneSessionsByAge(rootPath, 90);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`[knit] session prune background error: ${msg}
-`);
-    }
-  });
-  Promise.resolve().then(() => {
-    try {
-      const result = scanIntegrations(rootPath);
-      persistScanResult(rootPath, result);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`[knit] integration scan background error: ${msg}
-`);
-    }
-  });
-  const learningsPath = learningsFilePath(rootPath, projectName);
-  if (!existsSync(learningsPath)) {
-    writeFileSync(learningsPath, generateLearningsContent(config), "utf-8");
-  }
-  const kbPath = knowledgebasePath(rootPath);
-  const kb = loadKnowledgeBase(kbPath, projectName);
-  const entries = readLearnings(learningsPath);
-  importFromMarkdown(kb, entries);
-  saveKnowledgeBase(kbPath, kb);
-  writeFileSync(knowledgePath(rootPath), JSON.stringify(knowledge, null, 2), "utf-8");
-}
-function migrateLegacyData(rootPath) {
-  mkdirSync(projectDataDir(rootPath), { recursive: true });
-  mkdirSync(learningsDir(rootPath), { recursive: true });
-  copyIfExists(legacyKnowledgePath(rootPath), knowledgePath(rootPath));
-  copyIfExists(legacyKnowledgebasePath(rootPath), knowledgebasePath(rootPath));
-  copyIfExists(legacyTeamsPath(rootPath), teamsPath(rootPath));
-  const legacyLearn = legacyLearningsDir(rootPath);
-  if (existsSync(legacyLearn)) {
-    for (const file of readdirSync(legacyLearn)) {
-      const src = join(legacyLearn, file);
-      const dst = join(learningsDir(rootPath), file);
-      try {
-        if (statSync(src).isFile() && !existsSync(dst)) {
-          copyFileSync(src, dst);
-        }
-      } catch {
-      }
-    }
-  }
-  const breadcrumb = migrationBreadcrumbPath(rootPath);
-  const newPath = projectDataDir(rootPath);
-  if (!existsSync(breadcrumb) && existsSync(legacyClaudeDir(rootPath))) {
-    const note = `Knit data migrated to ~/.knit/ on ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.
-
-Centralized location for this project:
-  ${newPath}
-
-The legacy files in this .claude/ directory are no longer read by engram and
-can be deleted at your discretion. Future learnings, knowledge indexes, and
-session memory live in the new path.
-`;
-    try {
-      writeFileSync(breadcrumb, note, "utf-8");
-    } catch {
-    }
-  }
-}
-function writeProjectClaudeMd(rootPath, config, knowledge) {
-  const claudeMdPath = join(rootPath, "CLAUDE.md");
-  const block = generateClaudeMd(config, knowledge);
-  if (!existsSync(claudeMdPath)) {
-    writeFileSync(claudeMdPath, block, "utf-8");
-    return;
-  }
-  const existing = readFileSync(claudeMdPath, "utf-8");
-  if (existing.includes(KNIT_MARKER_START)) {
-    const { content } = spliceKnitBlock(existing, block);
-    writeFileSync(claudeMdPath, content, "utf-8");
-    return;
-  }
-  const sidecarDir = join(rootPath, ".claude");
-  const sidecarPath = join(sidecarDir, "KNIT.md");
-  mkdirSync(sidecarDir, { recursive: true });
-  const sidecar = `<!-- This file is Knit's per-project workflow. -->
-<!-- Your CLAUDE.md exists without Knit markers, so Knit wrote here instead of clobbering it. -->
-<!-- To include this content in CLAUDE.md, add: @.claude/KNIT.md -->
-
-${block}`;
-  writeFileSync(sidecarPath, sidecar, "utf-8");
-}
-function copyIfExists(src, dst) {
-  if (existsSync(src) && !existsSync(dst)) {
-    mkdirSync(dirname(dst), { recursive: true });
-    copyFileSync(src, dst);
-  }
-}
-function writeKnitHooks(rootPath, config) {
-  const claudeDir = join(rootPath, ".claude");
-  const settingsPath = join(claudeDir, "settings.local.json");
-  const fresh = generateSettings(config, rootPath);
-  if (!existsSync(settingsPath)) {
-    mkdirSync(claudeDir, { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify(fresh, null, 2), "utf-8");
-    return;
-  }
-  let existing;
-  try {
-    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return;
-    }
-    existing = parsed;
-  } catch {
-    return;
-  }
-  if ("_knitHooks" in existing || "_engramHooks" in existing) {
-    mkdirSync(claudeDir, { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify(fresh, null, 2), "utf-8");
-    return;
-  }
-  const userHooksRaw = existing.hooks;
-  let userHooks;
-  if (userHooksRaw === void 0) {
-    userHooks = {};
-  } else if (userHooksRaw && typeof userHooksRaw === "object" && !Array.isArray(userHooksRaw)) {
-    for (const v of Object.values(userHooksRaw)) {
-      if (!Array.isArray(v)) return;
-    }
-    userHooks = { ...userHooksRaw };
-  } else {
-    return;
-  }
-  for (const event of Object.keys(fresh.hooks)) {
-    const userEntries = Array.isArray(userHooks[event]) ? userHooks[event] : [];
-    const preserved = userEntries.filter((entry) => {
-      if (!entry || typeof entry !== "object") return true;
-      const e = entry;
-      return e._knitOwned !== true && e._engramOwned !== true;
-    });
-    userHooks[event] = [...preserved, ...fresh.hooks[event]];
-  }
-  const merged = {
-    ...existing,
-    hooks: userHooks,
-    _knitHooks: { ...fresh._knitHooks, merged: true }
-  };
-  delete merged._engramHooks;
-  mkdirSync(claudeDir, { recursive: true });
-  writeFileSync(settingsPath, JSON.stringify(merged, null, 2), "utf-8");
-}
-function detectProjectName(rootPath) {
-  let name = basename(rootPath);
-  try {
-    const pkg = JSON.parse(readFileSync(join(rootPath, "package.json"), "utf-8"));
-    if (pkg.name) name = pkg.name;
-  } catch {
-  }
-  return name;
-}
-function refreshBrain(rootPath) {
-  cache = null;
-  return getBrain(rootPath);
-}
-function detectProjectRoot() {
-  try {
-    return execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf-8" }).trim();
-  } catch {
-    return process.cwd();
-  }
-}
-
 export {
-  getBrain,
-  refreshBrain,
-  detectProjectRoot
+  HOOKS_VERSION,
+  generateSettings
 };

package/dist/{chunk-5NCSZYRJ.js → chunk-LV73YTVN.js}

@@ -16,6 +16,11 @@ When to reach for other Knit tools:
 - knit_get_workflow({phase}) \u2014 fetch protocol depth for one phase on demand. Do not try to remember the workflow; ask for it.
 - knit_list_features \u2014 if you want to do X but the tool isn't visible, this surfaces what's hidden and how to enable it.
 - knit_save_handoff \u2014 call when context degrades or session ends so the next session resumes cleanly.
+- knit_verify_claim \u2014 fact-check one claim against the graph BEFORE LEARN on standard/complex scope (Stop-hook gate enforces this).
+- knit_index_requirements / knit_generate_test_cases \u2014 for long-form spec / RFC / Jira-export ingestion. Indexes once, retrieves only relevant chunks per feature query.
+- knit_get_fingerprint \u2014 detected stack (lang/framework/test/lint/build/CI) for choosing the right tooling per project.
+- knit_infer_domains + knit_compose_template \u2014 propose CLAUDE.md auto-config sections from git co-change + import-graph + colocation signals.
+- knit_get_calibration / knit_record_false_positive (with a direction tag like #complex-was-trivial) \u2014 feed the self-healing classifier so it tunes per-project over time.
 
 The protocol enforces a 4-tier classifier:
 - Inquiry: read-only "what / where / audit / explain" \u2014 just answer.

package/dist/{chunk-B2KZ5UR7.js → chunk-ORKWLA33.js}

@@ -2,7 +2,7 @@ import {
   canonicalRepoRoot,
   globalLearningsPath,
   projectId
-} from "./chunk-XFS2XGZI.js";
+} from "./chunk-27TA2ZQZ.js";
 
 // src/engine/global-learnings.ts
 import { existsSync, mkdirSync, appendFileSync, readFileSync, statSync } from "fs";