@datacore-one/mcp 1.3.0 → 1.4.1

package/dist/index.js

@@ -222,6 +222,12 @@ var ConfigSchema = z.object({
   engagement: z.object({
     enabled: z.boolean().default(true),
     inline_xp: z.boolean().default(false)
+  }).default({}),
+  injection: z.object({
+    directive_cap: z.number().default(10),
+    consider_cap: z.number().default(5),
+    spread_cap: z.number().default(3),
+    spread_budget: z.number().default(480)
   }).default({})
 });
 var cachedConfig = null;
@@ -246,7 +252,7 @@ function getConfig() {
 // package.json
 var package_default = {
   name: "@datacore-one/mcp",
-  version: "1.3.0",
+  version: "1.4.1",
   description: "Datacore MCP server \u2014 The Software of You",
   type: "module",
   bin: {
@@ -259,7 +265,7 @@ var package_default = {
     test: "vitest run",
     "test:watch": "vitest",
     start: "node dist/index.js",
-    release: `npm test && npm run build && npm version \${VERSION:-patch} && npm publish --access public && npm install -g @datacore-one/mcp@$(node -p 'require("./package.json").version')`
+    release: `npm test && npm version \${VERSION:-patch} && npm run build && npm publish --access public && npm install -g @datacore-one/mcp@$(node -p 'require("./package.json").version')`
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.0.0",
@@ -334,7 +340,17 @@ var TOOLS = [
       scope: z2.string().optional().describe("Scope: global | agent:X | command:X"),
       tags: z2.array(z2.string()).optional(),
       domain: z2.string().optional().describe("Dot-notation domain: software.architecture"),
-      visibility: z2.enum(["private", "public", "template"]).optional()
+      visibility: z2.enum(["private", "public", "template"]).optional(),
+      knowledge_anchors: z2.array(z2.object({
+        path: z2.string().describe("Path to related document (e.g., zettel/Data-Pricing.md)"),
+        relevance: z2.enum(["primary", "supporting", "example"]).optional().describe("Anchor relevance level"),
+        snippet: z2.string().optional().describe("Short snippet from the document (max 200 chars)"),
+        snippet_extracted_at: z2.string().optional().describe("ISO date when snippet was extracted")
+      })).optional().describe("Links to related knowledge documents"),
+      dual_coding: z2.object({
+        example: z2.string().optional().describe("Concrete example illustrating the engram"),
+        analogy: z2.string().optional().describe("Analogy to aid understanding")
+      }).optional().describe("Dual coding: example and/or analogy for richer encoding")
     })
   },
   {
@@ -343,6 +359,7 @@ var TOOLS = [
     inputSchema: z2.object({
       prompt: z2.string().describe("The task or question to match against"),
       scope: z2.string().optional().describe("Filter by scope: global | agent:X | module:X | command:X"),
+      session_id: z2.string().optional().describe("Session ID for co-access tracking (from session.start)"),
       max_tokens: z2.number().optional().describe("Token budget (default: 8000)"),
       min_relevance: z2.number().optional().describe("Minimum score threshold (default: 0.3)")
     })
@@ -434,6 +451,7 @@ var TOOLS = [
     description: "End a session \u2014 captures journal summary and creates engrams from suggestions. Call before the conversation ends to preserve what was learned.",
     inputSchema: z2.object({
       summary: z2.string().describe("Session summary for the journal"),
+      session_id: z2.string().optional().describe("Session ID from session.start (for co-access tracking)"),
       tags: z2.array(z2.string()).optional().describe("Tags for the journal entry"),
       engram_suggestions: z2.array(z2.object({
         statement: z2.string().describe("The knowledge assertion"),
@@ -588,6 +606,25 @@ var KnowledgeTypeSchema = z3.object({
   memory_class: z3.enum(["semantic", "episodic", "procedural", "metacognitive"]),
   cognitive_level: z3.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
 });
+var KnowledgeAnchorSchema = z3.object({
+  path: z3.string(),
+  relevance: z3.enum(["primary", "supporting", "example"]).default("supporting"),
+  snippet: z3.string().max(200).optional(),
+  snippet_extracted_at: z3.string().optional()
+});
+var AssociationSchema = z3.object({
+  target_type: z3.enum(["engram", "document"]),
+  target: z3.string(),
+  strength: z3.number().min(0).max(0.95),
+  type: z3.enum(["semantic", "temporal", "causal", "co_accessed"])
+});
+var DualCodingSchema = z3.object({
+  example: z3.string().optional(),
+  analogy: z3.string().optional()
+}).refine(
+  (d) => d.example || d.analogy,
+  "At least one of example or analogy must be provided"
+);
 var RelationsSchema = z3.object({
   broader: z3.array(z3.string()).default([]),
   narrower: z3.array(z3.string()).default([]),
@@ -624,6 +661,9 @@ var EngramSchema = z3.object({
   activation: ActivationSchema,
   provenance: ProvenanceSchema.optional(),
   feedback_signals: FeedbackSignalsSchema.optional(),
+  knowledge_anchors: z3.array(KnowledgeAnchorSchema).default([]),
+  associations: z3.array(AssociationSchema).default([]),
+  dual_coding: DualCodingSchema.optional(),
   tags: z3.array(z3.string()).default([]),
   pack: z3.string().nullable().default(null),
   abstract: z3.string().nullable().default(null),
@@ -800,6 +840,14 @@ async function handleLearn(args2, engramsPath, service) {
     rationale: args2.rationale,
     derivation_count: 1,
     domain: args2.domain,
+    knowledge_anchors: args2.knowledge_anchors?.map((a) => ({
+      path: a.path,
+      relevance: a.relevance ?? "supporting",
+      snippet: a.snippet,
+      snippet_extracted_at: a.snippet_extracted_at
+    })) ?? [],
+    associations: [],
+    dual_coding: args2.dual_coding?.example || args2.dual_coding?.analogy ? args2.dual_coding : void 0,
     tags: args2.tags ?? [],
     activation: {
       retrieval_strength: autoPromote ? 0.7 : 0.5,
@@ -850,6 +898,7 @@ async function handleLearn(args2, engramsPath, service) {
 
 // src/tools/inject-tool.ts
 import * as fs5 from "fs";
+import * as path4 from "path";
 import * as yaml3 from "js-yaml";
 
 // src/decay.ts
@@ -872,38 +921,81 @@ function engramState(retrievalStrength) {
 // src/inject.ts
 var DEFAULT_MAX_TOKENS = 8e3;
 var DEFAULT_MIN_RELEVANCE = 0.3;
-var TOKENS_PER_ENGRAM = 40;
 var MAX_PER_PACK = 5;
 var MAX_PER_DOMAIN = 10;
-function selectEngrams(ctx, personalEngrams, packs) {
-  const promptLower = ctx.prompt.toLowerCase();
-  const promptWords = new Set(promptLower.split(/\W+/).filter((w) => w.length > 2));
-  const scored = [];
-  for (const engram of personalEngrams) {
-    if (engram.status !== "active") continue;
-    const score = scoreEngram(engram, promptLower, promptWords, [], ctx.scope, false);
-    if (score > 0) scored.push({ engram, score });
-  }
-  for (const pack of packs) {
-    if (pack.manifest["x-datacore"].injection_policy === "on_request") continue;
-    const matchTerms = pack.manifest["x-datacore"].match_terms;
-    for (const engram of pack.engrams) {
-      if (engram.status !== "active") continue;
-      const score = scoreEngram(engram, promptLower, promptWords, matchTerms, ctx.scope, true);
-      if (score > 0) scored.push({ engram, score });
+var DIP19_CONSIDER_MAX = 5;
+var DIP19_CONSIDER_BUDGET = 200;
+var RELEVANCE_RANK = { primary: 0, supporting: 1, example: 2 };
+function estimateTokens(engram) {
+  const { keyword_match: _km, raw_score: _rs, score: _s, associations: _a, ...wire } = engram;
+  const serialized = JSON.stringify(wire);
+  return Math.ceil(serialized.length / 4);
+}
+function tokenize(text) {
+  return new Set(text.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+}
+function anchorBoost(engram, taskWords) {
+  if (!engram.knowledge_anchors?.length) return 0;
+  const threshold = taskWords.size <= 1 ? 1 : 2;
+  let boost = 0;
+  for (const anchor of engram.knowledge_anchors) {
+    if (!anchor.snippet) continue;
+    const snippetWords = tokenize(anchor.snippet);
+    let overlap = 0;
+    for (const word of taskWords) {
+      if (snippetWords.has(word)) overlap++;
     }
+    if (overlap >= threshold) boost += 0.5;
   }
-  const maxTokens = ctx.maxTokens ?? DEFAULT_MAX_TOKENS;
-  const minRelevance = ctx.minRelevance ?? DEFAULT_MIN_RELEVANCE;
-  const passing = scored.filter((s) => s.score >= minRelevance);
-  passing.sort((a, b) => b.score - a.score);
-  const selected = fillTokenBudget(passing, maxTokens);
-  const splitPoint = Math.ceil(selected.length * 2 / 3);
-  return {
-    directives: selected.slice(0, splitPoint),
-    consider: selected.slice(splitPoint),
-    tokens_used: selected.length * TOKENS_PER_ENGRAM
+  return Math.min(boost, 2);
+}
+function flattenRelations(engram) {
+  if (!engram.relations) return [];
+  const associations = [];
+  for (const id of engram.relations.broader) {
+    associations.push({ target_type: "engram", target: id, type: "semantic", strength: 0.5 });
+  }
+  for (const id of engram.relations.narrower) {
+    associations.push({ target_type: "engram", target: id, type: "semantic", strength: 0.5 });
+  }
+  for (const id of engram.relations.related) {
+    associations.push({ target_type: "engram", target: id, type: "semantic", strength: 0.5 });
+  }
+  return associations;
+}
+function stripAssociations(engram) {
+  const { associations: _, ...rest } = engram;
+  return rest;
+}
+function stripScoring(engram) {
+  const { keyword_match: _, raw_score: _r, score: _s, ...rest } = engram;
+  return rest;
+}
+function aggregateAnchors(directives, consider) {
+  const seen = /* @__PURE__ */ new Map();
+  const processPool = (pool) => {
+    for (const engram of pool) {
+      if (!engram.knowledge_anchors?.length) continue;
+      for (const anchor of engram.knowledge_anchors) {
+        const existing = seen.get(anchor.path);
+        const rank = RELEVANCE_RANK[anchor.relevance] ?? 2;
+        const existingRank = existing ? RELEVANCE_RANK[existing.anchor.relevance] ?? 2 : Infinity;
+        if (!existing || rank < existingRank || rank === existingRank && engram.score > existing.engramScore) {
+          seen.set(anchor.path, { anchor, engramScore: engram.score });
+        }
+      }
+    }
   };
+  processPool(directives);
+  processPool(consider);
+  const entries = Array.from(seen.values());
+  entries.sort((a, b) => {
+    const rankA = RELEVANCE_RANK[a.anchor.relevance] ?? 2;
+    const rankB = RELEVANCE_RANK[b.anchor.relevance] ?? 2;
+    if (rankA !== rankB) return rankA - rankB;
+    return b.engramScore - a.engramScore;
+  });
+  return entries.slice(0, 10).map((e) => e.anchor);
 }
 function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilter, isPack) {
   if (scopeFilter) {
@@ -946,8 +1038,9 @@ function fillTokenBudget(scored, maxTokens) {
   const packCounts = /* @__PURE__ */ new Map();
   const domainCounts = /* @__PURE__ */ new Map();
   let tokensUsed = 0;
-  for (const { engram } of scored) {
-    if (tokensUsed + TOKENS_PER_ENGRAM > maxTokens) break;
+  for (const engram of scored) {
+    const cost = estimateTokens(engram);
+    if (tokensUsed + cost > maxTokens) continue;
     const pack = engram.pack ?? "__personal__";
     const packCount = packCounts.get(pack) ?? 0;
     if (packCount >= MAX_PER_PACK && pack !== "__personal__") continue;
@@ -956,11 +1049,120 @@ function fillTokenBudget(scored, maxTokens) {
     const domainCount = domainCounts.get(topDomain) ?? 0;
     if (domainCount >= MAX_PER_DOMAIN) continue;
     result.push(engram);
-    tokensUsed += TOKENS_PER_ENGRAM;
+    tokensUsed += cost;
     packCounts.set(pack, packCount + 1);
     domainCounts.set(topDomain, domainCount + 1);
   }
-  return result;
+  return { selected: result, tokens_used: tokensUsed };
+}
+function selectAndSpread(ctx, personalEngrams, packs) {
+  const config = getConfig();
+  const spreadCap = config.injection?.spread_cap ?? 3;
+  const spreadBudget = config.injection?.spread_budget ?? 480;
+  const promptLower = ctx.prompt.toLowerCase();
+  const promptWords = new Set(promptLower.split(/\W+/).filter((w) => w.length > 2));
+  const maxTokens = ctx.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const minRelevance = ctx.minRelevance ?? DEFAULT_MIN_RELEVANCE;
+  const engramMap = /* @__PURE__ */ new Map();
+  const scored = [];
+  for (const engram of personalEngrams) {
+    if (engram.status !== "active") continue;
+    engramMap.set(engram.id, engram);
+    const raw = scoreEngram(engram, promptLower, promptWords, [], ctx.scope, false);
+    if (raw > 0) {
+      scored.push({ ...engram, keyword_match: raw, raw_score: raw, score: raw });
+    }
+  }
+  for (const pack of packs) {
+    if (pack.manifest["x-datacore"].injection_policy === "on_request") continue;
+    const matchTerms = pack.manifest["x-datacore"].match_terms;
+    for (const engram of pack.engrams) {
+      if (engram.status !== "active") continue;
+      engramMap.set(engram.id, engram);
+      const raw = scoreEngram(engram, promptLower, promptWords, matchTerms, ctx.scope, true);
+      if (raw > 0) {
+        scored.push({ ...engram, keyword_match: raw, raw_score: raw, score: raw });
+      }
+    }
+  }
+  const filtered = scored.filter((s) => s.score >= minRelevance);
+  const maxKm = Math.max(...filtered.map((e) => e.keyword_match), 1);
+  for (const e of filtered) {
+    e.keyword_match = e.keyword_match / maxKm * 10;
+  }
+  for (const e of filtered) {
+    const aBoost = anchorBoost(e, promptWords);
+    e.score = e.keyword_match + aBoost;
+  }
+  filtered.sort((a, b) => b.score - a.score);
+  const { selected: directives, tokens_used: directiveTokens } = fillTokenBudget(filtered, maxTokens);
+  const directiveIds = new Set(directives.map((e) => e.id));
+  const directivePackCounts = /* @__PURE__ */ new Map();
+  for (const e of directives) {
+    const pack = e.pack ?? "__personal__";
+    directivePackCounts.set(pack, (directivePackCounts.get(pack) ?? 0) + 1);
+  }
+  const dip19Remainder = filtered.filter((e) => {
+    if (directiveIds.has(e.id)) return false;
+    const pack = e.pack ?? "__personal__";
+    if (pack !== "__personal__" && (directivePackCounts.get(pack) ?? 0) >= MAX_PER_PACK) return false;
+    return true;
+  });
+  const { selected: dip19Consider } = fillTokenBudget(
+    dip19Remainder,
+    DIP19_CONSIDER_BUDGET
+  );
+  const dip19Pool = dip19Consider.slice(0, DIP19_CONSIDER_MAX);
+  const dip19PoolTokens = dip19Pool.reduce((acc, e) => acc + estimateTokens(e), 0);
+  if (directives.length === 0 && dip19Pool.length === 0) {
+    return {
+      directives: [],
+      consider: [],
+      related_documents: [],
+      tokens_used: { directives: 0, consider: 0 }
+    };
+  }
+  const maxFirstPass = Math.max(...directives.map((e) => e.score), 1);
+  const visited = new Set(directives.map((e) => e.id));
+  for (const e of dip19Pool) visited.add(e.id);
+  const spreadCandidates = [];
+  let spreadTokens = 0;
+  for (const directive of directives) {
+    const assocs = directive.associations?.length ? directive.associations : flattenRelations(directive);
+    for (const assoc of assocs) {
+      if (assoc.target_type !== "engram") continue;
+      if (visited.has(assoc.target)) continue;
+      const target = engramMap.get(assoc.target);
+      if (!target || target.status !== "active") continue;
+      const spreadScore = directive.score / maxFirstPass * assoc.strength;
+      if (spreadScore < minRelevance * 0.5) continue;
+      const spreadEngram = {
+        ...target,
+        keyword_match: 0,
+        raw_score: 0,
+        score: spreadScore
+      };
+      const cost = estimateTokens(spreadEngram);
+      if (spreadTokens + cost > spreadBudget) continue;
+      if (spreadCandidates.length >= spreadCap) break;
+      spreadCandidates.push(spreadEngram);
+      spreadTokens += cost;
+      visited.add(assoc.target);
+    }
+  }
+  const allConsider = [...dip19Pool, ...spreadCandidates];
+  const agentDirectives = directives.map(stripAssociations);
+  const agentConsider = allConsider.map(stripAssociations);
+  const relatedDocs = aggregateAnchors(agentDirectives, agentConsider);
+  const wireDirectives = agentDirectives.map(stripScoring);
+  const wireConsider = agentConsider.map(stripScoring);
+  const considerTokens = dip19PoolTokens + spreadTokens;
+  return {
+    directives: wireDirectives,
+    consider: wireConsider,
+    related_documents: relatedDocs,
+    tokens_used: { directives: directiveTokens, consider: considerTokens }
+  };
 }
 
 // src/tools/inject-tool.ts
@@ -970,16 +1172,17 @@ async function handleInject(args2, paths) {
   const ctx = {
     prompt: args2.prompt,
     scope: args2.scope,
+    session_id: args2.session_id,
     maxTokens: args2.max_tokens,
     minRelevance: args2.min_relevance
   };
-  const result = selectEngrams(ctx, personalEngrams, packs);
+  const result = selectAndSpread(ctx, personalEngrams, packs);
   const totalCount = result.directives.length + result.consider.length;
   if (totalCount === 0) {
     return {
       text: "",
       count: 0,
-      tokens_used: 0,
+      tokens_used: { directives: 0, consider: 0 },
       _hints: buildHints({
         next: "No engrams matched this task. Use datacore.recall to search all sources, or datacore.learn to record new knowledge.",
         related: ["datacore.recall", "datacore.learn"]
@@ -999,6 +1202,10 @@ async function handleInject(args2, paths) {
       lines.push(formatEngram(e, totalCount));
     }
   }
+  const relatedDocs = paths.basePath ? result.related_documents.filter((doc) => fs5.existsSync(path4.join(paths.basePath, doc.path))) : result.related_documents;
+  if (relatedDocs.length > 0) {
+    lines.push("\n" + formatRelatedDocs(relatedDocs));
+  }
   updateUsageTracking(
     paths.engramsPath,
     personalEngrams,
@@ -1010,6 +1217,7 @@ async function handleInject(args2, paths) {
     text: lines.join("\n"),
     count: totalCount,
     tokens_used: result.tokens_used,
+    related_documents: relatedDocs.length > 0 ? relatedDocs.length : void 0,
     _hints: buildHints({
       next: `After task, call datacore.feedback on helpful/unhelpful engrams.${idsList}`,
       related: ["datacore.feedback", "datacore.session.end"]
@@ -1048,6 +1256,12 @@ function formatEngram(engram, totalCount) {
     if (engram.contraindications?.length) {
       text += `
   Except: ${engram.contraindications.join(", ")}`;
+    }
+    if (engram.dual_coding) {
+      if (engram.dual_coding.example) text += `
+  Example: ${engram.dual_coding.example}`;
+      if (engram.dual_coding.analogy) text += `
+  Analogy: ${engram.dual_coding.analogy}`;
     }
     return text;
   }
@@ -1057,10 +1271,19 @@ function formatEngram(engram, totalCount) {
   }
   return `- ${engram.statement}`;
 }
+function formatRelatedDocs(docs) {
+  const lines = ["## RELATED DOCUMENTS\n"];
+  for (const doc of docs) {
+    let line = `- [${doc.relevance}] ${doc.path}`;
+    if (doc.snippet) line += ` \u2014 "${doc.snippet}"`;
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
 
 // src/tools/search.ts
 import * as fs6 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 var CONTENT_CACHE_MAX = 500;
 var contentCache = /* @__PURE__ */ new Map();
 function getCachedContent(filePath) {
@@ -1136,7 +1359,7 @@ function searchDir(dirPath, query) {
 function walkDir(dir) {
   const files = [];
   for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path4.join(dir, entry.name);
+    const fullPath = path5.join(dir, entry.name);
     if (entry.isDirectory()) files.push(...walkDir(fullPath));
     else files.push(fullPath);
   }
@@ -1164,17 +1387,17 @@ function extractSnippet(content, query) {
 function extractTitle(content, filePath) {
   const match = content.match(/^#\s+(.+)$/m);
   if (match) return match[1].trim();
-  return path4.basename(filePath, path4.extname(filePath));
+  return path5.basename(filePath, path5.extname(filePath));
 }
 function extractDate(filePath) {
-  const match = path4.basename(filePath).match(/^(\d{4}-\d{2}-\d{2})/);
+  const match = path5.basename(filePath).match(/^(\d{4}-\d{2}-\d{2})/);
   if (match) return match[1];
   return void 0;
 }
 
 // src/tools/ingest.ts
 import * as fs7 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 async function handleIngest(args2, paths) {
   const contentError = validateContent(args2.content);
   if (contentError) return { success: false, error: contentError };
@@ -1185,8 +1408,8 @@ async function handleIngest(args2, paths) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const slug = (args2.title ?? "ingested").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
   const fileName = `${timestamp}-${slug}.md`;
-  const filePath = path5.join(paths.knowledgePath, fileName);
-  fs7.mkdirSync(path5.dirname(filePath), { recursive: true });
+  const filePath = path6.join(paths.knowledgePath, fileName);
+  fs7.mkdirSync(path6.dirname(filePath), { recursive: true });
   const frontmatter = `---
 title: "${args2.title ?? "Ingested Note"}"
 created: "${(/* @__PURE__ */ new Date()).toISOString()}"
@@ -1232,18 +1455,18 @@ function extractEngramSuggestions(content) {
 
 // src/tools/status.ts
 import * as fs9 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 
 // src/trust.ts
 import * as fs8 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 import * as crypto from "crypto";
 function computePackChecksum(packDir) {
   const files = ["SKILL.md", "engrams.yaml"];
   const hash = crypto.createHash("sha256");
   let hasContent = false;
   for (const file of files) {
-    const filePath = path6.join(packDir, file);
+    const filePath = path7.join(packDir, file);
     if (fs8.existsSync(filePath)) {
       hash.update(fs8.readFileSync(filePath));
       hasContent = true;
@@ -1600,7 +1823,7 @@ async function handleStatus(paths, updateAvailable2, engagementService2) {
   const packIntegrity = [];
   for (const regPack of packs_default.packs) {
     if (!regPack.checksum) continue;
-    const packDir = path7.join(paths.packsPath, regPack.id);
+    const packDir = path8.join(paths.packsPath, regPack.id);
     if (!fs9.existsSync(packDir)) continue;
     const result = verifyPackChecksum(packDir, regPack.checksum);
     packIntegrity.push({ name: regPack.id, valid: result.valid });
@@ -1617,7 +1840,7 @@ async function handleStatus(paths, updateAvailable2, engagementService2) {
     recommendations.push(`${candidateCount} candidate engrams awaiting review. Use datacore.promote or enable engrams.auto_promote in config.yaml.`);
   }
   const { date: today } = localDate();
-  const todayJournal = path7.join(paths.journalPath, `${today}.md`);
+  const todayJournal = path8.join(paths.journalPath, `${today}.md`);
   if (!fs9.existsSync(todayJournal)) {
     recommendations.push("No journal entry today. Use datacore.capture to start one.");
   }
@@ -1668,7 +1891,7 @@ function countFiles(dir, ext) {
   if (!fs9.existsSync(dir)) return 0;
   let count = 0;
   for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path7.join(dir, entry.name);
+    const fullPath = path8.join(dir, entry.name);
     if (entry.isDirectory()) count += countFiles(fullPath, ext);
     else if (entry.name.endsWith(ext)) count++;
   }
@@ -1681,26 +1904,26 @@ function countDirs(dir) {
 
 // src/tools/discover.ts
 import * as fs10 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 function handleDiscover(args2, packsDir) {
-  const bundledDir = path8.join(
-    path8.dirname(new URL(import.meta.url).pathname),
+  const bundledDir = path9.join(
+    path9.dirname(new URL(import.meta.url).pathname),
     "..",
     "packs"
   );
   let packs = packs_default.packs.map((p) => {
-    const localDir = path8.join(packsDir, p.id);
-    const installed = fs10.existsSync(path8.join(localDir, "SKILL.md"));
+    const localDir = path9.join(packsDir, p.id);
+    const installed = fs10.existsSync(path9.join(localDir, "SKILL.md"));
     let installedVersion;
     if (installed) {
       try {
-        const content = fs10.readFileSync(path8.join(localDir, "SKILL.md"), "utf8");
+        const content = fs10.readFileSync(path9.join(localDir, "SKILL.md"), "utf8");
         const match = content.match(/version:\s*["']?([^"'\n]+)/);
         installedVersion = match?.[1];
       } catch {
       }
     }
-    const bundled = fs10.existsSync(path8.join(bundledDir, p.id, "SKILL.md"));
+    const bundled = fs10.existsSync(path9.join(bundledDir, p.id, "SKILL.md"));
     return {
       ...p,
       installed,
@@ -1732,7 +1955,7 @@ function handleDiscover(args2, packsDir) {
 
 // src/tools/install.ts
 import * as fs11 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import * as yaml4 from "js-yaml";
 import * as os2 from "os";
 import { execSync } from "child_process";
@@ -1747,7 +1970,7 @@ async function handleInstall(args2, packsDir) {
     if (resolved.error) return { success: false, error: resolved.error };
     srcDir = resolved.path;
   }
-  const skillPath = path9.join(srcDir, "SKILL.md");
+  const skillPath = path10.join(srcDir, "SKILL.md");
   if (!fs11.existsSync(skillPath)) {
     return { success: false, error: "No SKILL.md found in source directory" };
   }
@@ -1762,9 +1985,9 @@ async function handleInstall(args2, packsDir) {
   if (!packId) {
     return { success: false, error: "Missing x-datacore.id in SKILL.md frontmatter" };
   }
-  const destDir = path9.join(packsDir, packId);
-  if (fs11.existsSync(path9.join(destDir, "SKILL.md"))) {
-    const existingContent = fs11.readFileSync(path9.join(destDir, "SKILL.md"), "utf8");
+  const destDir = path10.join(packsDir, packId);
+  if (fs11.existsSync(path10.join(destDir, "SKILL.md"))) {
+    const existingContent = fs11.readFileSync(path10.join(destDir, "SKILL.md"), "utf8");
     const existingMatch = existingContent.match(/version:\s*["']?([^"'\n]+)/);
     const existingVersion = existingMatch?.[1];
     if (existingVersion === newVersion) {
@@ -1785,14 +2008,14 @@ function verifyInstalledChecksum(packId, destDir) {
   return result.valid;
 }
 async function downloadPack(url) {
-  const tmpDir = fs11.mkdtempSync(path9.join(os2.tmpdir(), "datacore-pack-"));
+  const tmpDir = fs11.mkdtempSync(path10.join(os2.tmpdir(), "datacore-pack-"));
   try {
     const res = await fetch(url, { signal: AbortSignal.timeout(3e4) });
     if (!res.ok) return { error: `Download failed: HTTP ${res.status}` };
     const buffer = Buffer.from(await res.arrayBuffer());
-    const archivePath = path9.join(tmpDir, "pack.tar.gz");
+    const archivePath = path10.join(tmpDir, "pack.tar.gz");
     fs11.writeFileSync(archivePath, buffer);
-    const extractDir = path9.join(tmpDir, "extracted");
+    const extractDir = path10.join(tmpDir, "extracted");
     fs11.mkdirSync(extractDir);
     execSync(`tar xzf ${JSON.stringify(archivePath)} -C ${JSON.stringify(extractDir)}`, { timeout: 1e4 });
     const packRoot = findPackRoot(extractDir);
@@ -1803,10 +2026,10 @@ async function downloadPack(url) {
   }
 }
 function findPackRoot(dir) {
-  if (fs11.existsSync(path9.join(dir, "SKILL.md"))) return dir;
+  if (fs11.existsSync(path10.join(dir, "SKILL.md"))) return dir;
   for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      const found = findPackRoot(path9.join(dir, entry.name));
+      const found = findPackRoot(path10.join(dir, entry.name));
       if (found) return found;
     }
   }
@@ -1820,17 +2043,17 @@ function resolvePackId(packId, packsDir) {
   if (registryPack.download_url) {
     return { error: `Pack "${packId}" must be installed via URL: ${registryPack.download_url}` };
   }
-  const bundledDir = path9.join(
-    path9.dirname(new URL(import.meta.url).pathname),
+  const bundledDir = path10.join(
+    path10.dirname(new URL(import.meta.url).pathname),
     "..",
     "packs",
     packId
   );
-  if (fs11.existsSync(path9.join(bundledDir, "SKILL.md"))) {
+  if (fs11.existsSync(path10.join(bundledDir, "SKILL.md"))) {
     return { path: bundledDir };
   }
-  const localDir = path9.join(packsDir, packId);
-  if (fs11.existsSync(path9.join(localDir, "SKILL.md"))) {
+  const localDir = path10.join(packsDir, packId);
+  if (fs11.existsSync(path10.join(localDir, "SKILL.md"))) {
     return { path: localDir };
   }
   return { error: `Pack "${packId}" is registered but not available locally. It may need to be downloaded manually.` };
@@ -1838,7 +2061,7 @@ function resolvePackId(packId, packsDir) {
 
 // src/tools/export.ts
 import * as fs12 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 import * as yaml5 from "js-yaml";
 async function handleExport(args2, paths, service) {
   const allEngrams = loadEngrams(paths.engramsPath);
@@ -1871,7 +2094,7 @@ async function handleExport(args2, paths, service) {
     return { success: false, error: "No engrams match the filter criteria" };
   }
   const packId = args2.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
-  const packDir = path10.join(paths.packsPath, packId);
+  const packDir = path11.join(paths.packsPath, packId);
   if (!args2.confirm) {
     return {
       success: true,
@@ -1907,7 +2130,7 @@ ${args2.description}
 
 Exported ${selected.length} engrams.
 `;
-  fs12.writeFileSync(path10.join(packDir, "SKILL.md"), skillContent);
+  fs12.writeFileSync(path11.join(packDir, "SKILL.md"), skillContent);
   const exportEngrams = selected.map((e) => ({
     id: e.id,
     version: e.version,
@@ -1929,7 +2152,7 @@ Exported ${selected.length} engrams.
     feedback_signals: { positive: 0, negative: 0 }
   }));
   fs12.writeFileSync(
-    path10.join(packDir, "engrams.yaml"),
+    path11.join(packDir, "engrams.yaml"),
     yaml5.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' })
   );
   if (service?.isEnabled() && selected.length >= 5) {
@@ -1943,18 +2166,18 @@ Exported ${selected.length} engrams.
 
 // src/modules.ts
 import * as fs13 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import * as yaml6 from "js-yaml";
 function discoverModules(storage2) {
   const modules = [];
   if (storage2.mode !== "full") return modules;
-  const globalModulesDir = path11.join(storage2.basePath, ".datacore", "modules");
+  const globalModulesDir = path12.join(storage2.basePath, ".datacore", "modules");
   modules.push(...scanModulesDir(globalModulesDir, "global"));
   try {
     const entries = fs13.readdirSync(storage2.basePath);
     for (const entry of entries) {
       if (/^\d+-/.test(entry)) {
-        const spaceModulesDir = path11.join(storage2.basePath, entry, ".datacore", "modules");
+        const spaceModulesDir = path12.join(storage2.basePath, entry, ".datacore", "modules");
         modules.push(...scanModulesDir(spaceModulesDir, "space", entry));
       }
     }
@@ -1968,8 +2191,8 @@ function scanModulesDir(modulesDir, scope, spaceName) {
   try {
     const entries = fs13.readdirSync(modulesDir);
     for (const entry of entries) {
-      const modulePath = path11.join(modulesDir, entry);
-      const manifestPath = path11.join(modulePath, "module.yaml");
+      const modulePath = path12.join(modulesDir, entry);
+      const manifestPath = path12.join(modulePath, "module.yaml");
       if (!fs13.existsSync(manifestPath)) continue;
       try {
         const raw = fs13.readFileSync(manifestPath, "utf-8");
@@ -1994,12 +2217,12 @@ async function loadModuleTools(modules, storage2) {
   for (const mod of modules) {
     const declaredTools = mod.manifest.provides?.tools;
     if (!declaredTools || declaredTools.length === 0) continue;
-    const toolsIndexPath = path11.join(mod.modulePath, "tools", "index.js");
+    const toolsIndexPath = path12.join(mod.modulePath, "tools", "index.js");
     if (!fs13.existsSync(toolsIndexPath)) continue;
     try {
       const toolsModule = await import(toolsIndexPath);
       const moduleTools2 = toolsModule.tools || toolsModule.default?.tools || [];
-      const dataPath = mod.scope === "space" && mod.spaceName ? path11.join(storage2.basePath, mod.spaceName, ".datacore", "modules", mod.name, "data") : path11.join(storage2.basePath, "0-personal", ".datacore", "modules", mod.name, "data");
+      const dataPath = mod.scope === "space" && mod.spaceName ? path12.join(storage2.basePath, mod.spaceName, ".datacore", "modules", mod.name, "data") : path12.join(storage2.basePath, "0-personal", ".datacore", "modules", mod.name, "data");
       const context = {
         storage: storage2,
         modulePath: mod.modulePath,
@@ -2096,7 +2319,7 @@ async function handleModulesInfo(args2, storage2, cachedModules) {
 
 // src/tools/modules-health.ts
 import * as fs14 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 async function handleModulesHealth(args2, storage2, cachedModules) {
   const modules = cachedModules ?? discoverModules(storage2);
   if (args2.module) {
@@ -2118,10 +2341,10 @@ async function handleModulesHealth(args2, storage2, cachedModules) {
 async function checkModule(mod, storage2) {
   const issues = [];
   const manifest = mod.manifest;
-  if (!fs14.existsSync(path12.join(mod.modulePath, "SKILL.md"))) {
+  if (!fs14.existsSync(path13.join(mod.modulePath, "SKILL.md"))) {
     issues.push("Missing SKILL.md (ecosystem entry point)");
   }
-  if (!fs14.existsSync(path12.join(mod.modulePath, "CLAUDE.base.md"))) {
+  if (!fs14.existsSync(path13.join(mod.modulePath, "CLAUDE.base.md"))) {
     issues.push("Missing CLAUDE.base.md (AI context)");
   }
   if (!manifest.manifest_version || manifest.manifest_version < 2) {
@@ -2137,7 +2360,7 @@ async function checkModule(mod, storage2) {
   const provides = manifest.provides;
   const declaredTools = provides?.tools || [];
   if (declaredTools.length > 0) {
-    const toolsIndex = path12.join(mod.modulePath, "tools", "index.js");
+    const toolsIndex = path13.join(mod.modulePath, "tools", "index.js");
     if (!fs14.existsSync(toolsIndex)) {
       issues.push(`Declares ${declaredTools.length} tools but tools/index.js not found`);
     } else {
@@ -2157,7 +2380,7 @@ async function checkModule(mod, storage2) {
   const suspectExts = [".db", ".sqlite", ".json"];
   const suspectDirs = ["output", "data", "state"];
   for (const dir of suspectDirs) {
-    const fullPath = path12.join(mod.modulePath, dir);
+    const fullPath = path13.join(mod.modulePath, dir);
     if (fs14.existsSync(fullPath) && fs14.statSync(fullPath).isDirectory()) {
       issues.push(`Data dir '${dir}/' found in module code (should be in space data path)`);
     }
@@ -2238,7 +2461,7 @@ async function handleForget(args2, engramsPath, service) {
 }
 
 // src/tools/feedback.ts
-import * as path13 from "path";
+import * as path14 from "path";
 function findEngram(engramId, engramsPath, packsPath) {
   const personal = loadEngrams(engramsPath);
   const found = personal.find((e) => e.id === engramId);
@@ -2248,14 +2471,14 @@ function findEngram(engramId, engramsPath, packsPath) {
     const packEngram = pack.engrams.find((e) => e.id === engramId);
     if (packEngram) {
       const packId = pack.manifest["x-datacore"]?.id;
-      const packEngramsPath = packId ? path13.join(packsPath, packId, "engrams.yaml") : void 0;
+      const packEngramsPath = packId ? path14.join(packsPath, packId, "engrams.yaml") : void 0;
       return { engram: packEngram, source: "pack", packEngrams: pack.engrams, packEngramsPath };
     }
   }
   return null;
 }
 async function handleFeedback(args2, engramsPath, packsPath, service) {
-  const pPath = packsPath ?? path13.join(path13.dirname(engramsPath), "packs");
+  const pPath = packsPath ?? path14.join(path14.dirname(engramsPath), "packs");
   if (args2.signals && args2.signals.length > 0) {
     return handleBatchFeedback(args2.signals, engramsPath, pPath, service);
   }
@@ -2323,7 +2546,7 @@ async function handleBatchFeedback(signals, engramsPath, packsPath, service) {
           const packId = pack.manifest["x-datacore"]?.id;
           if (packId) {
             dirtyPackFiles.set(
-              path13.join(packsPath, packId, "engrams.yaml"),
+              path14.join(packsPath, packId, "engrams.yaml"),
               pack.engrams
             );
           }
@@ -2372,23 +2595,24 @@ async function handleBatchFeedback(signals, engramsPath, packsPath, service) {
 
 // src/tools/session-start.ts
 import * as fs18 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
+import * as crypto2 from "crypto";
 
 // src/engagement/service.ts
 import * as fs17 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 
 // src/engagement/profile.ts
 import * as fs15 from "fs";
-import * as path14 from "path";
+import * as path15 from "path";
 import * as yaml7 from "js-yaml";
 var PROFILE_DIR = "engagement";
 var PROFILE_FILE = "profile.yaml";
 function engagementDir(basePath) {
-  return path14.join(basePath, ".datacore", PROFILE_DIR);
+  return path15.join(basePath, ".datacore", PROFILE_DIR);
 }
 function profilePath(basePath) {
-  return path14.join(engagementDir(basePath), PROFILE_FILE);
+  return path15.join(engagementDir(basePath), PROFILE_FILE);
 }
 function createDefaultProfile() {
   return EngagementProfileSchema.parse({ version: 4 });
@@ -2426,7 +2650,7 @@ function ensureEngagementDir(basePath) {
   if (!fs15.existsSync(dir)) {
     fs15.mkdirSync(dir, { recursive: true });
   }
-  const gitignorePath = path14.join(basePath, ".datacore", ".gitignore");
+  const gitignorePath = path15.join(basePath, ".datacore", ".gitignore");
   if (fs15.existsSync(gitignorePath)) {
     const content = fs15.readFileSync(gitignorePath, "utf8");
     if (!content.includes("engagement/profile.yaml")) {
@@ -2437,7 +2661,7 @@ function ensureEngagementDir(basePath) {
 
 // src/engagement/actions.ts
 import * as fs16 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 import * as yaml8 from "js-yaml";
 var BUNDLED_ACTIONS = {
   version: 1,
@@ -2510,7 +2734,7 @@ var BUNDLED_ACTIONS = {
   }
 };
 function loadActions(basePath) {
-  const actionsPath = path15.join(basePath, ".datacore", "engagement", "xp-actions.yaml");
+  const actionsPath = path16.join(basePath, ".datacore", "engagement", "xp-actions.yaml");
   if (!fs16.existsSync(actionsPath)) {
     return BUNDLED_ACTIONS;
   }
@@ -2523,8 +2747,8 @@ function loadActions(basePath) {
   }
 }
 function writeDefaultActions(basePath) {
-  const dir = path15.join(basePath, ".datacore", "engagement");
-  const actionsPath = path15.join(dir, "xp-actions.yaml");
+  const dir = path16.join(basePath, ".datacore", "engagement");
+  const actionsPath = path16.join(dir, "xp-actions.yaml");
   if (fs16.existsSync(actionsPath)) return;
   if (!fs16.existsSync(dir)) {
     fs16.mkdirSync(dir, { recursive: true });
@@ -2769,9 +2993,9 @@ var EngagementService = class {
   async init() {
     if (!this.isEnabled() || this.initialized) return;
     ensureEngagementDir(this.basePath);
-    const profilePath2 = path16.join(this.basePath, ".datacore", "engagement", "profile.yaml");
-    const engramsPath = path16.join(this.basePath, ".datacore", "learning", "engrams.yaml");
-    const coreEngramsPath = path16.join(this.basePath, "engrams.yaml");
+    const profilePath2 = path17.join(this.basePath, ".datacore", "engagement", "profile.yaml");
+    const engramsPath = path17.join(this.basePath, ".datacore", "learning", "engrams.yaml");
+    const coreEngramsPath = path17.join(this.basePath, "engrams.yaml");
     if (!fs17.existsSync(profilePath2)) {
       const actualEngramsPath = fs17.existsSync(engramsPath) ? engramsPath : coreEngramsPath;
       if (fs17.existsSync(actualEngramsPath)) {
@@ -3221,18 +3445,19 @@ function dismissChallenge(profile, challengeId) {
 
 // src/tools/session-start.ts
 async function handleSessionStart(args2, storage2, bridge, engagementService2) {
+  const session_id = crypto2.randomUUID();
   let engrams = null;
   if (args2.task) {
     const injectResult = await handleInject(
-      { prompt: args2.task, scope: args2.tags?.length ? `tags:${args2.tags.join(",")}` : void 0 },
-      { engramsPath: storage2.engramsPath, packsPath: storage2.packsPath }
+      { prompt: args2.task, session_id, scope: args2.tags?.length ? `tags:${args2.tags.join(",")}` : void 0 },
+      { engramsPath: storage2.engramsPath, packsPath: storage2.packsPath, basePath: storage2.basePath }
     );
     if (injectResult.count > 0) {
       engrams = { text: injectResult.text, count: injectResult.count };
     }
   }
   const { date: today } = localDate();
-  const journalFile = path17.join(storage2.journalPath, `${today}.md`);
+  const journalFile = path18.join(storage2.journalPath, `${today}.md`);
   const journal_today = fs18.existsSync(journalFile) ? fs18.readFileSync(journalFile, "utf8") : null;
   const allEngrams = loadEngrams(storage2.engramsPath);
   const pending_candidates = allEngrams.filter((e) => e.status === "candidate").length;
@@ -3324,7 +3549,7 @@ async function handleSessionStart(args2, storage2, bridge, engagementService2) {
     } catch {
     }
   }
-  return { engrams, journal_today, pending_candidates, recommendations, guide, engagement, _hints: hints };
+  return { session_id, engrams, journal_today, pending_candidates, recommendations, guide, engagement, _hints: hints };
 }
 var SESSION_GUIDE_FULL = `## Datacore Quick Start
 
@@ -3695,7 +3920,7 @@ import {
   ListResourceTemplatesRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 import * as fs19 from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 function registerResources(server, storage2) {
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
@@ -3776,7 +4001,7 @@ function registerResources(server, storage2) {
     const journalMatch = uri.match(/^datacore:\/\/journal\/(.+)$/);
     if (journalMatch) {
       const dateStr = journalMatch[1] === "today" ? localDate().date : journalMatch[1];
-      const filePath = path18.join(storage2.journalPath, `${dateStr}.md`);
+      const filePath = path19.join(storage2.journalPath, `${dateStr}.md`);
       if (!fs19.existsSync(filePath)) {
         return { contents: [{ uri, mimeType: "text/markdown", text: `No journal entry for ${dateStr}` }] };
       }
@@ -4027,7 +4252,7 @@ function registerPrompts(server) {
 // src/datacortex.ts
 import { execFile } from "child_process";
 import * as fs20 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 var DatacortexBridge = class {
   pythonPath;
   scriptPath;
@@ -4037,8 +4262,8 @@ var DatacortexBridge = class {
   }
   findBridgeScript(datacorePath) {
     const candidates = [
-      path19.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
-      path19.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
+      path20.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
+      path20.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
     ];
     for (const candidate of candidates) {
       if (fs20.existsSync(candidate)) return candidate;
@@ -4171,7 +4396,7 @@ async function routeTool(name, args2) {
         result = await handleLearn(validated, storage.engramsPath, getEngagementService());
         break;
       case "datacore.inject":
-        result = await handleInject(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath });
+        result = await handleInject(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath, basePath: storage.basePath });
         break;
       case "datacore.search":
         result = await handleSearch(validated, { journalPath: storage.journalPath, knowledgePath: storage.knowledgePath }, datacortexBridge);