knit-mcp 0.8.0 → 0.9.0

package/dist/{cache-RRKF2IZ5.js → cache-JSN6ETUF.js}

@@ -2,13 +2,15 @@ import {
   detectProjectRoot,
   getBrain,
   refreshBrain
-} from "./chunk-WN4AQFMO.js";
-import "./chunk-N7R4P42P.js";
+} from "./chunk-4K4FHOKE.js";
+import "./chunk-BU3VHX3W.js";
 import "./chunk-MOOVNMIN.js";
-import "./chunk-JJ367RK5.js";
+import "./chunk-7PPC6IG6.js";
 import "./chunk-M3YZOJNW.js";
+import "./chunk-FLNV2IQC.js";
+import "./chunk-KLNUEE3O.js";
 import "./chunk-BAUQEFYY.js";
-import "./chunk-SBJMHDBM.js";
+import "./chunk-XFS2XGZI.js";
 export {
   detectProjectRoot,
   getBrain,

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

@@ -1,23 +1,27 @@
 import {
   installAgentsForProject,
-  persistScanResult,
   prewarmLatestVersion,
-  pruneSessionsByAge,
-  scanIntegrations
-} from "./chunk-N7R4P42P.js";
+  pruneSessionsByAge
+} from "./chunk-BU3VHX3W.js";
 import {
   buildKnowledge,
   buildReverseDependencies
 } from "./chunk-MOOVNMIN.js";
 import {
-  KNIT_MARKER_START,
-  generateClaudeMd,
-  scanProject,
-  spliceKnitBlock
-} from "./chunk-JJ367RK5.js";
+  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,
@@ -37,11 +41,12 @@ import {
   migrationBreadcrumbPath,
   projectDataDir,
   protocolConfigPath,
+  searchMarkerPath,
   sessionMarkerPath,
   sessionsJsonlPath,
   sessionsLogPath,
   teamsPath
-} from "./chunk-SBJMHDBM.js";
+} from "./chunk-XFS2XGZI.js";
 
 // src/mcp/cache.ts
 import { execSync } from "child_process";
@@ -68,7 +73,7 @@ function generateLearningsContent(config) {
 }
 
 // src/generators/settings.ts
-var HOOKS_VERSION = 6;
+var HOOKS_VERSION = 7;
 function generateSettings(config, rootPath) {
   return {
     mcpServers: {
@@ -114,6 +119,9 @@ function generateHooks(config, rootPath) {
   const PROTOCOL_CONFIG = protocolConfigPath(rootPath);
   const CLASSIFIED_MARKER = classificationMarkerPath(rootPath);
   const SESSION_MARKER = sessionMarkerPath(rootPath);
+  const SEARCH_MARKER = searchMarkerPath(rootPath);
+  const CLAUDE_MD = `${rootPath}/CLAUDE.md`;
+  void knowledgePath;
   const hooks = {
     SessionStart: [
       // Protocol Guard layer 1: drop a marker that knit_load_session
@@ -152,6 +160,10 @@ function generateHooks(config, rootPath) {
                 const fs = require("fs");
                 const p = ${jsLit(CLASSIFIED_MARKER)};
                 if (fs.existsSync(p)) fs.rmSync(p, { force: true });
+                // v0.9 #5: per-turn search marker is also cleared at the turn boundary
+                // 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 });
               } catch (e) {}
             `),
             timeout: 5
@@ -195,6 +207,7 @@ function generateHooks(config, rootPath) {
                 const fs = require("fs");
                 const cfgPath = ${jsLit(PROTOCOL_CONFIG)};
                 const markerPath = ${jsLit(CLASSIFIED_MARKER)};
+                const searchMarkerPath = ${jsLit(SEARCH_MARKER)};
                 let level = "warn";
                 if (fs.existsSync(cfgPath)) {
                   try {
@@ -205,13 +218,33 @@ function generateHooks(config, rootPath) {
                   }
                 }
                 if (level === "off") return;
+                // Classification gate (v0.5).
                 const hasMarker = fs.existsSync(markerPath);
-                if (hasMarker) return;
-                if (level === "block") {
-                  console.error("[knit] BLOCKED: call knit_classify_task before Edit/Write. The Protocol Guard prevents implementation without classification.");
-                  process.exit(2);
+                if (!hasMarker) {
+                  if (level === "block") {
+                    console.error("[knit] BLOCKED: call knit_classify_task before Edit/Write. The Protocol Guard prevents implementation without classification.");
+                    process.exit(2);
+                  }
+                  console.error("[knit] reminder: call knit_classify_task before Edit/Write. Set strictness=block via knit_set_protocol_strictness to make this a hard gate.");
+                  return;
+                }
+                // v0.9 #5: search gate. For standard/complex tasks, knit_search_learnings
+                // (or knit_search_global_learnings) must run before the Edit lands \u2014
+                // otherwise the agent is re-investigating without checking memory.
+                try {
+                  const marker = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
+                  if (marker && (marker.tier === "standard" || marker.tier === "complex")) {
+                    if (!fs.existsSync(searchMarkerPath)) {
+                      if (level === "block") {
+                        console.error("[knit] BLOCKED: " + marker.tier + " task \u2014 call knit_search_learnings or knit_search_global_learnings before Edit/Write so memory is checked before re-investigation.");
+                        process.exit(2);
+                      }
+                      console.error("[knit] reminder: " + marker.tier + " task \u2014 call knit_search_learnings before Edit/Write. Skipping memory check means re-doing work the project already learned.");
+                    }
+                  }
+                } catch (markerErr) {
+                  // Marker exists but JSON unreadable \u2014 be lenient.
                 }
-                console.error("[knit] reminder: call knit_classify_task before Edit/Write. Set strictness=block via knit_set_protocol_strictness to make this a hard gate.");
               } catch (hookErr) {
                 console.error("[knit] protocol-guard hook crashed, allowing tool through:", hookErr && hookErr.message ? hookErr.message : hookErr);
               }
@@ -219,11 +252,106 @@ function generateHooks(config, rootPath) {
             timeout: 5
           }
         ]
+      },
+      // v0.9 #9 — Pre-write content inspection. Reads the proposed Write/Edit
+      // content from tool_input, parses local import statements, and reports
+      // any relative paths that don't resolve on disk. Warn-level by default
+      // (the existing classification gate handles block mode); soft signal,
+      // never blocks on its own.
+      {
+        _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 filePath = (i.tool_input && i.tool_input.file_path) || "";
+                  if (!/\\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(filePath)) return;
+                  // Pull proposed content from any of the Edit/Write shapes.
+                  let content = (i.tool_input && (i.tool_input.content || i.tool_input.new_string)) || "";
+                  if (i.tool_input && Array.isArray(i.tool_input.edits)) {
+                    content = i.tool_input.edits.map((e) => e && e.new_string ? e.new_string : "").join("\\n");
+                  }
+                  if (!content) return;
+                  const dir = path.dirname(filePath);
+                  const re = /^import\\s+(?:[^'"]+?\\s+from\\s+)?['"]([^'"]+)['"]/gm;
+                  const unresolved = [];
+                  let m;
+                  while ((m = re.exec(content)) !== null) {
+                    const target = m[1];
+                    if (!target.startsWith(".") && !target.startsWith("/")) continue;
+                    const candidates = [target, target + ".ts", target + ".tsx", target + ".js", target + ".jsx", target + "/index.ts", target + "/index.tsx", target + "/index.js"];
+                    let resolved = false;
+                    for (const c of candidates) {
+                      const abs = path.resolve(dir, c);
+                      if (fs.existsSync(abs)) { resolved = true; break; }
+                    }
+                    if (!resolved) unresolved.push(target);
+                  }
+                  if (unresolved.length > 0) {
+                    console.error("[knit] heads-up: proposed edit references " + unresolved.length + " unresolved relative import(s): " + unresolved.join(", ") + ". Likely hallucinated paths \u2014 verify with knit_query_imports or knit_verify_claim before relying on them.");
+                  }
+                } catch (e) {}
+              });
+            `),
+            timeout: 5
+          }
+        ]
       }
     ],
     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 f = (i.tool_input && i.tool_input.file_path) || (i.tool_response && i.tool_response.filePath) || "";
+              if (!/\\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(f)) return;
+              if (!fs.existsSync(f)) return;
+              const content = fs.readFileSync(f, "utf-8");
+              const dir = path.dirname(f);
+              const re = /^import\\s+(?:[^'"]+?\\s+from\\s+)?['"]([^'"]+)['"]/gm;
+              const unresolved = [];
+              let m;
+              while ((m = re.exec(content)) !== null) {
+                const target = m[1];
+                if (!target.startsWith(".") && !target.startsWith("/")) continue;
+                const candidates = [target, target + ".ts", target + ".tsx", target + ".js", target + ".jsx", target + "/index.ts", target + "/index.tsx", target + "/index.js"];
+                let resolved = false;
+                for (const c of candidates) {
+                  if (fs.existsSync(path.resolve(dir, c))) { resolved = true; break; }
+                }
+                if (!resolved) unresolved.push(target);
+              }
+              if (unresolved.length > 0) {
+                console.error("[knit] post-write check: " + f + " has " + unresolved.length + " unresolved relative import(s): " + unresolved.join(", ") + ". Run typecheck before relying on this file.");
+              }
+            } catch (e) {}
+          });
+        `),
+        timeout: 5,
+        statusMessage: "Knit: validating imports..."
+      }
+    ]
+  });
   if (config.stack.language === "typescript" && config.stack.typecheckCommand) {
     hooks.PostToolUse.push({
       _knitOwned: true,
@@ -354,6 +482,27 @@ function generateHooks(config, rootPath) {
       ]
     });
   }
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            const p = ${jsLit(CLAUDE_MD)};
+            if (!fs.existsSync(p)) return;
+            const size = fs.statSync(p).size;
+            if (size > 12500) {
+              console.error("[knit] budget watch: CLAUDE.md is " + Math.round(size/1024*10)/10 + "KB (target 6.5KB; over-budget threshold 12.5KB). Call knit_brain_status to confirm and consider regenerating via knit refresh.");
+            }
+          } catch (e) {}
+        `),
+        timeout: 5,
+        statusMessage: "Knit: budget check..."
+      }
+    ]
+  });
   hooks.Stop.push({
     _knitOwned: true,
     hooks: [

package/dist/chunk-5NCSZYRJ.js

@@ -0,0 +1,66 @@
+// src/mcp/instructions.ts
+var KNIT_INSTRUCTIONS_BASE = `Knit is a memory + workflow layer for this project. It provides per-project memory across sessions, a knowledge graph (imports/exports/tests), and a tier-routed workflow protocol.
+
+ALWAYS at session start:
+1. Call knit_load_session \u2014 returns prior handoff, top learnings, false positives. If has_unfinished_work is true, resume that handoff instead of starting fresh.
+2. For any non-trivial task, call knit_classify_task BEFORE editing or writing \u2014 returns tier (inquiry / trivial / standard / complex) and phases.
+3. If tier=complex with auto_plan_mode=true, call EnterPlanMode immediately. Do not start editing.
+4. If tier=inquiry, just answer \u2014 no plan mode, no phases. Re-classify only if scope grows into writes.
+5. Before reporting a task done, call knit_record_learning if anything non-obvious surfaced (not a substring restatement of prior learnings).
+
+When to reach for other Knit tools:
+- knit_query_imports / knit_query_exports / knit_query_dependents / knit_query_tests \u2014 use instead of grep when the knowledge index is fresh.
+- knit_search_learnings \u2014 call before re-investigating a domain. The point of memory is to skip what you've already learned.
+- knit_search_sessions \u2014 answers "have I done this before?"
+- knit_search_global_learnings \u2014 same, but across all your projects (Knit's cross-project pool).
+- 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.
+
+The protocol enforces a 4-tier classifier:
+- Inquiry: read-only "what / where / audit / explain" \u2014 just answer.
+- Trivial: single-file obvious change \u2014 EXECUTE \u2192 VERIFY \u2192 LEARN.
+- Standard: bug fix or single-domain feature \u2014 RESEARCH \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW \u2192 LEARN.
+- Complex: cross-domain, types/auth-touching, high-fanout, or any task spanning more than one commit \u2014 full 6 phases with auto plan mode on RESEARCH.
+
+Knit provides inputs; you make the calls. When in doubt, under-classify \u2014 easier to escalate mid-task than to downgrade.
+
+Citation rule: when you state a fact about this codebase ("file X imports Y", "function Z is defined in W", "tests for A live in B"), cite the Knit tool result that verified it \u2014 e.g. "(per knit_query_imports)". If you can't cite a tool result, mark the claim as 'unverified' explicitly. This makes hallucinations visible at the claim level instead of letting them ship as confident-sounding prose. The verifier exists; use it.`;
+var KNIT_INSTRUCTIONS = KNIT_INSTRUCTIONS_BASE;
+function buildInstructions(scan) {
+  if (!scan) return KNIT_INSTRUCTIONS_BASE;
+  const addenda = [];
+  if (scan.detected.ruflo.present) {
+    addenda.push(
+      "DETECTED: Ruflo (multi-agent orchestration) is installed alongside Knit on this project. For multi-agent swarms, federation, or large-scale orchestration, defer to Ruflo's tools (`memory_store`, `swarm_init`, `agent_spawn`, etc). Knit's domain in this project: per-project memory + tier-routed classification + token discipline. Do NOT duplicate Ruflo's routing logic with Knit's tier protocol when Ruflo is driving the workflow."
+    );
+  }
+  if (scan.detected.gstack.present) {
+    addenda.push(
+      "DETECTED: gstack slash commands are installed. For routing decisions (`/plan`, `/ship`, `/qa`, `/cso`, `/investigate`), prefer the gstack command. Knit operates underneath as the memory + classification layer; the gstack command can invoke Knit tools internally."
+    );
+  }
+  if (scan.detected.codetour.present) {
+    addenda.push(
+      "DETECTED: CodeTour is configured (.tours/*.tour). When asked to walk through code or explain architecture, surface relevant tours via the CodeTour extension rather than reconstructing the explanation from scratch."
+    );
+  }
+  if (scan.detected.conductor.present) {
+    addenda.push(
+      "DETECTED: Conductor is installed. For cross-workspace handoff and context-restore flows, defer to Conductor's primitives; Knit's `knit_save_handoff` / `knit_load_session` continue to handle the per-project memory layer."
+    );
+  }
+  if (scan.detected.custom_workflow_sections.length > 0) {
+    addenda.push(
+      `DETECTED: this project's CLAUDE.md has user-curated workflow sections (${scan.detected.custom_workflow_sections.join("; ")}). Treat that as the canonical workflow doc for project-specific phases; Knit's tier protocol applies underneath as the routing layer.`
+    );
+  }
+  if (addenda.length === 0) return KNIT_INSTRUCTIONS_BASE;
+  return KNIT_INSTRUCTIONS_BASE + "\n\n\u2014 Per-project integrations \u2014\n\n" + addenda.join("\n\n") + "\n\nGeneral rule: when an integration above provides a higher-level routing primitive (slash command, swarm orchestrator, methodology framework), use it. Knit handles the substrate it doesn't cover: memory, classification, and the workflow protocol for tasks the integration doesn't route.";
+}
+
+export {
+  KNIT_INSTRUCTIONS_BASE,
+  KNIT_INSTRUCTIONS,
+  buildInstructions
+};

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

@@ -271,162 +271,6 @@ function detectGit(root) {
   return { isRepo, defaultBranch, hasRemote };
 }
 
-// src/generators/claude-md.ts
-var KNIT_MARKER_START = "<!-- knit:start -->";
-var KNIT_MARKER_END = "<!-- knit:end -->";
-var LEGACY_ENGRAM_MARKER_START = "<!-- engram:start -->";
-var LEGACY_ENGRAM_MARKER_END = "<!-- engram:end -->";
-function generateClaudeMd(config, knowledge, falsePositives) {
-  const sections = [
-    generateHeader(config),
-    generateSessionStartup(),
-    knowledge ? generateProjectMap(knowledge) : null,
-    generateDomainArchitecture(config),
-    falsePositives && falsePositives.length > 0 ? generateFalsePositives(falsePositives) : null,
-    generateBuildGates(config),
-    generateTierVocabulary(),
-    generateWorkflowPointer()
-  ];
-  const body = sections.filter(Boolean).join("\n\n---\n\n");
-  return `${KNIT_MARKER_START}
-
-${body}
-
-${KNIT_MARKER_END}
-`;
-}
-function spliceKnitBlock(existing, newBlock) {
-  const markerPairs = [
-    [KNIT_MARKER_START, KNIT_MARKER_END],
-    [LEGACY_ENGRAM_MARKER_START, LEGACY_ENGRAM_MARKER_END]
-  ];
-  for (const [startMarker, endMarker] of markerPairs) {
-    const startIdx = existing.indexOf(startMarker);
-    const endIdx = existing.indexOf(endMarker);
-    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
-      const before = existing.slice(0, startIdx);
-      const after = existing.slice(endIdx + endMarker.length);
-      return { content: before + newBlock.trimEnd() + after, mode: "replaced" };
-    }
-  }
-  return { content: existing, mode: "sidecar-needed" };
-}
-function generateHeader(config) {
-  const stackParts = [
-    config.stack.language !== "unknown" ? config.stack.language : null,
-    config.stack.framework
-  ].filter(Boolean);
-  const stackDesc = stackParts.length > 0 ? `${stackParts.join(" + ")} project. ` : "";
-  return `# ${config.name}
-
-${stackDesc}Knit-powered workflow. The protocol depth is fetched on demand via \`knit_get_workflow({phase})\` \u2014 this file holds only project-specific facts.`;
-}
-function generateSessionStartup() {
-  return `## Session start
-
-First action: call \`knit_load_session\`. One MCP call returns last sessions, handoff, learnings, false positives. If \`handoff.md\` exists at the repo root, resume that work first.
-
-Protocol Guard runs in \`warn\` mode by default \u2014 adjust with \`knit_set_protocol_strictness\`.`;
-}
-function generateProjectMap(knowledge) {
-  const { summary } = knowledge;
-  let content = `## Project Map (auto-generated)
-
-`;
-  if (summary.entryPoints.length > 0) {
-    content += `**Entry points:** \`${summary.entryPoints.join("`, `")}\`
-`;
-  }
-  if (summary.highFanoutFiles.length > 0) {
-    const shown = summary.highFanoutFiles.slice(0, 5);
-    content += `**High-fanout (change carefully):** \`${shown.join("`, `")}\``;
-    if (summary.highFanoutFiles.length > 5) {
-      content += ` (+${summary.highFanoutFiles.length - 5} more \u2014 \`knit_find_fanout\`)`;
-    }
-    content += "\n";
-  }
-  if (summary.untestedFiles.length > 0) {
-    const shown = summary.untestedFiles.slice(0, 3);
-    content += `**Untested:** \`${shown.join("`, `")}\``;
-    if (summary.untestedFiles.length > 3) {
-      content += ` (+${summary.untestedFiles.length - 3} more \u2014 \`knit_query_tests({filter:"untested"})\`)`;
-    }
-    content += "\n";
-  }
-  if (summary.largestFiles.length > 0) {
-    const top3 = summary.largestFiles.slice(0, 3);
-    const list = top3.map((f) => `\`${f.path}\` (${f.lines})`).join(", ");
-    content += `**Largest:** ${list}
-`;
-  }
-  content += `
-**Stats:** ${summary.totalFiles} files, ${summary.totalLines.toLocaleString()} lines`;
-  const langs = Object.entries(summary.languageBreakdown).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([ext, count]) => `${ext}: ${count}`);
-  if (langs.length > 0) content += ` (${langs.join(", ")})`;
-  return content;
-}
-function generateDomainArchitecture(config) {
-  if (!config.domains || config.domains.length === 0) {
-    return `## Domain Architecture
-
-No domains detected. Use \`knit_setup_project\` to describe your project \u2014 Knit will configure domains and review agents.`;
-  }
-  const rows = config.domains.map((d) => {
-    const patterns = d.filePatterns.slice(0, 3).join(", ");
-    const agents = d.agents.join(", ");
-    return `### ${d.name}
-**Files:** \`${patterns}\`
-**Concern:** ${d.description}
-**Review agents:** \`${agents}\``;
-  }).join("\n\n");
-  return `## Domain Architecture
-
-${rows}`;
-}
-function generateFalsePositives(fps) {
-  const items = fps.slice(0, 10).map((fp) => `- **${fp.summary}** \u2014 ${fp.lesson}`).join("\n");
-  return `## Known False Positives
-
-Review agents should NOT re-flag these \u2014 they're confirmed non-issues from prior sessions:
-
-${items}`;
-}
-function generateBuildGates(config) {
-  const gates = [];
-  if (config.stack.typecheckCommand) gates.push(`- \`${config.stack.typecheckCommand}\``);
-  if (config.stack.lintCommand) gates.push(`- \`${config.stack.lintCommand}\``);
-  if (config.stack.testFramework) {
-    const pm = config.packageManager === "unknown" ? "npm" : config.packageManager;
-    gates.push(`- \`${pm} test\``);
-  }
-  if (config.stack.buildCommand) gates.push(`- \`${config.stack.buildCommand}\``);
-  if (gates.length === 0) {
-    return `## Build Gates
-
-No build gates auto-detected. Add typecheck/lint/test/build commands to your package.json.`;
-  }
-  return `## Build Gates
-
-All must pass before commit:
-
-${gates.join("\n")}`;
-}
-function generateTierVocabulary() {
-  return `## Tier vocabulary
-
-| Tier | When |
-|------|------|
-| **Inquiry** | Read-only ("what", "where", "audit") \u2014 just answer. |
-| **Trivial** | One-line fix \u2014 execute \u2192 verify. |
-| **Standard** | Single-domain bug fix or feature \u2014 research \u2192 execute \u2192 review. |
-| **Complex** | Cross-domain, touches types/auth, high-fanout, or multi-commit arc \u2014 full 6 phases + auto plan mode. |`;
-}
-function generateWorkflowPointer() {
-  return `## Workflow on demand
-
-Fetch any phase via \`knit_get_workflow({phase})\`. Call with no phase to list available sections.`;
-}
-
 export {
   VOLTAGENT_PINNED_SHA,
   VOLTAGENT_REF,
@@ -434,11 +278,5 @@ export {
   categoryOf,
   rawAgentUrl,
   isBundledCore,
-  scanProject,
-  KNIT_MARKER_START,
-  KNIT_MARKER_END,
-  LEGACY_ENGRAM_MARKER_START,
-  LEGACY_ENGRAM_MARKER_END,
-  generateClaudeMd,
-  spliceKnitBlock
+  scanProject
 };

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

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