knit-mcp 0.9.0 → 0.11.2

package/dist/{chunk-BU3VHX3W.js → chunk-RZOVZYTF.js}

@@ -5,13 +5,13 @@ import {
   isBundledCore,
   knownAgents,
   rawAgentUrl
-} from "./chunk-7PPC6IG6.js";
+} from "./chunk-ST4X7LZT.js";
 import {
   agentsCacheFile,
   projectAgentFile,
   projectAgentsDir,
   sessionsJsonlPath
-} from "./chunk-XFS2XGZI.js";
+} from "./chunk-27TA2ZQZ.js";
 
 // src/engine/install-agents.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -339,8 +339,16 @@ import { existsSync as existsSync3, mkdirSync as mkdirSync3, appendFileSync, rea
 import { dirname as dirname2 } from "path";
 function appendSession(rootPath, entry) {
   const path = sessionsJsonlPath(rootPath);
-  mkdirSync3(dirname2(path), { recursive: true });
-  appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
+  try {
+    mkdirSync3(dirname2(path), { recursive: true });
+    appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
+  } catch (err) {
+    process.stderr.write(
+      `[knit] session append failed at ${path}: ${err.message}
+`
+    );
+    throw err;
+  }
 }
 function searchSessions(rootPath, query, limit = 10) {
   const lines = readAllLines(rootPath);

package/dist/{chunk-7PPC6IG6.js → chunk-ST4X7LZT.js}

@@ -1,5 +1,5 @@
 // src/engine/scanner.ts
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, existsSync, readdirSync } from "fs";
 import { join } from "path";
 import { execSync } from "child_process";
 
@@ -89,6 +89,63 @@ function scanProject(rootPath) {
     git: detectGit(rootPath)
   };
 }
+function scanProjectFingerprint(rootPath) {
+  const stack = detectStack(rootPath);
+  const pm = detectPackageManager(rootPath);
+  const languages = [];
+  if (stack.language && stack.language !== "unknown") languages.push(stack.language);
+  if (stack.language !== "python" && existsSync(join(rootPath, "pyproject.toml"))) languages.push("python");
+  if (stack.language !== "go" && existsSync(join(rootPath, "go.mod"))) languages.push("go");
+  if (stack.language !== "rust" && existsSync(join(rootPath, "Cargo.toml"))) languages.push("rust");
+  return {
+    languages,
+    framework: stack.framework,
+    testRunner: stack.testFramework,
+    linter: detectLinter(rootPath, stack.language),
+    buildCommand: stack.buildCommand,
+    lintCommand: stack.lintCommand,
+    typecheckCommand: stack.typecheckCommand,
+    packageManager: pm === "unknown" ? null : pm,
+    ciFiles: detectCiFiles(rootPath),
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function detectLinter(rootPath, language) {
+  if (existsSync(join(rootPath, ".eslintrc.json")) || existsSync(join(rootPath, ".eslintrc.js")) || existsSync(join(rootPath, "eslint.config.js")) || existsSync(join(rootPath, "eslint.config.mjs")) || existsSync(join(rootPath, "eslint.config.ts"))) return "eslint";
+  if (existsSync(join(rootPath, ".ruff.toml")) || existsSync(join(rootPath, "ruff.toml"))) return "ruff";
+  if (existsSync(join(rootPath, ".golangci.yml")) || existsSync(join(rootPath, ".golangci.yaml"))) return "golangci-lint";
+  if (existsSync(join(rootPath, "clippy.toml"))) return "clippy";
+  if (language === "python" && existsSync(join(rootPath, "pyproject.toml"))) {
+    try {
+      const py = readFileSync(join(rootPath, "pyproject.toml"), "utf-8");
+      if (py.includes("ruff")) return "ruff";
+      if (py.includes("flake8")) return "flake8";
+      if (py.includes("pylint")) return "pylint";
+    } catch {
+    }
+  }
+  if (language === "go") return "golangci-lint";
+  if (language === "rust") return "clippy";
+  return null;
+}
+function detectCiFiles(rootPath) {
+  const out = [];
+  const ghDir = join(rootPath, ".github", "workflows");
+  if (existsSync(ghDir)) {
+    try {
+      for (const f of readdirSync(ghDir)) {
+        if (f.endsWith(".yml") || f.endsWith(".yaml")) {
+          out.push(join(".github/workflows", f));
+        }
+      }
+    } catch {
+    }
+  }
+  for (const f of [".gitlab-ci.yml", ".circleci/config.yml", ".travis.yml", "Jenkinsfile", "azure-pipelines.yml"]) {
+    if (existsSync(join(rootPath, f))) out.push(f);
+  }
+  return out;
+}
 function detectPackageManager(root) {
   if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
   if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
@@ -278,5 +335,6 @@ export {
   categoryOf,
   rawAgentUrl,
   isBundledCore,
-  scanProject
+  scanProject,
+  scanProjectFingerprint
 };

package/dist/chunk-TWHNYJAJ.js

@@ -0,0 +1,328 @@
+import {
+  HOOKS_VERSION,
+  generateSettings
+} from "./chunk-HROSQ5MS.js";
+import {
+  installAgentsForProject,
+  prewarmLatestVersion,
+  pruneSessionsByAge
+} from "./chunk-RZOVZYTF.js";
+import {
+  buildKnowledge,
+  buildReverseDependencies
+} from "./chunk-MOOVNMIN.js";
+import {
+  scanProject
+} from "./chunk-ST4X7LZT.js";
+import {
+  readLearnings
+} from "./chunk-M3YZOJNW.js";
+import {
+  persistScanResult,
+  scanIntegrations
+} from "./chunk-VB2TIR6L.js";
+import {
+  KNIT_MARKER_START,
+  generateClaudeMd,
+  spliceKnitBlock
+} from "./chunk-7UFS67HP.js";
+import {
+  importFromMarkdown,
+  loadKnowledgeBaseSafe,
+  saveKnowledgeBase
+} from "./chunk-WKQHCLLO.js";
+import {
+  knowledgePath,
+  knowledgebasePath,
+  learningsDir,
+  learningsFilePath,
+  legacyClaudeDir,
+  legacyKnowledgePath,
+  legacyKnowledgebasePath,
+  legacyLearningsDir,
+  legacyTeamsPath,
+  migrationBreadcrumbPath,
+  projectDataDir,
+  teamsPath
+} from "./chunk-27TA2ZQZ.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
+`;
+}
+
+// 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 kbLoad = loadKnowledgeBaseSafe(knowledgebasePath(rootPath), projectName);
+  const knowledgeBase = kbLoad.kb;
+  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");
+  if (!kbLoad.loadFailed) {
+    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 = loadKnowledgeBaseSafe(kbPath, projectName).kb;
+  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;
+  }
+  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
+};

package/dist/{chunk-FLNV2IQC.js → chunk-VB2TIR6L.js}

@@ -3,11 +3,11 @@ import {
   KNIT_MARKER_START,
   LEGACY_ENGRAM_MARKER_END,
   LEGACY_ENGRAM_MARKER_START
-} from "./chunk-KLNUEE3O.js";
+} from "./chunk-7UFS67HP.js";
 import {
   integrationsConfigPath,
   projectDataDir
-} from "./chunk-XFS2XGZI.js";
+} from "./chunk-27TA2ZQZ.js";
 
 // src/engine/integration-scanner.ts
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, renameSync, unlinkSync } from "fs";

package/dist/{chunk-BAUQEFYY.js → chunk-WKQHCLLO.js}

@@ -1,6 +1,6 @@
 // src/engine/knowledgebase.ts
 import { randomUUID } from "crypto";
-import { readFileSync, writeFileSync, statSync, existsSync, mkdirSync } from "fs";
+import { readFileSync, writeFileSync, statSync, existsSync, mkdirSync, renameSync, unlinkSync } from "fs";
 import { dirname } from "path";
 function createKnowledgeBase(projectName) {
   return {
@@ -17,28 +17,53 @@ function createKnowledgeBase(projectName) {
   };
 }
 function loadKnowledgeBase(filePath, projectName) {
+  return loadKnowledgeBaseSafe(filePath, projectName).kb;
+}
+function loadKnowledgeBaseSafe(filePath, projectName) {
   if (!existsSync(filePath)) {
-    return createKnowledgeBase(projectName);
+    return { kb: createKnowledgeBase(projectName), loadFailed: false };
   }
   try {
     const stat = statSync(filePath);
     if (stat.size > 10 * 1024 * 1024) {
-      return createKnowledgeBase(projectName);
+      process.stderr.write(
+        `[knit] knowledgebase.json at ${filePath} exceeds 10MB \u2014 refusing to load. Original file preserved.
+`
+      );
+      return { kb: createKnowledgeBase(projectName), loadFailed: true };
     }
     const raw = readFileSync(filePath, "utf-8");
     const kb = JSON.parse(raw);
-    if (kb.version !== 1) return createKnowledgeBase(projectName);
-    if (!Array.isArray(kb.entries)) return createKnowledgeBase(projectName);
-    if (!kb.metrics || typeof kb.metrics.totalSessions !== "number") return createKnowledgeBase(projectName);
-    return kb;
-  } catch {
-    return createKnowledgeBase(projectName);
+    if (kb.version !== 1 || !Array.isArray(kb.entries) || !kb.metrics || typeof kb.metrics.totalSessions !== "number") {
+      process.stderr.write(
+        `[knit] knowledgebase.json at ${filePath} failed structural validation \u2014 refusing to overwrite. Original file preserved.
+`
+      );
+      return { kb: createKnowledgeBase(projectName), loadFailed: true };
+    }
+    return { kb, loadFailed: false };
+  } catch (err) {
+    process.stderr.write(
+      `[knit] knowledgebase.json at ${filePath} could not be parsed (${err.message}) \u2014 refusing to overwrite. Original file preserved.
+`
+    );
+    return { kb: createKnowledgeBase(projectName), loadFailed: true };
   }
 }
 function saveKnowledgeBase(filePath, kb) {
   const dir = dirname(filePath);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(filePath, JSON.stringify(kb, null, 2), "utf-8");
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(tmpPath, JSON.stringify(kb, null, 2), "utf-8");
+    renameSync(tmpPath, filePath);
+  } catch (err) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
 }
 function addEntry(kb, entry) {
   const kbEntry = {
@@ -102,6 +127,13 @@ function getStaleEntries(kb, olderThanDays = 30) {
 function recordCacheHit(kb) {
   kb.metrics.cacheHits++;
 }
+function bumpMetric(kb, key, delta = 1) {
+  kb.metrics[key] = (kb.metrics[key] ?? 0) + delta;
+}
+function bumpClassificationTier(kb, tier, delta = 1) {
+  if (!kb.metrics.classificationsByTier) kb.metrics.classificationsByTier = {};
+  kb.metrics.classificationsByTier[tier] = (kb.metrics.classificationsByTier[tier] ?? 0) + delta;
+}
 function getKBSummary(kb) {
   const totalEntries = kb.entries.length;
   const accessedEntries = kb.entries.filter((e) => e.accessCount > 0).length;
@@ -126,6 +158,7 @@ function getKBSummary(kb) {
 
 export {
   loadKnowledgeBase,
+  loadKnowledgeBaseSafe,
   saveKnowledgeBase,
   addEntry,
   importFromMarkdown,
@@ -134,5 +167,7 @@ export {
   getTopEntries,
   getStaleEntries,
   recordCacheHit,
+  bumpMetric,
+  bumpClassificationTier,
   getKBSummary
 };

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
 // src/cli.ts
 import { Command } from "commander";
 var args = process.argv.slice(2);
-var hasSubcommand = args.length > 0 && ["setup", "status", "refresh", "install-agents", "export", "--help", "-h", "--version", "-V"].includes(args[0]);
+var hasSubcommand = args.length > 0 && ["setup", "status", "refresh", "install-agents", "export", "doctor", "--help", "-h", "--version", "-V"].includes(args[0]);
 var isTTY = process.stdin.isTTY;
 if (hasSubcommand) {
   runCLI();
@@ -20,10 +20,11 @@ async function runCLI() {
   const gradient = (await import("gradient-string")).default;
   const chalk = (await import("chalk")).default;
   const { setupCommand } = await import("./setup-5TUUWLIJ.js");
-  const { statusCommand } = await import("./status-RQWRIM2Y.js");
-  const { refreshCommand } = await import("./refresh-BXN32CNA.js");
-  const { installAgentsCommand } = await import("./install-agents-D2KJQUH3.js");
-  const { exportCommand } = await import("./export-I5Y26WUL.js");
+  const { statusCommand } = await import("./status-VJDB75X2.js");
+  const { refreshCommand } = await import("./refresh-SMJ2NGIW.js");
+  const { installAgentsCommand } = await import("./install-agents-OBDCWCPB.js");
+  const { exportCommand } = await import("./export-CGSEUYZA.js");
+  const { doctorCommand } = await import("./doctor-4DN2P2JR.js");
   const ENGRAM_GRADIENT = gradient(["#7c3aed", "#2563eb", "#06b6d4"]);
   const banner = `
   \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
@@ -75,6 +76,14 @@ async function runCLI() {
       process.exit(1);
     }
   });
+  program.command("doctor").description("Install health check: version, MCP registration, HOOKS_VERSION drift, knowledgebase, dangling symlinks").argument("[directory]", "Project directory", ".").action(async (directory) => {
+    try {
+      await doctorCommand(directory);
+    } catch (error) {
+      console.error(chalk.red("  Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
   program.command("export").description("Export knit learnings into a target format (e.g. an Obsidian vault)").argument("<format>", "Export format (currently only: obsidian)").argument("<vault-path>", "Output directory (Obsidian vault path)").option("--filter <tag>", "Only export entries tagged with this tag (e.g. #auth)").action(async (format, vaultPath, options) => {
     try {
       await exportCommand(format, vaultPath, options);
@@ -89,11 +98,11 @@ async function runMCP() {
   const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
   const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
   const { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
-  const { getBrain, detectProjectRoot, refreshBrain } = await import("./cache-JSN6ETUF.js");
-  const { getActiveToolDefinitionsForBrain, handleToolCall } = await import("./tools-EISDGPS5.js");
-  const { buildInstructions } = await import("./instructions-4FI32YZU.js");
+  const { getBrain, detectProjectRoot, refreshBrain } = await import("./cache-3LPETDUT.js");
+  const { getActiveToolDefinitionsForBrain, handleToolCall } = await import("./tools-MIROTK2A.js");
+  const { buildInstructions } = await import("./instructions-JARSXQPO.js");
   const { registerToolsListChangedNotifier } = await import("./notifier-4L27HKHI.js");
-  const { loadScanResult } = await import("./integration-scanner-PS47AHGM.js");
+  const { loadScanResult } = await import("./integration-scanner-LBD2PIZ3.js");
   const ROOT_PATH = detectProjectRoot();
   const PER_PROJECT_INSTRUCTIONS = buildInstructions(loadScanResult(ROOT_PATH));
   const server = new Server(