@datacore-one/mcp 1.4.1 → 1.5.1

package/dist/index.js

@@ -41,7 +41,13 @@ function fullConfig(basePath) {
     engramsPath: path.join(basePath, ".datacore", "learning", "engrams.yaml"),
     journalPath: path.join(basePath, "0-personal", "journal"),
     knowledgePath: path.join(basePath, "0-personal", "3-knowledge"),
-    packsPath: path.join(basePath, ".datacore", "learning", "packs")
+    packsPath: path.join(basePath, ".datacore", "learning", "packs"),
+    schemasPath: path.join(basePath, ".datacore", "learning", "schemas.yaml"),
+    exchangeInboxPath: path.join(basePath, ".datacore", "learning", "exchange", "inbox"),
+    exchangeOutboxPath: path.join(basePath, ".datacore", "learning", "exchange", "outbox"),
+    knowledgeSurfacingPath: path.join(basePath, ".datacore", "state", "knowledge-surfacing.yaml"),
+    archivePath: path.join(basePath, ".datacore", "learning", "archive"),
+    statePath: path.join(basePath, ".datacore", "state")
   };
 }
 function coreConfig(basePath) {
@@ -51,12 +57,18 @@ function coreConfig(basePath) {
     engramsPath: path.join(basePath, "engrams.yaml"),
     journalPath: path.join(basePath, "journal"),
     knowledgePath: path.join(basePath, "knowledge"),
-    packsPath: path.join(basePath, "packs")
+    packsPath: path.join(basePath, "packs"),
+    schemasPath: path.join(basePath, "schemas.yaml"),
+    exchangeInboxPath: path.join(basePath, "exchange", "inbox"),
+    exchangeOutboxPath: path.join(basePath, "exchange", "outbox"),
+    knowledgeSurfacingPath: path.join(basePath, "state", "knowledge-surfacing.yaml"),
+    archivePath: path.join(basePath, "archive"),
+    statePath: path.join(basePath, "state")
   };
 }
 function initCore(basePath) {
   const isFirstRun2 = !fs.existsSync(path.join(basePath, "engrams.yaml"));
-  for (const dir of ["journal", "knowledge", "packs"]) {
+  for (const dir of ["journal", "knowledge", "packs", "exchange/inbox", "exchange/outbox", "archive", "state"]) {
     const dirPath = path.join(basePath, dir);
     if (!fs.existsSync(dirPath)) {
       fs.mkdirSync(dirPath, { recursive: true });
@@ -228,6 +240,21 @@ var ConfigSchema = z.object({
     consider_cap: z.number().default(5),
     spread_cap: z.number().default(3),
     spread_budget: z.number().default(480)
+  }).default({}),
+  co_access: z.object({
+    new_strength: z.number().default(0.1),
+    increment: z.number().default(0.05),
+    max_strength: z.number().default(0.95),
+    decay_rate: z.number().default(0.05),
+    prune_threshold: z.number().default(0.05)
+  }).default({}),
+  learning: z.object({
+    decay_rate: z.number().default(0.05),
+    abstraction_threshold: z.number().default(2),
+    legacy_audit_rate: z.number().default(3),
+    auto_defer_learning_review: z.boolean().default(false),
+    daily_review_max_items: z.number().default(5),
+    onboarding_max_items: z.number().default(15)
   }).default({})
 });
 var cachedConfig = null;
@@ -252,7 +279,7 @@ function getConfig() {
 // package.json
 var package_default = {
   name: "@datacore-one/mcp",
-  version: "1.4.1",
+  version: "1.5.1",
   description: "Datacore MCP server \u2014 The Software of You",
   type: "module",
   bin: {
@@ -350,7 +377,9 @@ var TOOLS = [
       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")
+      }).optional().describe("Dual coding: example and/or analogy for richer encoding"),
+      abstract: z2.string().nullable().optional().describe("Abstract engram ID this was derived from"),
+      derived_from: z2.string().nullable().optional().describe("Source engram ID this was derived from")
     })
   },
   {
@@ -497,6 +526,40 @@ var TOOLS = [
       module: z2.string().optional().describe("Module name (omit for all modules)")
     })
   },
+  {
+    name: "datacore.knowledge.scan",
+    description: "Scan zettel knowledge base for engram candidates, or run consolidation pass to find low-RS and duplicate engrams.",
+    inputSchema: z2.object({
+      action: z2.enum(["scan_zettels", "scan_status", "consolidation_pass"]).describe("Action: scan_zettels | scan_status | consolidation_pass"),
+      confirm: z2.boolean().optional().describe("Confirm consolidation execution (default: preview only)")
+    })
+  },
+  {
+    name: "datacore.exchange",
+    description: "Exchange engrams via Learning Exchange Packets (LEP). Export your public engrams, import from others, or check inbox/outbox status.",
+    inputSchema: z2.object({
+      action: z2.enum(["export", "import", "status"]).describe("Action: export | import | status"),
+      engram_ids: z2.array(z2.string()).optional().describe("Specific engram IDs to export"),
+      filter_domain: z2.string().optional().describe("Filter export by domain prefix"),
+      path: z2.string().optional().describe("Path to LEP packet file (for import)"),
+      sender: z2.string().optional().describe("Sender identity (for export)"),
+      confirm: z2.boolean().optional().describe("Confirm import (default: preview only)"),
+      fitness_threshold: z2.number().optional().describe("Minimum fitness score for import (default: 0.3)"),
+      source_cap_percent: z2.number().optional().describe("Max percentage of engrams from one source (default: 0.20)")
+    })
+  },
+  {
+    name: "datacore.schemas",
+    description: "Manage knowledge schemas \u2014 detect clusters, activate, archive, merge, split, or migrate legacy relations.",
+    inputSchema: z2.object({
+      action: z2.enum(["list", "detect", "activate", "archive", "merge", "split", "migrate"]).describe("Action: list | detect | activate | archive | merge | split | migrate"),
+      id: z2.string().optional().describe("Schema ID (for activate/archive/merge/split)"),
+      target_id: z2.string().optional().describe("Target schema ID (for merge)"),
+      member_ids: z2.array(z2.string()).optional().describe("Member engram IDs to extract (for split)"),
+      name: z2.string().optional().describe("Name for new schema (for split)"),
+      confirm: z2.boolean().optional().describe("Confirm destructive action (for migrate)")
+    })
+  },
   {
     name: "datacore.resolve",
     description: "Resolve a pending engagement event: reconsolidation (contradiction challenge), discovery (cross-domain insight), or challenge (weekly goal). The agent presents options to the user and calls this with their choice.",
@@ -616,7 +679,8 @@ 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"])
+  type: z3.enum(["semantic", "temporal", "causal", "co_accessed"]),
+  updated_at: z3.string().optional()
 });
 var DualCodingSchema = z3.object({
   example: z3.string().optional(),
@@ -643,7 +707,7 @@ var FeedbackSignalsSchema = z3.object({
   neutral: z3.number().int().default(0)
 });
 var EngramSchema = z3.object({
-  id: z3.string().regex(/^ENG-[A-Za-z0-9-]+$/),
+  id: z3.string().regex(/^(ENG|ABS)-[A-Za-z0-9-]+$/),
   version: z3.number().int().min(1),
   status: z3.enum(["active", "dormant", "retired", "candidate"]),
   consolidated: z3.boolean().default(false),
@@ -824,12 +888,29 @@ function generateEngramId(existingEngrams) {
   const padWidth = nextSeq > 999 ? String(nextSeq).length : 3;
   return `${prefix}${String(nextSeq).padStart(padWidth, "0")}`;
 }
+function generateAbstractId(existingEngrams) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().split("T")[0].replace(/-/g, "").slice(0, 8);
+  const prefix = `ABS-${date.slice(0, 4)}-${date.slice(4)}-`;
+  let maxSeq = 0;
+  for (const e of existingEngrams) {
+    if (e.id.startsWith(prefix)) {
+      const seq = parseInt(e.id.slice(prefix.length), 10);
+      if (seq > maxSeq) maxSeq = seq;
+    }
+  }
+  const nextSeq = maxSeq + 1;
+  const padWidth = nextSeq > 999 ? String(nextSeq).length : 3;
+  return `${prefix}${String(nextSeq).padStart(padWidth, "0")}`;
+}
 async function handleLearn(args2, engramsPath, service) {
   const engrams = loadEngrams(engramsPath);
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const autoPromote = getConfig().engrams.auto_promote;
+  const isAbstract = args2.abstract !== void 0 && args2.abstract !== null;
+  const id = isAbstract ? generateAbstractId(engrams) : generateEngramId(engrams);
   const engram = {
-    id: generateEngramId(engrams),
+    id,
     version: 2,
     status: autoPromote ? "active" : "candidate",
     consolidated: false,
@@ -856,8 +937,8 @@ async function handleLearn(args2, engramsPath, service) {
       last_accessed: today
     },
     pack: null,
-    abstract: null,
-    derived_from: null
+    abstract: args2.abstract ?? null,
+    derived_from: args2.derived_from ?? null
   };
   engrams.push(engram);
   saveEngrams(engramsPath, engrams);
@@ -897,9 +978,9 @@ async function handleLearn(args2, engramsPath, service) {
 }
 
 // src/tools/inject-tool.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path4 from "path";
-import * as yaml3 from "js-yaml";
+import * as yaml4 from "js-yaml";
 
 // src/decay.ts
 var DECAY_RATE = 0.05;
@@ -911,6 +992,15 @@ function decayedStrength(retrievalStrength, lastAccessed, now) {
   const days = Math.max(0, (current.getTime() - last.getTime()) / MS_PER_DAY);
   return Math.max(retrievalStrength * Math.exp(-DECAY_RATE * days), FLOOR);
 }
+function decayedCoAccessStrength(strength, updatedAt, now, decayRate, pruneThreshold) {
+  const rate = decayRate ?? DECAY_RATE;
+  const threshold = pruneThreshold ?? FLOOR;
+  const last = new Date(updatedAt);
+  const current = now ?? /* @__PURE__ */ new Date();
+  const days = Math.max(0, (current.getTime() - last.getTime()) / MS_PER_DAY);
+  const decayed = strength * Math.exp(-rate * days);
+  return decayed < threshold ? 0 : decayed;
+}
 function engramState(retrievalStrength) {
   if (retrievalStrength >= 0.5) return "active";
   if (retrievalStrength >= 0.3) return "fading";
@@ -949,6 +1039,19 @@ function anchorBoost(engram, taskWords) {
   }
   return Math.min(boost, 2);
 }
+var SCHEMA_BOOST = 2;
+function schemaBoost(engramId, schemaMap, scoredAboveMin) {
+  const schemas = schemaMap.get(engramId);
+  if (!schemas) return 0;
+  for (const schema of schemas) {
+    for (const memberId of schema.members) {
+      if (memberId !== engramId && scoredAboveMin.has(memberId)) {
+        return SCHEMA_BOOST;
+      }
+    }
+  }
+  return 0;
+}
 function flattenRelations(engram) {
   if (!engram.relations) return [];
   const associations = [];
@@ -1055,7 +1158,7 @@ function fillTokenBudget(scored, maxTokens) {
   }
   return { selected: result, tokens_used: tokensUsed };
 }
-function selectAndSpread(ctx, personalEngrams, packs) {
+function selectAndSpread(ctx, personalEngrams, packs, schemas = []) {
   const config = getConfig();
   const spreadCap = config.injection?.spread_cap ?? 3;
   const spreadBudget = config.injection?.spread_budget ?? 480;
@@ -1085,15 +1188,33 @@ function selectAndSpread(ctx, personalEngrams, packs) {
       }
     }
   }
-  const filtered = scored.filter((s) => s.score >= minRelevance);
-  const maxKm = Math.max(...filtered.map((e) => e.keyword_match), 1);
-  for (const e of filtered) {
+  const maxKm = Math.max(...scored.map((e) => e.keyword_match), 1);
+  for (const e of scored) {
     e.keyword_match = e.keyword_match / maxKm * 10;
   }
-  for (const e of filtered) {
+  const schemaMap = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    if (schema.status !== "active" && schema.status !== "consolidated") continue;
+    for (const memberId of schema.members) {
+      const existing = schemaMap.get(memberId);
+      if (existing) existing.push(schema);
+      else schemaMap.set(memberId, [schema]);
+    }
+  }
+  const aBoosts = /* @__PURE__ */ new Map();
+  for (const e of scored) {
     const aBoost = anchorBoost(e, promptWords);
+    aBoosts.set(e.id, aBoost);
     e.score = e.keyword_match + aBoost;
   }
+  const scoredAboveMin = new Set(
+    scored.filter((e) => e.score >= minRelevance).map((e) => e.id)
+  );
+  for (const e of scored) {
+    const sBoost = schemaBoost(e.id, schemaMap, scoredAboveMin);
+    e.score = e.keyword_match + (aBoosts.get(e.id) ?? 0) + sBoost;
+  }
+  const filtered = scored.filter((s) => s.score >= minRelevance);
   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));
@@ -1134,7 +1255,9 @@ function selectAndSpread(ctx, personalEngrams, packs) {
       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;
+      const effectiveStrength = assoc.type === "co_accessed" && assoc.updated_at ? decayedCoAccessStrength(assoc.strength, assoc.updated_at) : assoc.strength;
+      if (effectiveStrength <= 0) continue;
+      const spreadScore = directive.score / maxFirstPass * effectiveStrength;
       if (spreadScore < minRelevance * 0.5) continue;
       const spreadEngram = {
         ...target,
@@ -1165,10 +1288,62 @@ function selectAndSpread(ctx, personalEngrams, packs) {
   };
 }
 
+// src/schemas/schema-definition.ts
+import * as fs5 from "fs";
+import * as yaml3 from "js-yaml";
+import { z as z4 } from "zod";
+var SchemaDefinitionSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  members: z4.array(z4.string()),
+  confidence: z4.number().min(0).max(1),
+  status: z4.enum(["candidate", "active", "consolidated", "archived"]),
+  shared_anchors: z4.array(z4.string()),
+  created: z4.string(),
+  updated: z4.string()
+});
+function loadSchemas(filePath) {
+  if (!fs5.existsSync(filePath)) return [];
+  try {
+    const raw = yaml3.load(fs5.readFileSync(filePath, "utf8"));
+    if (!raw?.schemas || !Array.isArray(raw.schemas)) return [];
+    const valid = [];
+    for (const entry of raw.schemas) {
+      const result = SchemaDefinitionSchema.safeParse(entry);
+      if (result.success) valid.push(result.data);
+    }
+    return valid;
+  } catch {
+    return [];
+  }
+}
+function saveSchemas(filePath, schemas) {
+  const content = yaml3.dump({ schemas }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const tmpPath = filePath + ".tmp." + process.pid;
+  fs5.writeFileSync(tmpPath, content);
+  fs5.renameSync(tmpPath, filePath);
+}
+function generateSchemaId(existing) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().split("T")[0].replace(/-/g, "").slice(0, 8);
+  const prefix = `SCH-${date.slice(0, 4)}-${date.slice(4)}-`;
+  let maxSeq = 0;
+  for (const s of existing) {
+    if (s.id.startsWith(prefix)) {
+      const seq = parseInt(s.id.slice(prefix.length), 10);
+      if (seq > maxSeq) maxSeq = seq;
+    }
+  }
+  const nextSeq = maxSeq + 1;
+  const padWidth = nextSeq > 999 ? String(nextSeq).length : 3;
+  return `${prefix}${String(nextSeq).padStart(padWidth, "0")}`;
+}
+
 // src/tools/inject-tool.ts
 async function handleInject(args2, paths) {
   const personalEngrams = loadEngrams(paths.engramsPath);
   const packs = loadAllPacks(paths.packsPath);
+  const schemas = paths.schemasPath ? loadSchemas(paths.schemasPath) : [];
   const ctx = {
     prompt: args2.prompt,
     scope: args2.scope,
@@ -1176,13 +1351,14 @@ async function handleInject(args2, paths) {
     maxTokens: args2.max_tokens,
     minRelevance: args2.min_relevance
   };
-  const result = selectAndSpread(ctx, personalEngrams, packs);
+  const result = selectAndSpread(ctx, personalEngrams, packs, schemas);
   const totalCount = result.directives.length + result.consider.length;
   if (totalCount === 0) {
     return {
       text: "",
       count: 0,
       tokens_used: { directives: 0, consider: 0 },
+      injected_personal_ids: [],
       _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"]
@@ -1202,7 +1378,7 @@ 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;
+  const relatedDocs = paths.basePath ? result.related_documents.filter((doc) => fs6.existsSync(path4.join(paths.basePath, doc.path))) : result.related_documents;
   if (relatedDocs.length > 0) {
     lines.push("\n" + formatRelatedDocs(relatedDocs));
   }
@@ -1217,6 +1393,7 @@ async function handleInject(args2, paths) {
     text: lines.join("\n"),
     count: totalCount,
     tokens_used: result.tokens_used,
+    injected_personal_ids: injectedIds,
     related_documents: relatedDocs.length > 0 ? relatedDocs.length : void 0,
     _hints: buildHints({
       next: `After task, call datacore.feedback on helpful/unhelpful engrams.${idsList}`,
@@ -1243,10 +1420,10 @@ function updateUsageTracking(engramsPath, allPersonal, selected) {
   }
 }
 function atomicWriteYaml(filePath, data) {
-  const content = yaml3.dump(data, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const content = yaml4.dump(data, { lineWidth: 120, noRefs: true, quotingType: '"' });
   const tmpPath = filePath + ".tmp." + process.pid;
-  fs5.writeFileSync(tmpPath, content);
-  fs5.renameSync(tmpPath, filePath);
+  fs6.writeFileSync(tmpPath, content);
+  fs6.renameSync(tmpPath, filePath);
 }
 function formatEngram(engram, totalCount) {
   if (totalCount < 10) {
@@ -1282,7 +1459,7 @@ function formatRelatedDocs(docs) {
 }
 
 // src/tools/search.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path5 from "path";
 var CONTENT_CACHE_MAX = 500;
 var contentCache = /* @__PURE__ */ new Map();
@@ -1290,7 +1467,7 @@ function getCachedContent(filePath) {
   const entry = contentCache.get(filePath);
   if (!entry) return null;
   try {
-    const stat = fs6.statSync(filePath);
+    const stat = fs7.statSync(filePath);
     if (stat.mtimeMs === entry.mtime) return entry.content;
   } catch {
   }
@@ -1299,7 +1476,7 @@ function getCachedContent(filePath) {
 }
 function setCachedContent(filePath, content) {
   try {
-    const mtime = fs6.statSync(filePath).mtimeMs;
+    const mtime = fs7.statSync(filePath).mtimeMs;
     if (contentCache.size >= CONTENT_CACHE_MAX) {
       const firstKey = contentCache.keys().next().value;
       if (firstKey) contentCache.delete(firstKey);
@@ -1336,13 +1513,13 @@ async function keywordSearch(args2, paths) {
   return { results: results.slice(0, limit), method: "keyword" };
 }
 function searchDir(dirPath, query) {
-  if (!fs6.existsSync(dirPath)) return [];
+  if (!fs7.existsSync(dirPath)) return [];
   const results = [];
   const queryLower = query.toLowerCase();
   for (const file of walkDir(dirPath)) {
     if (!file.endsWith(".md")) continue;
     const content = getCachedContent(file) ?? (() => {
-      const c = fs6.readFileSync(file, "utf8");
+      const c = fs7.readFileSync(file, "utf8");
       setCachedContent(file, c);
       return c;
     })();
@@ -1358,7 +1535,7 @@ function searchDir(dirPath, query) {
 }
 function walkDir(dir) {
   const files = [];
-  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
     const fullPath = path5.join(dir, entry.name);
     if (entry.isDirectory()) files.push(...walkDir(fullPath));
     else files.push(fullPath);
@@ -1396,7 +1573,7 @@ function extractDate(filePath) {
 }
 
 // src/tools/ingest.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path6 from "path";
 async function handleIngest(args2, paths) {
   const contentError = validateContent(args2.content);
@@ -1409,7 +1586,7 @@ async function handleIngest(args2, paths) {
   const slug = (args2.title ?? "ingested").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
   const fileName = `${timestamp}-${slug}.md`;
   const filePath = path6.join(paths.knowledgePath, fileName);
-  fs7.mkdirSync(path6.dirname(filePath), { recursive: true });
+  fs8.mkdirSync(path6.dirname(filePath), { recursive: true });
   const frontmatter = `---
 title: "${args2.title ?? "Ingested Note"}"
 created: "${(/* @__PURE__ */ new Date()).toISOString()}"
@@ -1420,7 +1597,7 @@ type: ingested
   const tagLine = args2.tags?.length ? `
 ${args2.tags.map((t) => `#${t}`).join(" ")}
 ` : "";
-  fs7.writeFileSync(filePath, `${frontmatter}${args2.content}
+  fs8.writeFileSync(filePath, `${frontmatter}${args2.content}
 ${tagLine}`);
   const suggestions = extractEngramSuggestions(args2.content);
   return {
@@ -1454,11 +1631,11 @@ function extractEngramSuggestions(content) {
 }
 
 // src/tools/status.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path8 from "path";
 
 // src/trust.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path7 from "path";
 import * as crypto from "crypto";
 function computePackChecksum(packDir) {
@@ -1467,8 +1644,8 @@ function computePackChecksum(packDir) {
   let hasContent = false;
   for (const file of files) {
     const filePath = path7.join(packDir, file);
-    if (fs8.existsSync(filePath)) {
-      hash.update(fs8.readFileSync(filePath));
+    if (fs9.existsSync(filePath)) {
+      hash.update(fs9.readFileSync(filePath));
       hasContent = true;
     }
   }
@@ -1480,185 +1657,185 @@ function verifyPackChecksum(packDir, expected) {
 }
 
 // src/engagement/types.ts
-import { z as z4 } from "zod";
-var IdentitySchema = z4.object({
-  mode: z4.enum(["private", "anonymous", "verified"]).default("private"),
-  pseudonym: z4.string().nullable().default(null),
-  erc8004_address: z4.string().nullable().default(null),
-  erc8004_registered: z4.boolean().default(false)
+import { z as z5 } from "zod";
+var IdentitySchema = z5.object({
+  mode: z5.enum(["private", "anonymous", "verified"]).default("private"),
+  pseudonym: z5.string().nullable().default(null),
+  erc8004_address: z5.string().nullable().default(null),
+  erc8004_registered: z5.boolean().default(false)
 });
-var XPHistoryEntrySchema = z4.object({
-  date: z4.string(),
-  earned: z4.number(),
-  base_earned: z4.number(),
-  multiplier: z4.number(),
-  actions: z4.array(z4.string())
+var XPHistoryEntrySchema = z5.object({
+  date: z5.string(),
+  earned: z5.number(),
+  base_earned: z5.number(),
+  multiplier: z5.number(),
+  actions: z5.array(z5.string())
 });
-var TierHistoryEntrySchema = z4.object({
-  tier: z4.string(),
-  date: z4.string()
+var TierHistoryEntrySchema = z5.object({
+  tier: z5.string(),
+  date: z5.string()
 });
-var MultiplierEntrySchema = z4.object({
-  type: z4.string(),
-  factor: z4.number(),
-  since: z4.string()
+var MultiplierEntrySchema = z5.object({
+  type: z5.string(),
+  factor: z5.number(),
+  since: z5.string()
 });
-var ChallengeSchema = z4.object({
-  id: z4.string(),
-  type: z4.string(),
-  tier: z4.string(),
-  description: z4.string(),
-  criteria: z4.object({
-    metric: z4.string(),
-    target_delta: z4.number()
+var ChallengeSchema = z5.object({
+  id: z5.string(),
+  type: z5.string(),
+  tier: z5.string(),
+  description: z5.string(),
+  criteria: z5.object({
+    metric: z5.string(),
+    target_delta: z5.number()
   }),
-  baseline_stats: z4.record(z4.number()),
-  bonus_xp: z4.number(),
-  started_at: z4.string(),
-  expires_at: z4.string()
+  baseline_stats: z5.record(z5.number()),
+  bonus_xp: z5.number(),
+  started_at: z5.string(),
+  expires_at: z5.string()
 });
-var ChallengeHistorySchema = z4.object({
-  type: z4.string(),
-  tier: z4.string(),
-  completed: z4.boolean(),
-  date: z4.string()
+var ChallengeHistorySchema = z5.object({
+  type: z5.string(),
+  tier: z5.string(),
+  completed: z5.boolean(),
+  date: z5.string()
 });
-var ReconsolidationPendingSchema = z4.object({
-  engram_id: z4.string(),
-  contradicting_id: z4.string(),
-  statement: z4.string(),
-  contradiction: z4.string(),
-  evidence_strength: z4.enum(["weak", "moderate", "strong"]),
-  confidence: z4.number(),
-  detected_at: z4.string(),
-  expires_at: z4.string()
+var ReconsolidationPendingSchema = z5.object({
+  engram_id: z5.string(),
+  contradicting_id: z5.string(),
+  statement: z5.string(),
+  contradiction: z5.string(),
+  evidence_strength: z5.enum(["weak", "moderate", "strong"]),
+  confidence: z5.number(),
+  detected_at: z5.string(),
+  expires_at: z5.string()
 });
-var DiscoverySchema = z4.object({
-  id: z4.string(),
-  engram_a: z4.object({ id: z4.string(), domain: z4.string(), statement: z4.string() }),
-  engram_b: z4.object({ id: z4.string(), domain: z4.string(), statement: z4.string() }),
-  connection: z4.string(),
-  offered_at: z4.string()
+var DiscoverySchema = z5.object({
+  id: z5.string(),
+  engram_a: z5.object({ id: z5.string(), domain: z5.string(), statement: z5.string() }),
+  engram_b: z5.object({ id: z5.string(), domain: z5.string(), statement: z5.string() }),
+  connection: z5.string(),
+  offered_at: z5.string()
 });
-var EngagementProfileSchema = z4.object({
-  version: z4.literal(4),
+var EngagementProfileSchema = z5.object({
+  version: z5.literal(4),
   identity: IdentitySchema.default({}),
-  xp: z4.object({
-    total: z4.number().default(0),
-    this_week: z4.number().default(0),
-    history: z4.array(XPHistoryEntrySchema).default([])
+  xp: z5.object({
+    total: z5.number().default(0),
+    this_week: z5.number().default(0),
+    history: z5.array(XPHistoryEntrySchema).default([])
   }).default({}),
-  tier: z4.object({
-    current: z4.string().default("Seed"),
-    achieved_at: z4.string().nullable().default(null),
-    history: z4.array(TierHistoryEntrySchema).default([])
+  tier: z5.object({
+    current: z5.string().default("Seed"),
+    achieved_at: z5.string().nullable().default(null),
+    history: z5.array(TierHistoryEntrySchema).default([])
   }).default({}),
-  multipliers: z4.object({
-    active: z4.array(MultiplierEntrySchema).default([]),
-    effective: z4.number().default(1)
+  multipliers: z5.object({
+    active: z5.array(MultiplierEntrySchema).default([]),
+    effective: z5.number().default(1)
   }).default({}),
-  consistency: z4.object({
-    active_days_30: z4.number().default(0),
-    best_run: z4.number().default(0),
-    last_active: z4.string().nullable().default(null)
+  consistency: z5.object({
+    active_days_30: z5.number().default(0),
+    best_run: z5.number().default(0),
+    last_active: z5.string().nullable().default(null)
   }).default({}),
-  challenges: z4.object({
+  challenges: z5.object({
     active: ChallengeSchema.nullable().default(null),
-    completed: z4.number().default(0),
-    dismissed: z4.number().default(0),
-    graduated: z4.boolean().default(false),
-    history: z4.array(ChallengeHistorySchema).default([])
+    completed: z5.number().default(0),
+    dismissed: z5.number().default(0),
+    graduated: z5.boolean().default(false),
+    history: z5.array(ChallengeHistorySchema).default([])
   }).default({}),
-  reconsolidation: z4.object({
-    pending: z4.array(ReconsolidationPendingSchema).default([]),
-    total_resolved: z4.number().default(0),
-    outcomes: z4.object({
-      defended: z4.number().default(0),
-      revised: z4.number().default(0),
-      retired: z4.number().default(0),
-      dismissed: z4.number().default(0)
+  reconsolidation: z5.object({
+    pending: z5.array(ReconsolidationPendingSchema).default([]),
+    total_resolved: z5.number().default(0),
+    outcomes: z5.object({
+      defended: z5.number().default(0),
+      revised: z5.number().default(0),
+      retired: z5.number().default(0),
+      dismissed: z5.number().default(0)
     }).default({}),
-    response_rate: z4.number().default(0)
+    response_rate: z5.number().default(0)
   }).default({}),
-  discoveries: z4.object({
-    pending: z4.array(DiscoverySchema).default([]),
-    total: z4.number().default(0),
-    last_offered: z4.string().nullable().default(null),
-    explored: z4.number().default(0),
-    noted: z4.number().default(0),
-    explore_rate: z4.number().default(0)
+  discoveries: z5.object({
+    pending: z5.array(DiscoverySchema).default([]),
+    total: z5.number().default(0),
+    last_offered: z5.string().nullable().default(null),
+    explored: z5.number().default(0),
+    noted: z5.number().default(0),
+    explore_rate: z5.number().default(0)
   }).default({}),
-  ai_performance: z4.object({
-    total_injections: z4.number().default(0),
-    feedback_count: z4.number().default(0),
-    helpful_ratio: z4.number().default(0),
-    top_engrams: z4.array(z4.object({
-      id: z4.string(),
-      injections: z4.number(),
-      positive_ratio: z4.number()
+  ai_performance: z5.object({
+    total_injections: z5.number().default(0),
+    feedback_count: z5.number().default(0),
+    helpful_ratio: z5.number().default(0),
+    top_engrams: z5.array(z5.object({
+      id: z5.string(),
+      injections: z5.number(),
+      positive_ratio: z5.number()
     })).default([]),
-    unused_60d: z4.array(z4.string()).default([])
+    unused_60d: z5.array(z5.string()).default([])
   }).default({}),
-  reputation: z4.object({
-    score: z4.number().default(0),
-    components: z4.object({
-      feedback_ratio: z4.number().default(0),
-      stake_amount: z4.number().default(0),
-      tenure_days: z4.number().default(0),
-      reconsolidation_honesty: z4.number().default(0)
+  reputation: z5.object({
+    score: z5.number().default(0),
+    components: z5.object({
+      feedback_ratio: z5.number().default(0),
+      stake_amount: z5.number().default(0),
+      tenure_days: z5.number().default(0),
+      reconsolidation_honesty: z5.number().default(0)
     }).default({}),
-    last_calculated: z4.string().nullable().default(null)
+    last_calculated: z5.string().nullable().default(null)
   }).default({}),
-  leaderboard: z4.object({
-    mode: z4.enum(["private", "anonymous", "verified"]).default("private"),
-    display_name: z4.string().nullable().default(null),
-    position: z4.number().nullable().default(null)
+  leaderboard: z5.object({
+    mode: z5.enum(["private", "anonymous", "verified"]).default("private"),
+    display_name: z5.string().nullable().default(null),
+    position: z5.number().nullable().default(null)
   }).default({}),
-  badge: z4.object({
-    preview_svg: z4.string().nullable().default(null),
-    nft_token_id: z4.string().nullable().default(null),
-    last_generated: z4.string().nullable().default(null)
+  badge: z5.object({
+    preview_svg: z5.string().nullable().default(null),
+    nft_token_id: z5.string().nullable().default(null),
+    last_generated: z5.string().nullable().default(null)
   }).default({}),
-  stats: z4.object({
-    total_engrams_created: z4.number().default(0),
-    total_feedback_given: z4.number().default(0),
-    total_engrams_retired: z4.number().default(0),
-    total_packs_exported: z4.number().default(0),
-    total_feedback_received: z4.number().default(0),
-    feedback_positive_ratio: z4.number().default(0),
-    domains_covered: z4.number().default(0),
-    public_engrams: z4.number().default(0),
-    first_activity: z4.string().nullable().default(null)
+  stats: z5.object({
+    total_engrams_created: z5.number().default(0),
+    total_feedback_given: z5.number().default(0),
+    total_engrams_retired: z5.number().default(0),
+    total_packs_exported: z5.number().default(0),
+    total_feedback_received: z5.number().default(0),
+    feedback_positive_ratio: z5.number().default(0),
+    domains_covered: z5.number().default(0),
+    public_engrams: z5.number().default(0),
+    first_activity: z5.string().nullable().default(null)
   }).default({})
 });
-var XPEventSchema = z4.object({
-  action_key: z4.string(),
-  xp_base: z4.number(),
-  multiplier: z4.number(),
-  xp_earned: z4.number(),
-  timestamp: z4.string(),
-  context: z4.record(z4.unknown()).optional()
+var XPEventSchema = z5.object({
+  action_key: z5.string(),
+  xp_base: z5.number(),
+  multiplier: z5.number(),
+  xp_earned: z5.number(),
+  timestamp: z5.string(),
+  context: z5.record(z5.unknown()).optional()
 });
-var XPResultSchema = z4.object({
+var XPResultSchema = z5.object({
   event: XPEventSchema,
-  tier_change: z4.object({
-    from: z4.string(),
-    to: z4.string(),
-    message: z4.string()
+  tier_change: z5.object({
+    from: z5.string(),
+    to: z5.string(),
+    message: z5.string()
   }).nullable()
 });
-var XPActionSchema = z4.object({
-  xp: z4.number(),
-  trigger: z4.string(),
-  condition: z4.string().optional(),
-  daily_limit: z4.number().optional(),
-  cooldown_days: z4.number().optional(),
-  reciprocity_cap: z4.number().optional(),
-  description: z4.string()
+var XPActionSchema = z5.object({
+  xp: z5.number(),
+  trigger: z5.string(),
+  condition: z5.string().optional(),
+  daily_limit: z5.number().optional(),
+  cooldown_days: z5.number().optional(),
+  reciprocity_cap: z5.number().optional(),
+  description: z5.string()
 });
-var XPActionRegistrySchema = z4.object({
-  version: z4.number(),
-  actions: z4.record(XPActionSchema)
+var XPActionRegistrySchema = z5.object({
+  version: z5.number(),
+  actions: z5.record(XPActionSchema)
 });
 var TIER_THRESHOLDS = [
   { name: "Seed", minXP: 0 },
@@ -1824,7 +2001,7 @@ async function handleStatus(paths, updateAvailable2, engagementService2) {
   for (const regPack of packs_default.packs) {
     if (!regPack.checksum) continue;
     const packDir = path8.join(paths.packsPath, regPack.id);
-    if (!fs9.existsSync(packDir)) continue;
+    if (!fs10.existsSync(packDir)) continue;
     const result = verifyPackChecksum(packDir, regPack.checksum);
     packIntegrity.push({ name: regPack.id, valid: result.valid });
   }
@@ -1841,7 +2018,7 @@ async function handleStatus(paths, updateAvailable2, engagementService2) {
   }
   const { date: today } = localDate();
   const todayJournal = path8.join(paths.journalPath, `${today}.md`);
-  if (!fs9.existsSync(todayJournal)) {
+  if (!fs10.existsSync(todayJournal)) {
     recommendations.push("No journal entry today. Use datacore.capture to start one.");
   }
   if (updateAvailable2) {
@@ -1888,9 +2065,9 @@ async function handleStatus(paths, updateAvailable2, engagementService2) {
   return statusResult;
 }
 function countFiles(dir, ext) {
-  if (!fs9.existsSync(dir)) return 0;
+  if (!fs10.existsSync(dir)) return 0;
   let count = 0;
-  for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
     const fullPath = path8.join(dir, entry.name);
     if (entry.isDirectory()) count += countFiles(fullPath, ext);
     else if (entry.name.endsWith(ext)) count++;
@@ -1898,12 +2075,12 @@ function countFiles(dir, ext) {
   return count;
 }
 function countDirs(dir) {
-  if (!fs9.existsSync(dir)) return 0;
-  return fs9.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).length;
+  if (!fs10.existsSync(dir)) return 0;
+  return fs10.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).length;
 }
 
 // src/tools/discover.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path9 from "path";
 function handleDiscover(args2, packsDir) {
   const bundledDir = path9.join(
@@ -1913,17 +2090,17 @@ function handleDiscover(args2, packsDir) {
   );
   let packs = packs_default.packs.map((p) => {
     const localDir = path9.join(packsDir, p.id);
-    const installed = fs10.existsSync(path9.join(localDir, "SKILL.md"));
+    const installed = fs11.existsSync(path9.join(localDir, "SKILL.md"));
     let installedVersion;
     if (installed) {
       try {
-        const content = fs10.readFileSync(path9.join(localDir, "SKILL.md"), "utf8");
+        const content = fs11.readFileSync(path9.join(localDir, "SKILL.md"), "utf8");
         const match = content.match(/version:\s*["']?([^"'\n]+)/);
         installedVersion = match?.[1];
       } catch {
       }
     }
-    const bundled = fs10.existsSync(path9.join(bundledDir, p.id, "SKILL.md"));
+    const bundled = fs11.existsSync(path9.join(bundledDir, p.id, "SKILL.md"));
     return {
       ...p,
       installed,
@@ -1954,9 +2131,9 @@ function handleDiscover(args2, packsDir) {
 }
 
 // src/tools/install.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path10 from "path";
-import * as yaml4 from "js-yaml";
+import * as yaml5 from "js-yaml";
 import * as os2 from "os";
 import { execSync } from "child_process";
 async function handleInstall(args2, packsDir) {
@@ -1971,33 +2148,33 @@ async function handleInstall(args2, packsDir) {
     srcDir = resolved.path;
   }
   const skillPath = path10.join(srcDir, "SKILL.md");
-  if (!fs11.existsSync(skillPath)) {
+  if (!fs12.existsSync(skillPath)) {
     return { success: false, error: "No SKILL.md found in source directory" };
   }
-  const skillContent = fs11.readFileSync(skillPath, "utf8");
+  const skillContent = fs12.readFileSync(skillPath, "utf8");
   const frontmatterMatch = skillContent.match(/^---\n([\s\S]*?)\n---/);
   if (!frontmatterMatch) {
     return { success: false, error: "No YAML frontmatter in SKILL.md" };
   }
-  const manifest = yaml4.load(frontmatterMatch[1]);
+  const manifest = yaml5.load(frontmatterMatch[1]);
   const packId = manifest?.["x-datacore"]?.id;
   const newVersion = manifest?.version;
   if (!packId) {
     return { success: false, error: "Missing x-datacore.id in SKILL.md frontmatter" };
   }
   const destDir = path10.join(packsDir, packId);
-  if (fs11.existsSync(path10.join(destDir, "SKILL.md"))) {
-    const existingContent = fs11.readFileSync(path10.join(destDir, "SKILL.md"), "utf8");
+  if (fs12.existsSync(path10.join(destDir, "SKILL.md"))) {
+    const existingContent = fs12.readFileSync(path10.join(destDir, "SKILL.md"), "utf8");
     const existingMatch = existingContent.match(/version:\s*["']?([^"'\n]+)/);
     const existingVersion = existingMatch?.[1];
     if (existingVersion === newVersion) {
       return { success: true, pack_id: packId, already_current: true };
     }
-    fs11.rmSync(destDir, { recursive: true, force: true });
-    fs11.cpSync(srcDir, destDir, { recursive: true });
+    fs12.rmSync(destDir, { recursive: true, force: true });
+    fs12.cpSync(srcDir, destDir, { recursive: true });
     return { success: true, pack_id: packId, upgraded: true };
   }
-  fs11.cpSync(srcDir, destDir, { recursive: true });
+  fs12.cpSync(srcDir, destDir, { recursive: true });
   const checksumVerified = verifyInstalledChecksum(packId, destDir);
   return { success: true, pack_id: packId, checksum_verified: checksumVerified ?? void 0 };
 }
@@ -2008,15 +2185,15 @@ function verifyInstalledChecksum(packId, destDir) {
   return result.valid;
 }
 async function downloadPack(url) {
-  const tmpDir = fs11.mkdtempSync(path10.join(os2.tmpdir(), "datacore-pack-"));
+  const tmpDir = fs12.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 = path10.join(tmpDir, "pack.tar.gz");
-    fs11.writeFileSync(archivePath, buffer);
+    fs12.writeFileSync(archivePath, buffer);
     const extractDir = path10.join(tmpDir, "extracted");
-    fs11.mkdirSync(extractDir);
+    fs12.mkdirSync(extractDir);
     execSync(`tar xzf ${JSON.stringify(archivePath)} -C ${JSON.stringify(extractDir)}`, { timeout: 1e4 });
     const packRoot = findPackRoot(extractDir);
     if (!packRoot) return { error: "Downloaded archive does not contain SKILL.md" };
@@ -2026,8 +2203,8 @@ async function downloadPack(url) {
   }
 }
 function findPackRoot(dir) {
-  if (fs11.existsSync(path10.join(dir, "SKILL.md"))) return dir;
-  for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
+  if (fs12.existsSync(path10.join(dir, "SKILL.md"))) return dir;
+  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       const found = findPackRoot(path10.join(dir, entry.name));
       if (found) return found;
@@ -2049,20 +2226,20 @@ function resolvePackId(packId, packsDir) {
     "packs",
     packId
   );
-  if (fs11.existsSync(path10.join(bundledDir, "SKILL.md"))) {
+  if (fs12.existsSync(path10.join(bundledDir, "SKILL.md"))) {
     return { path: bundledDir };
   }
   const localDir = path10.join(packsDir, packId);
-  if (fs11.existsSync(path10.join(localDir, "SKILL.md"))) {
+  if (fs12.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.` };
 }
 
 // src/tools/export.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path11 from "path";
-import * as yaml5 from "js-yaml";
+import * as yaml6 from "js-yaml";
 async function handleExport(args2, paths, service) {
   const allEngrams = loadEngrams(paths.engramsPath);
   let selected = allEngrams.filter((e) => e.status === "active");
@@ -2105,13 +2282,13 @@ async function handleExport(args2, paths, service) {
       }
     };
   }
-  if (fs12.existsSync(packDir)) {
+  if (fs13.existsSync(packDir)) {
     return {
       success: false,
       error: `Pack directory already exists at ${packDir}. Remove it first or use a different name.`
     };
   }
-  fs12.mkdirSync(packDir, { recursive: true });
+  fs13.mkdirSync(packDir, { recursive: true });
   const skillContent = `---
 name: "${args2.name}"
 description: "${args2.description}"
@@ -2130,7 +2307,7 @@ ${args2.description}
 
 Exported ${selected.length} engrams.
 `;
-  fs12.writeFileSync(path11.join(packDir, "SKILL.md"), skillContent);
+  fs13.writeFileSync(path11.join(packDir, "SKILL.md"), skillContent);
   const exportEngrams = selected.map((e) => ({
     id: e.id,
     version: e.version,
@@ -2151,9 +2328,9 @@ Exported ${selected.length} engrams.
     },
     feedback_signals: { positive: 0, negative: 0 }
   }));
-  fs12.writeFileSync(
+  fs13.writeFileSync(
     path11.join(packDir, "engrams.yaml"),
-    yaml5.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' })
+    yaml6.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' })
   );
   if (service?.isEnabled() && selected.length >= 5) {
     try {
@@ -2165,16 +2342,16 @@ Exported ${selected.length} engrams.
 }
 
 // src/modules.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path12 from "path";
-import * as yaml6 from "js-yaml";
+import * as yaml7 from "js-yaml";
 function discoverModules(storage2) {
   const modules = [];
   if (storage2.mode !== "full") return modules;
   const globalModulesDir = path12.join(storage2.basePath, ".datacore", "modules");
   modules.push(...scanModulesDir(globalModulesDir, "global"));
   try {
-    const entries = fs13.readdirSync(storage2.basePath);
+    const entries = fs14.readdirSync(storage2.basePath);
     for (const entry of entries) {
       if (/^\d+-/.test(entry)) {
         const spaceModulesDir = path12.join(storage2.basePath, entry, ".datacore", "modules");
@@ -2187,16 +2364,16 @@ function discoverModules(storage2) {
 }
 function scanModulesDir(modulesDir, scope, spaceName) {
   const modules = [];
-  if (!fs13.existsSync(modulesDir)) return modules;
+  if (!fs14.existsSync(modulesDir)) return modules;
   try {
-    const entries = fs13.readdirSync(modulesDir);
+    const entries = fs14.readdirSync(modulesDir);
     for (const entry of entries) {
       const modulePath = path12.join(modulesDir, entry);
       const manifestPath = path12.join(modulePath, "module.yaml");
-      if (!fs13.existsSync(manifestPath)) continue;
+      if (!fs14.existsSync(manifestPath)) continue;
       try {
-        const raw = fs13.readFileSync(manifestPath, "utf-8");
-        const manifest = yaml6.load(raw);
+        const raw = fs14.readFileSync(manifestPath, "utf-8");
+        const manifest = yaml7.load(raw);
         if (!manifest || !manifest.name) continue;
         modules.push({
           name: manifest.name,
@@ -2218,7 +2395,7 @@ async function loadModuleTools(modules, storage2) {
     const declaredTools = mod.manifest.provides?.tools;
     if (!declaredTools || declaredTools.length === 0) continue;
     const toolsIndexPath = path12.join(mod.modulePath, "tools", "index.js");
-    if (!fs13.existsSync(toolsIndexPath)) continue;
+    if (!fs14.existsSync(toolsIndexPath)) continue;
     try {
       const toolsModule = await import(toolsIndexPath);
       const moduleTools2 = toolsModule.tools || toolsModule.default?.tools || [];
@@ -2318,7 +2495,7 @@ async function handleModulesInfo(args2, storage2, cachedModules) {
 }
 
 // src/tools/modules-health.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as path13 from "path";
 async function handleModulesHealth(args2, storage2, cachedModules) {
   const modules = cachedModules ?? discoverModules(storage2);
@@ -2341,10 +2518,10 @@ async function handleModulesHealth(args2, storage2, cachedModules) {
 async function checkModule(mod, storage2) {
   const issues = [];
   const manifest = mod.manifest;
-  if (!fs14.existsSync(path13.join(mod.modulePath, "SKILL.md"))) {
+  if (!fs15.existsSync(path13.join(mod.modulePath, "SKILL.md"))) {
     issues.push("Missing SKILL.md (ecosystem entry point)");
   }
-  if (!fs14.existsSync(path13.join(mod.modulePath, "CLAUDE.base.md"))) {
+  if (!fs15.existsSync(path13.join(mod.modulePath, "CLAUDE.base.md"))) {
     issues.push("Missing CLAUDE.base.md (AI context)");
   }
   if (!manifest.manifest_version || manifest.manifest_version < 2) {
@@ -2361,7 +2538,7 @@ async function checkModule(mod, storage2) {
   const declaredTools = provides?.tools || [];
   if (declaredTools.length > 0) {
     const toolsIndex = path13.join(mod.modulePath, "tools", "index.js");
-    if (!fs14.existsSync(toolsIndex)) {
+    if (!fs15.existsSync(toolsIndex)) {
       issues.push(`Declares ${declaredTools.length} tools but tools/index.js not found`);
     } else {
       try {
@@ -2381,12 +2558,12 @@ async function checkModule(mod, storage2) {
   const suspectDirs = ["output", "data", "state"];
   for (const dir of suspectDirs) {
     const fullPath = path13.join(mod.modulePath, dir);
-    if (fs14.existsSync(fullPath) && fs14.statSync(fullPath).isDirectory()) {
+    if (fs15.existsSync(fullPath) && fs15.statSync(fullPath).isDirectory()) {
       issues.push(`Data dir '${dir}/' found in module code (should be in space data path)`);
     }
   }
   try {
-    const entries = fs14.readdirSync(mod.modulePath);
+    const entries = fs15.readdirSync(mod.modulePath);
     for (const entry of entries) {
       if (suspectExts.some((ext) => entry.endsWith(ext))) {
         issues.push(`Data file '${entry}' found in module code dir`);
@@ -2594,18 +2771,18 @@ async function handleBatchFeedback(signals, engramsPath, packsPath, service) {
 }
 
 // src/tools/session-start.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import * as path18 from "path";
 import * as crypto2 from "crypto";
 
 // src/engagement/service.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as path17 from "path";
 
 // src/engagement/profile.ts
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as path15 from "path";
-import * as yaml7 from "js-yaml";
+import * as yaml8 from "js-yaml";
 var PROFILE_DIR = "engagement";
 var PROFILE_FILE = "profile.yaml";
 function engagementDir(basePath) {
@@ -2619,16 +2796,16 @@ function createDefaultProfile() {
 }
 function loadProfile(basePath) {
   const filePath = profilePath(basePath);
-  if (!fs15.existsSync(filePath)) {
+  if (!fs16.existsSync(filePath)) {
     return createDefaultProfile();
   }
   try {
-    const raw = yaml7.load(fs15.readFileSync(filePath, "utf8"));
+    const raw = yaml8.load(fs16.readFileSync(filePath, "utf8"));
     return EngagementProfileSchema.parse(raw);
   } catch (err) {
     logger.warning(`Engagement profile corrupted, backing up and creating fresh: ${err}`);
     try {
-      fs15.copyFileSync(filePath, filePath + ".bak");
+      fs16.copyFileSync(filePath, filePath + ".bak");
     } catch {
     }
     return createDefaultProfile();
@@ -2636,33 +2813,33 @@ function loadProfile(basePath) {
 }
 function saveProfile(basePath, profile) {
   const dir = engagementDir(basePath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
   const filePath = profilePath(basePath);
-  const content = yaml7.dump(profile, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const content = yaml8.dump(profile, { lineWidth: 120, noRefs: true, quotingType: '"' });
   const tmpPath = filePath + ".tmp." + process.pid;
-  fs15.writeFileSync(tmpPath, content);
-  fs15.renameSync(tmpPath, filePath);
+  fs16.writeFileSync(tmpPath, content);
+  fs16.renameSync(tmpPath, filePath);
 }
 function ensureEngagementDir(basePath) {
   const dir = engagementDir(basePath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
   const gitignorePath = path15.join(basePath, ".datacore", ".gitignore");
-  if (fs15.existsSync(gitignorePath)) {
-    const content = fs15.readFileSync(gitignorePath, "utf8");
+  if (fs16.existsSync(gitignorePath)) {
+    const content = fs16.readFileSync(gitignorePath, "utf8");
     if (!content.includes("engagement/profile.yaml")) {
-      fs15.appendFileSync(gitignorePath, "\nengagement/profile.yaml\nengagement/badge.svg\n");
+      fs16.appendFileSync(gitignorePath, "\nengagement/profile.yaml\nengagement/badge.svg\n");
     }
   }
 }
 
 // src/engagement/actions.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as path16 from "path";
-import * as yaml8 from "js-yaml";
+import * as yaml9 from "js-yaml";
 var BUNDLED_ACTIONS = {
   version: 1,
   actions: {
@@ -2735,11 +2912,11 @@ var BUNDLED_ACTIONS = {
 };
 function loadActions(basePath) {
   const actionsPath = path16.join(basePath, ".datacore", "engagement", "xp-actions.yaml");
-  if (!fs16.existsSync(actionsPath)) {
+  if (!fs17.existsSync(actionsPath)) {
     return BUNDLED_ACTIONS;
   }
   try {
-    const raw = yaml8.load(fs16.readFileSync(actionsPath, "utf8"));
+    const raw = yaml9.load(fs17.readFileSync(actionsPath, "utf8"));
     return XPActionRegistrySchema.parse(raw);
   } catch (err) {
     logger.warning(`Malformed xp-actions.yaml, using defaults: ${err}`);
@@ -2749,12 +2926,12 @@ function loadActions(basePath) {
 function writeDefaultActions(basePath) {
   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 });
+  if (fs17.existsSync(actionsPath)) return;
+  if (!fs17.existsSync(dir)) {
+    fs17.mkdirSync(dir, { recursive: true });
   }
-  const content = yaml8.dump(BUNDLED_ACTIONS, { lineWidth: 120, noRefs: true, quotingType: '"' });
-  fs16.writeFileSync(actionsPath, content);
+  const content = yaml9.dump(BUNDLED_ACTIONS, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  fs17.writeFileSync(actionsPath, content);
 }
 
 // src/engagement/engine.ts
@@ -2996,9 +3173,9 @@ var EngagementService = class {
     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)) {
+    if (!fs18.existsSync(profilePath2)) {
+      const actualEngramsPath = fs18.existsSync(engramsPath) ? engramsPath : coreEngramsPath;
+      if (fs18.existsSync(actualEngramsPath)) {
         const engrams = loadEngrams(actualEngramsPath);
         if (engrams.length > 0) {
           this.profile = migrateProfile(this.basePath, engrams);
@@ -3444,21 +3621,29 @@ function dismissChallenge(profile, challengeId) {
 }
 
 // src/tools/session-start.ts
-async function handleSessionStart(args2, storage2, bridge, engagementService2) {
+async function handleSessionStart(args2, storage2, bridge, engagementService2, tracker) {
+  if (storage2.mode === "full") {
+    for (const dir of [storage2.archivePath, storage2.exchangeInboxPath, storage2.exchangeOutboxPath, storage2.statePath]) {
+      if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+    }
+  }
   const session_id = crypto2.randomUUID();
   let engrams = null;
   if (args2.task) {
     const injectResult = await handleInject(
       { prompt: args2.task, session_id, scope: args2.tags?.length ? `tags:${args2.tags.join(",")}` : void 0 },
-      { engramsPath: storage2.engramsPath, packsPath: storage2.packsPath, basePath: storage2.basePath }
+      { engramsPath: storage2.engramsPath, packsPath: storage2.packsPath, basePath: storage2.basePath, schemasPath: storage2.schemasPath }
     );
     if (injectResult.count > 0) {
       engrams = { text: injectResult.text, count: injectResult.count };
     }
+    if (tracker && injectResult.injected_personal_ids.length > 0) {
+      tracker.trackInjected(session_id, injectResult.injected_personal_ids);
+    }
   }
   const { date: today } = localDate();
   const journalFile = path18.join(storage2.journalPath, `${today}.md`);
-  const journal_today = fs18.existsSync(journalFile) ? fs18.readFileSync(journalFile, "utf8") : null;
+  const journal_today = fs19.existsSync(journalFile) ? fs19.readFileSync(journalFile, "utf8") : null;
   const allEngrams = loadEngrams(storage2.engramsPath);
   const pending_candidates = allEngrams.filter((e) => e.status === "candidate").length;
   const recommendations = [];
@@ -3578,7 +3763,14 @@ Positive feedback strengthens engrams. Unused ones naturally decay.`;
 var SESSION_GUIDE_SHORT = `Session started. Workflow: work \u2192 feedback \u2192 session.end.`;
 
 // src/tools/session-end.ts
-async function handleSessionEnd(args2, storage2, engagementService2) {
+async function handleSessionEnd(args2, storage2, engagementService2, tracker) {
+  if (args2.session_id && tracker) {
+    const pairs = tracker.getCoAccessPairs(args2.session_id);
+    if (pairs.length > 0) {
+      writeCoAccessAssociations(storage2.engramsPath, pairs);
+    }
+    tracker.clear(args2.session_id);
+  }
   const captureResult = await handleCapture(
     { type: "journal", content: args2.summary, tags: args2.tags },
     storage2
@@ -3622,6 +3814,43 @@ async function handleSessionEnd(args2, storage2, engagementService2) {
     })
   };
 }
+function writeCoAccessAssociations(engramsPath, pairs) {
+  const engrams = loadEngrams(engramsPath);
+  const map = new Map(engrams.map((e) => [e.id, e]));
+  const config = getConfig().co_access;
+  let changed = false;
+  for (const [idA, idB] of pairs) {
+    const a = map.get(idA);
+    const b = map.get(idB);
+    if (!a || !b || a.pack || b.pack) continue;
+    changed = strengthenCoAccess(a, idB, config) || changed;
+    changed = strengthenCoAccess(b, idA, config) || changed;
+  }
+  if (changed) {
+    atomicWriteYaml(engramsPath, { engrams });
+  }
+}
+function strengthenCoAccess(engram, targetId, config) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const existing = engram.associations.find(
+    (a) => a.target === targetId && a.type === "co_accessed"
+  );
+  if (existing) {
+    const newStrength = Math.min(existing.strength + config.increment, config.max_strength);
+    if (newStrength === existing.strength && existing.updated_at === today) return false;
+    existing.strength = newStrength;
+    existing.updated_at = today;
+    return true;
+  }
+  engram.associations.push({
+    target_type: "engram",
+    target: targetId,
+    strength: config.new_strength,
+    type: "co_accessed",
+    updated_at: today
+  });
+  return true;
+}
 
 // src/tools/recall.ts
 async function handleRecall(args2, storage2, bridge) {
@@ -3913,14 +4142,961 @@ function handleChallengeResolve(args2, service) {
   return { success: false, type: "challenge", action: args2.action, error: 'Invalid action. Must be "complete" or "dismiss".' };
 }
 
+// src/tools/schemas.ts
+import * as fs20 from "fs";
+
+// src/schema-detection.ts
+var MIN_STRENGTH = 0.4;
+var MIN_MEMBERS = 3;
+var MIN_SHARED_ANCHORS = 2;
+var K_CORE = 2;
+var MAX_EDGES = 1e4;
+var STALE_DAYS = 90;
+function detectSchemas(engrams, existing) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const engramMap = new Map(engrams.map((e) => [e.id, e]));
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const engram of engrams) {
+    if (engram.status !== "active") continue;
+    for (const assoc of engram.associations) {
+      if (assoc.target_type !== "engram") continue;
+      const target = engramMap.get(assoc.target);
+      if (!target || target.status !== "active") continue;
+      const effectiveStrength = assoc.type === "co_accessed" && assoc.updated_at ? decayedCoAccessStrength(assoc.strength, assoc.updated_at) : assoc.strength;
+      if (effectiveStrength < MIN_STRENGTH) continue;
+      if (!adjacency.has(engram.id)) adjacency.set(engram.id, /* @__PURE__ */ new Set());
+      if (!adjacency.has(assoc.target)) adjacency.set(assoc.target, /* @__PURE__ */ new Set());
+      adjacency.get(engram.id).add(assoc.target);
+      adjacency.get(assoc.target).add(engram.id);
+      const edgeKey = engram.id < assoc.target ? `${engram.id}:${assoc.target}` : `${assoc.target}:${engram.id}`;
+      seenEdges.add(edgeKey);
+    }
+  }
+  if (seenEdges.size > MAX_EDGES) {
+    return {
+      created: [],
+      updated: [],
+      flagged: [],
+      warning: `Association graph has ${seenEdges.size} edges (limit: ${MAX_EDGES}). Skipping detection to prevent performance issues.`
+    };
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [node, neighbors] of adjacency) {
+      if (neighbors.size < K_CORE) {
+        for (const neighbor of neighbors) {
+          adjacency.get(neighbor)?.delete(node);
+        }
+        adjacency.delete(node);
+        changed = true;
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const node of adjacency.keys()) {
+    if (visited.has(node)) continue;
+    const component = [];
+    const queue = [node];
+    visited.add(node);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      component.push(current);
+      for (const neighbor of adjacency.get(current) ?? []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    components.push(component);
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const created = [];
+  const updated = [];
+  for (const component of components) {
+    if (component.length < MIN_MEMBERS) continue;
+    const anchorCounts = /* @__PURE__ */ new Map();
+    for (const id of component) {
+      const engram = engramMap.get(id);
+      if (!engram) continue;
+      for (const anchor of engram.knowledge_anchors) {
+        anchorCounts.set(anchor.path, (anchorCounts.get(anchor.path) ?? 0) + 1);
+      }
+    }
+    const sharedAnchors = Array.from(anchorCounts.entries()).filter(([, count]) => count >= 2).map(([path23]) => path23);
+    if (sharedAnchors.length < MIN_SHARED_ANCHORS) continue;
+    const memberScore = Math.min(component.length / 10, 1);
+    const anchorScore = Math.min(sharedAnchors.length / 5, 1);
+    let totalStrength = 0;
+    let edgePairs = 0;
+    for (const id of component) {
+      const neighbors = adjacency.get(id) ?? /* @__PURE__ */ new Set();
+      for (const neighbor of neighbors) {
+        if (component.includes(neighbor)) {
+          totalStrength += getMaxStrength(engramMap.get(id), neighbor, engramMap);
+          edgePairs++;
+        }
+      }
+    }
+    const avgStrength = edgePairs > 0 ? totalStrength / edgePairs : 0;
+    const confidence = Math.round(memberScore * anchorScore * avgStrength * 1e3) / 1e3;
+    const componentSet = new Set(component);
+    let matched = false;
+    for (const schema of existing) {
+      if (schema.status === "archived") continue;
+      const schemaSet = new Set(schema.members);
+      const intersection = component.filter((id) => schemaSet.has(id)).length;
+      const union = (/* @__PURE__ */ new Set([...component, ...schema.members])).size;
+      const jaccard = intersection / union;
+      if (jaccard >= 0.5) {
+        updated.push({
+          ...schema,
+          members: component.sort(),
+          shared_anchors: sharedAnchors,
+          confidence,
+          updated: today
+        });
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      const allExisting = [...existing, ...created];
+      created.push({
+        id: generateSchemaId(allExisting),
+        name: `Schema from ${component.length} engrams`,
+        members: component.sort(),
+        confidence,
+        status: "candidate",
+        shared_anchors: sharedAnchors,
+        created: today,
+        updated: today
+      });
+    }
+  }
+  const flagged = [];
+  const staleDate = /* @__PURE__ */ new Date();
+  staleDate.setDate(staleDate.getDate() - STALE_DAYS);
+  const staleDateStr = staleDate.toISOString().split("T")[0];
+  for (const schema of existing) {
+    if (schema.status === "archived") continue;
+    if (schema.updated < staleDateStr) {
+      flagged.push(schema);
+    }
+  }
+  return { created, updated, flagged };
+}
+function getMaxStrength(engram, targetId, engramMap) {
+  let max = 0;
+  for (const assoc of engram.associations) {
+    if (assoc.target === targetId) {
+      const effective = assoc.type === "co_accessed" && assoc.updated_at ? decayedCoAccessStrength(assoc.strength, assoc.updated_at) : assoc.strength;
+      if (effective > max) max = effective;
+    }
+  }
+  const target = engramMap.get(targetId);
+  if (target) {
+    for (const assoc of target.associations) {
+      if (assoc.target === engram.id) {
+        const effective = assoc.type === "co_accessed" && assoc.updated_at ? decayedCoAccessStrength(assoc.strength, assoc.updated_at) : assoc.strength;
+        if (effective > max) max = effective;
+      }
+    }
+  }
+  return max;
+}
+
+// src/tools/schemas.ts
+async function handleSchemas(args2, paths) {
+  switch (args2.action) {
+    case "list":
+      return listSchemas(paths.schemasPath);
+    case "detect":
+      return detectAction(paths);
+    case "activate":
+      return setStatus(paths.schemasPath, args2.id, "active");
+    case "archive":
+      return setStatus(paths.schemasPath, args2.id, "archived");
+    case "merge":
+      return mergeSchemas(paths.schemasPath, args2.id, args2.target_id);
+    case "split":
+      return splitSchema(paths.schemasPath, args2.id, args2.member_ids, args2.name);
+    case "migrate":
+      return migrateRelations(paths.engramsPath, args2.confirm);
+    default:
+      throw new Error(`Unknown schemas action: ${args2.action}`);
+  }
+}
+function listSchemas(schemasPath) {
+  const schemas = loadSchemas(schemasPath);
+  return {
+    schemas: schemas.map((s) => ({
+      id: s.id,
+      name: s.name,
+      status: s.status,
+      members: s.members.length,
+      confidence: s.confidence,
+      shared_anchors: s.shared_anchors.length,
+      updated: s.updated
+    })),
+    total: schemas.length,
+    _hints: buildHints({
+      next: schemas.length === 0 ? 'No schemas yet. Use action="detect" to discover schemas from association graph.' : 'Use action="detect" to update schemas from current associations.',
+      related: ["datacore.schemas"]
+    })
+  };
+}
+function detectAction(paths) {
+  const engrams = loadEngrams(paths.engramsPath);
+  const existing = loadSchemas(paths.schemasPath);
+  const result = detectSchemas(engrams, existing);
+  if (result.warning) {
+    return { warning: result.warning, created: 0, updated: 0, flagged: 0 };
+  }
+  const updatedIds = new Set(result.updated.map((s) => s.id));
+  const final = [
+    ...existing.filter((s) => !updatedIds.has(s.id)),
+    ...result.updated,
+    ...result.created
+  ];
+  const dir = paths.schemasPath.substring(0, paths.schemasPath.lastIndexOf("/"));
+  if (dir && !fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
+  saveSchemas(paths.schemasPath, final);
+  return {
+    created: result.created.length,
+    updated: result.updated.length,
+    flagged: result.flagged.length,
+    flagged_ids: result.flagged.map((s) => s.id),
+    total: final.length,
+    _hints: buildHints({
+      next: result.created.length > 0 ? `${result.created.length} new candidate schema(s) found. Use action="activate" to promote.` : "Schema detection complete.",
+      related: ["datacore.schemas"]
+    })
+  };
+}
+function setStatus(schemasPath, id, newStatus) {
+  const schemas = loadSchemas(schemasPath);
+  const schema = schemas.find((s) => s.id === id);
+  if (!schema) throw new Error(`Schema not found: ${id}`);
+  schema.status = newStatus;
+  schema.updated = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  saveSchemas(schemasPath, schemas);
+  return {
+    id: schema.id,
+    status: newStatus,
+    _hints: buildHints({ next: `Schema ${id} is now ${newStatus}.`, related: ["datacore.schemas"] })
+  };
+}
+function mergeSchemas(schemasPath, sourceId, targetId) {
+  const schemas = loadSchemas(schemasPath);
+  const source = schemas.find((s) => s.id === sourceId);
+  const target = schemas.find((s) => s.id === targetId);
+  if (!source) throw new Error(`Source schema not found: ${sourceId}`);
+  if (!target) throw new Error(`Target schema not found: ${targetId}`);
+  const memberSet = /* @__PURE__ */ new Set([...target.members, ...source.members]);
+  target.members = Array.from(memberSet).sort();
+  const anchorSet = /* @__PURE__ */ new Set([...target.shared_anchors, ...source.shared_anchors]);
+  target.shared_anchors = Array.from(anchorSet);
+  target.confidence = Math.max(target.confidence, source.confidence);
+  const statusOrder = { archived: 0, candidate: 1, active: 2, consolidated: 3 };
+  if (statusOrder[source.status] > statusOrder[target.status]) {
+    target.status = source.status;
+  }
+  target.updated = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  source.status = "archived";
+  source.updated = target.updated;
+  saveSchemas(schemasPath, schemas);
+  return {
+    merged_into: target.id,
+    archived: source.id,
+    members: target.members.length,
+    _hints: buildHints({ next: `Merged ${sourceId} into ${targetId}.`, related: ["datacore.schemas"] })
+  };
+}
+function splitSchema(schemasPath, id, memberIds, name) {
+  const schemas = loadSchemas(schemasPath);
+  const schema = schemas.find((s) => s.id === id);
+  if (!schema) throw new Error(`Schema not found: ${id}`);
+  const schemaMembers = new Set(schema.members);
+  for (const memberId of memberIds) {
+    if (!schemaMembers.has(memberId)) throw new Error(`${memberId} is not a member of ${id}`);
+  }
+  schema.members = schema.members.filter((m) => !memberIds.includes(m));
+  schema.updated = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const newSchema = {
+    id: generateSchemaId(schemas),
+    name: name ?? `Split from ${schema.name}`,
+    members: memberIds.sort(),
+    confidence: schema.confidence * 0.8,
+    status: "candidate",
+    shared_anchors: [],
+    created: schema.updated,
+    updated: schema.updated
+  };
+  schemas.push(newSchema);
+  saveSchemas(schemasPath, schemas);
+  return {
+    original: { id: schema.id, remaining_members: schema.members.length },
+    new_schema: { id: newSchema.id, members: newSchema.members.length },
+    _hints: buildHints({ next: `Split complete. New schema: ${newSchema.id}`, related: ["datacore.schemas"] })
+  };
+}
+function migrateRelations(engramsPath, confirm) {
+  const engrams = loadEngrams(engramsPath);
+  let migratedCount = 0;
+  let totalAssociations = 0;
+  for (const engram of engrams) {
+    if (engram.pack) continue;
+    if (!engram.relations) continue;
+    const converted = flattenRelations(engram);
+    if (converted.length === 0) continue;
+    if (confirm) {
+      const existingTargets = new Set(engram.associations.map((a) => `${a.target}:${a.type}`));
+      for (const assoc of converted) {
+        const key = `${assoc.target}:${assoc.type}`;
+        if (!existingTargets.has(key)) {
+          engram.associations.push(assoc);
+          totalAssociations++;
+        }
+      }
+      delete engram.relations;
+      migratedCount++;
+    } else {
+      migratedCount++;
+      totalAssociations += converted.length;
+    }
+  }
+  if (confirm && migratedCount > 0) {
+    atomicWriteYaml(engramsPath, { engrams });
+  }
+  return {
+    action: confirm ? "executed" : "preview",
+    engrams_with_relations: migratedCount,
+    associations_created: totalAssociations,
+    _hints: buildHints({
+      next: confirm ? `Migrated ${migratedCount} engram(s) from relations to associations.` : `Preview: ${migratedCount} engram(s) to migrate. Set confirm=true to execute.`,
+      related: ["datacore.schemas"]
+    })
+  };
+}
+
+// src/tools/exchange.ts
+import * as fs21 from "fs";
+import * as path19 from "path";
+import * as yaml10 from "js-yaml";
+
+// src/exchange.ts
+import { z as z6 } from "zod";
+var LEPEngramSchema = z6.object({
+  id: z6.string(),
+  type: z6.enum(["behavioral", "terminological", "procedural", "architectural"]),
+  scope: z6.string(),
+  statement: z6.string(),
+  rationale: z6.string().optional(),
+  domain: z6.string().optional(),
+  tags: z6.array(z6.string()).default([]),
+  fitness: z6.number().min(0).max(1),
+  provenance: z6.object({
+    origin: z6.string(),
+    chain: z6.array(z6.string()).default([])
+  }).optional()
+});
+var LEPPacketSchema = z6.object({
+  id: z6.string(),
+  sender: z6.string(),
+  signature: z6.string().nullable().default(null),
+  created: z6.string(),
+  engrams: z6.array(LEPEngramSchema)
+});
+function calculateFitness(engram, allEngrams) {
+  const adoptionCount = engram.derivation_count;
+  const adoptionBase = Math.min(Math.log2(adoptionCount + 1) / 6, 1);
+  const associatedScopes = /* @__PURE__ */ new Set();
+  for (const assoc of engram.associations) {
+    if (assoc.target_type !== "engram") continue;
+    const target = allEngrams.find((e) => e.id === assoc.target);
+    if (target) {
+      const prefix = target.scope.split(":")[0];
+      associatedScopes.add(prefix);
+    }
+  }
+  const envDiversity = Math.max(associatedScopes.size, 1);
+  const envDiversityNorm = Math.min(envDiversity / 5, 1);
+  const adoptionScore = adoptionBase * envDiversityNorm * 0.4;
+  const rsScore = engram.activation.retrieval_strength * 0.3;
+  const createdDate = parseEngramDate(engram.id);
+  const ageDays = createdDate ? Math.max(0, (Date.now() - createdDate.getTime()) / 864e5) : 0;
+  const ageScore = Math.min(Math.log(ageDays + 1) / 7, 1) * 0.2;
+  const feedback = engram.feedback_signals;
+  const totalFeedback = feedback ? feedback.positive + feedback.negative + feedback.neutral : 0;
+  const contradictionRate = totalFeedback > 0 && feedback ? feedback.negative / totalFeedback : 0;
+  const contradictionScore = (1 - contradictionRate) * 0.1;
+  return Math.round((adoptionScore + rsScore + ageScore + contradictionScore) * 1e3) / 1e3;
+}
+function parseEngramDate(id) {
+  const match = id.match(/^ENG-(\d{4})-(\d{4})-/);
+  if (!match) return null;
+  const year = match[1];
+  const mmdd = match[2];
+  const month = mmdd.slice(0, 2);
+  const day = mmdd.slice(2, 4);
+  return /* @__PURE__ */ new Date(`${year}-${month}-${day}`);
+}
+function createLEPPacket(engrams, allEngrams, sender) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const id = `LEP-${today.replace(/-/g, "").slice(0, 4)}-${today.replace(/-/g, "").slice(4)}-${String(Date.now()).slice(-3)}`;
+  const lepEngrams = engrams.filter((e) => e.visibility === "public" || e.visibility === "template").map((e) => ({
+    id: e.id,
+    type: e.type,
+    scope: e.scope,
+    statement: e.statement,
+    rationale: e.rationale,
+    domain: e.domain,
+    tags: e.tags,
+    fitness: calculateFitness(e, allEngrams),
+    provenance: {
+      origin: sender,
+      chain: [id]
+    }
+  }));
+  return { id, sender, signature: null, created: today, engrams: lepEngrams };
+}
+function validateLEPPacket(raw) {
+  return LEPPacketSchema.parse(raw);
+}
+function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: n + 1 }, (_, i) => i);
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const tmp = dp[j];
+      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = tmp;
+    }
+  }
+  return dp[n];
+}
+function normalizeStatement(s) {
+  return s.toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function importLEPEngrams(packet, existing, config = {}) {
+  const sourceCapPercent = config.sourceCapPercent ?? 0.2;
+  const fitnessThreshold = config.fitnessThreshold ?? 0.3;
+  const personalCount = existing.filter((e) => !e.pack).length;
+  if (personalCount > 0) {
+    const fromSender = existing.filter((e) => e.provenance?.origin === packet.sender).length;
+    if (fromSender / personalCount > sourceCapPercent) {
+      return {
+        imported: 0,
+        skipped_fitness: 0,
+        skipped_duplicate: 0,
+        skipped_source_cap: true,
+        candidates: []
+      };
+    }
+  }
+  const existingNormalized = existing.map((e) => normalizeStatement(e.statement));
+  let skippedFitness = 0;
+  let skippedDuplicate = 0;
+  const candidates = [];
+  const now = /* @__PURE__ */ new Date();
+  const today = now.toISOString().split("T")[0];
+  const trialExpiry = new Date(now);
+  trialExpiry.setDate(trialExpiry.getDate() + 30);
+  const trialExpiryTag = `_trial_expires:${trialExpiry.toISOString().split("T")[0]}`;
+  for (const lepEngram of packet.engrams) {
+    if (lepEngram.fitness < fitnessThreshold) {
+      skippedFitness++;
+      continue;
+    }
+    const normalized = normalizeStatement(lepEngram.statement);
+    let isDuplicate = false;
+    for (const existingNorm of existingNormalized) {
+      const dist = levenshteinDistance(normalized, existingNorm);
+      const maxLen = Math.max(normalized.length, existingNorm.length);
+      if (maxLen > 0 && dist / maxLen < 0.15) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (isDuplicate) {
+      skippedDuplicate++;
+      continue;
+    }
+    const newId = generateEngramId(existing);
+    candidates.push({
+      id: newId,
+      statement: lepEngram.statement,
+      fitness: lepEngram.fitness
+    });
+    const newEngram = {
+      id: newId,
+      version: 2,
+      status: "candidate",
+      consolidated: false,
+      type: lepEngram.type,
+      scope: lepEngram.scope,
+      visibility: "private",
+      statement: lepEngram.statement,
+      rationale: lepEngram.rationale,
+      derivation_count: 1,
+      domain: lepEngram.domain,
+      knowledge_anchors: [],
+      associations: [],
+      tags: [...lepEngram.tags, "_trial", trialExpiryTag],
+      activation: {
+        retrieval_strength: 0.5,
+        storage_strength: 0.3,
+        frequency: 0,
+        last_accessed: today
+      },
+      pack: packet.id,
+      abstract: null,
+      derived_from: lepEngram.id,
+      provenance: {
+        origin: lepEngram.provenance?.origin ?? packet.sender,
+        chain: [...lepEngram.provenance?.chain ?? [], packet.id],
+        signature: null,
+        license: "cc-by-sa-4.0"
+      }
+    };
+    existing.push(newEngram);
+    existingNormalized.push(normalized);
+  }
+  return {
+    imported: candidates.length,
+    skipped_fitness: skippedFitness,
+    skipped_duplicate: skippedDuplicate,
+    skipped_source_cap: false,
+    candidates
+  };
+}
+
+// src/tools/exchange.ts
+async function handleExchange(args2, paths, engagementService2) {
+  switch (args2.action) {
+    case "export":
+      return exportAction(args2, paths, engagementService2);
+    case "import":
+      return importAction(args2, paths);
+    case "status":
+      return statusAction(paths);
+    default:
+      throw new Error(`Unknown exchange action: ${args2.action}`);
+  }
+}
+async function exportAction(args2, paths, engagementService2) {
+  const allEngrams = loadEngrams(paths.engramsPath);
+  const sender = args2.sender ?? "anonymous";
+  let candidates = allEngrams.filter(
+    (e) => !e.pack && e.status === "active" && (e.visibility === "public" || e.visibility === "template")
+  );
+  if (args2.engram_ids?.length) {
+    const idSet = new Set(args2.engram_ids);
+    candidates = candidates.filter((e) => idSet.has(e.id));
+  }
+  if (args2.filter_domain) {
+    candidates = candidates.filter((e) => e.domain?.startsWith(args2.filter_domain));
+  }
+  if (candidates.length === 0) {
+    return {
+      exported: 0,
+      message: "No eligible engrams found. Only public/template visibility engrams can be exported.",
+      _hints: buildHints({ next: "Set visibility to public or template on engrams you want to share.", related: ["datacore.learn"] })
+    };
+  }
+  const packet = createLEPPacket(candidates, allEngrams, sender);
+  fs21.mkdirSync(paths.exchangeOutboxPath, { recursive: true });
+  const outPath = path19.join(paths.exchangeOutboxPath, `${packet.id}.yaml`);
+  fs21.writeFileSync(outPath, yaml10.dump(packet, { lineWidth: 120, noRefs: true, quotingType: '"' }));
+  if (engagementService2?.isEnabled()) {
+    try {
+      await engagementService2.award("pack_exported", { count: packet.engrams.length });
+    } catch {
+    }
+  }
+  return {
+    exported: packet.engrams.length,
+    packet_id: packet.id,
+    path: outPath,
+    _hints: buildHints({ next: `Exported ${packet.engrams.length} engram(s) to ${outPath}`, related: ["datacore.exchange"] })
+  };
+}
+async function importAction(args2, paths) {
+  if (!args2.path) throw new Error("path is required for import action");
+  if (!fs21.existsSync(args2.path)) throw new Error(`File not found: ${args2.path}`);
+  const raw = yaml10.load(fs21.readFileSync(args2.path, "utf8"));
+  const packet = validateLEPPacket(raw);
+  const existing = loadEngrams(paths.engramsPath);
+  const result = importLEPEngrams(packet, existing, {
+    fitnessThreshold: args2.fitness_threshold,
+    sourceCapPercent: args2.source_cap_percent
+  });
+  if (result.skipped_source_cap) {
+    return {
+      imported: 0,
+      message: `Source cap exceeded: too many engrams already from ${packet.sender}.`,
+      _hints: buildHints({ next: "Remove some imported engrams from this source first.", related: ["datacore.forget"] })
+    };
+  }
+  if (args2.confirm && result.imported > 0) {
+    saveEngrams(paths.engramsPath, existing);
+    return {
+      imported: result.imported,
+      skipped_fitness: result.skipped_fitness,
+      skipped_duplicate: result.skipped_duplicate,
+      candidates: result.candidates,
+      _hints: buildHints({
+        next: `Imported ${result.imported} engram(s) as candidates. Use datacore.promote to activate.`,
+        related: ["datacore.promote"]
+      })
+    };
+  }
+  return {
+    action: "preview",
+    would_import: result.imported,
+    skipped_fitness: result.skipped_fitness,
+    skipped_duplicate: result.skipped_duplicate,
+    candidates: result.candidates,
+    _hints: buildHints({
+      next: result.imported > 0 ? `Preview: ${result.imported} engram(s) would be imported. Set confirm=true to execute.` : "No engrams passed fitness and duplicate filters.",
+      related: ["datacore.exchange"]
+    })
+  };
+}
+function statusAction(paths) {
+  const inboxCount = countYamlFiles(paths.exchangeInboxPath);
+  const outboxCount = countYamlFiles(paths.exchangeOutboxPath);
+  return {
+    inbox: inboxCount,
+    outbox: outboxCount,
+    _hints: buildHints({
+      next: inboxCount > 0 ? `${inboxCount} packet(s) in inbox. Use action="import" with path to process.` : "No packets in inbox.",
+      related: ["datacore.exchange"]
+    })
+  };
+}
+function countYamlFiles(dir) {
+  if (!fs21.existsSync(dir)) return 0;
+  return fs21.readdirSync(dir).filter((f) => f.endsWith(".yaml")).length;
+}
+
+// src/knowledge-surfacing.ts
+import * as fs22 from "fs";
+import * as path20 from "path";
+import * as yaml11 from "js-yaml";
+import { z as z7 } from "zod";
+var ZettelCandidateSchema = z7.object({
+  path: z7.string(),
+  title: z7.string(),
+  suggested_statement: z7.string(),
+  suggested_type: z7.enum(["behavioral", "terminological", "procedural", "architectural"]),
+  suggested_scope: z7.string(),
+  suggested_anchors: z7.array(z7.string()),
+  confidence: z7.number().min(0).max(1),
+  status: z7.enum(["pending", "accepted", "rejected"]),
+  created: z7.string()
+});
+var defaultState = {
+  last_zettel_scan: null,
+  scanned_paths: [],
+  zettel_candidates: [],
+  last_consolidation: null,
+  consolidation_results: null
+};
+function loadKnowledgeSurfacing(filePath) {
+  if (!fs22.existsSync(filePath)) return { ...defaultState };
+  try {
+    const raw = yaml11.load(fs22.readFileSync(filePath, "utf8"));
+    return { ...defaultState, ...raw };
+  } catch {
+    return { ...defaultState };
+  }
+}
+function saveKnowledgeSurfacing(filePath, state) {
+  const dir = path20.dirname(filePath);
+  if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
+  const content = yaml11.dump(state, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const tmpPath = filePath + ".tmp." + process.pid;
+  fs22.writeFileSync(tmpPath, content);
+  fs22.renameSync(tmpPath, filePath);
+}
+var ACTIONABLE_WORDS = /\b(should|always|never|when|before|after|must|avoid|prefer|ensure|make sure)\b/i;
+var PROCEDURAL_PATTERNS = /(\d+\.\s|\bhow to\b|step \d+)/i;
+var DECISION_PATTERNS = /\b(because|due to|trade-?off|we chose|decided|rationale)\b/i;
+function scanZettels(knowledgePath, state) {
+  const zettelDir = path20.join(knowledgePath, "zettel");
+  if (!fs22.existsSync(zettelDir)) return [];
+  const scannedSet = new Set(state.scanned_paths);
+  const candidates = [];
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const files = globMd(zettelDir);
+  for (const filePath of files) {
+    const relativePath = path20.relative(path20.dirname(knowledgePath), filePath);
+    if (scannedSet.has(relativePath)) continue;
+    const content = fs22.readFileSync(filePath, "utf8");
+    const candidate = analyzeZettel(content, relativePath, today);
+    if (candidate) candidates.push(candidate);
+    state.scanned_paths.push(relativePath);
+  }
+  state.last_zettel_scan = today;
+  return candidates;
+}
+function globMd(dir) {
+  const results = [];
+  if (!fs22.existsSync(dir)) return results;
+  for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
+    const full = path20.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...globMd(full));
+    } else if (entry.name.endsWith(".md")) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function analyzeZettel(content, relativePath, today) {
+  const lines = content.split("\n");
+  const title = extractTitle2(lines) ?? path20.basename(relativePath, ".md");
+  const hasActionable = ACTIONABLE_WORDS.test(content);
+  const hasProcedural = PROCEDURAL_PATTERNS.test(content);
+  const hasDecision = DECISION_PATTERNS.test(content);
+  if (!hasActionable && !hasProcedural && !hasDecision) return null;
+  let type = "behavioral";
+  if (hasProcedural) type = "procedural";
+  else if (hasDecision) type = "architectural";
+  let confidence = 0.4;
+  if (hasActionable) confidence += 0.3;
+  if (hasProcedural || hasDecision) confidence += 0.1;
+  confidence = Math.min(confidence, 1);
+  if (confidence < 0.4) return null;
+  const statement = extractActionableSentence(content) ?? `${title}: ${firstParagraph(content)}`;
+  return {
+    path: relativePath,
+    title,
+    suggested_statement: statement.slice(0, 300),
+    suggested_type: type,
+    suggested_scope: "global",
+    suggested_anchors: [relativePath],
+    confidence: Math.round(confidence * 100) / 100,
+    status: "pending",
+    created: today
+  };
+}
+function extractTitle2(lines) {
+  for (const line of lines) {
+    if (line.startsWith("# ")) return line.slice(2).trim();
+  }
+  return null;
+}
+function extractActionableSentence(content) {
+  const sentences = content.split(/(?<=[.!?])\s+/);
+  for (const sentence of sentences) {
+    if (ACTIONABLE_WORDS.test(sentence) && sentence.length > 20) {
+      return sentence.replace(/^[-*#>\s]+/, "").trim();
+    }
+  }
+  return null;
+}
+function firstParagraph(content) {
+  const lines = content.split("\n");
+  const para = [];
+  let started = false;
+  for (const line of lines) {
+    if (line.startsWith("#")) continue;
+    if (line.trim() === "") {
+      if (started) break;
+      continue;
+    }
+    started = true;
+    para.push(line.trim());
+  }
+  return para.join(" ").slice(0, 200);
+}
+function normalizeStatement2(s) {
+  return s.toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function consolidationPass(engramsPath, confirm = false) {
+  const engrams = loadEngrams(engramsPath);
+  const active = engrams.filter((e) => e.status === "active" && !e.pack);
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+  const thirtyDaysAgoStr = thirtyDaysAgo.toISOString().split("T")[0];
+  const lowRs = active.filter(
+    (e) => e.activation.retrieval_strength < 0.15 && e.activation.last_accessed < thirtyDaysAgoStr
+  ).map((e) => ({
+    id: e.id,
+    rs: e.activation.retrieval_strength,
+    last_accessed: e.activation.last_accessed
+  }));
+  const normalized = active.map((e) => ({
+    id: e.id,
+    norm: normalizeStatement2(e.statement),
+    rs: e.activation.retrieval_strength
+  }));
+  const parent = /* @__PURE__ */ new Map();
+  const find = (x) => {
+    let root = x;
+    while (parent.has(root) && parent.get(root) !== root) root = parent.get(root);
+    let curr = x;
+    while (curr !== root) {
+      const next = parent.get(curr) ?? curr;
+      parent.set(curr, root);
+      curr = next;
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  for (const item of normalized) parent.set(item.id, item.id);
+  for (let i = 0; i < normalized.length; i++) {
+    for (let j = i + 1; j < normalized.length; j++) {
+      const a = normalized[i];
+      const b = normalized[j];
+      const maxLen = Math.max(a.norm.length, b.norm.length);
+      if (maxLen === 0) continue;
+      const dist = levenshteinDistance(a.norm, b.norm);
+      if (dist / maxLen < 0.3) {
+        union(a.id, b.id);
+      }
+    }
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  for (const item of normalized) {
+    const root = find(item.id);
+    if (!clusters.has(root)) clusters.set(root, []);
+    clusters.get(root).push(item.id);
+  }
+  const duplicateClusters = [];
+  for (const [, members] of clusters) {
+    if (members.length < 2) continue;
+    const sorted = members.map((id) => ({ id, rs: normalized.find((n) => n.id === id).rs })).sort((a, b) => b.rs - a.rs);
+    duplicateClusters.push({
+      representative: sorted[0].id,
+      duplicates: sorted.slice(1).map((s) => s.id),
+      similarity: 0.7
+      // approximate
+    });
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  if (confirm) {
+    const toRetire = /* @__PURE__ */ new Set([
+      ...lowRs.map((e) => e.id),
+      ...duplicateClusters.flatMap((c) => c.duplicates)
+    ]);
+    for (const engram of engrams) {
+      if (toRetire.has(engram.id)) {
+        engram.status = "retired";
+      }
+    }
+    for (const cluster of duplicateClusters) {
+      const rep = engrams.find((e) => e.id === cluster.representative);
+      if (rep) rep.derivation_count += cluster.duplicates.length;
+    }
+    if (toRetire.size > 0) {
+      const content = yaml11.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+      const tmpPath = engramsPath + ".tmp." + process.pid;
+      fs22.writeFileSync(tmpPath, content);
+      fs22.renameSync(tmpPath, engramsPath);
+    }
+  }
+  return {
+    low_rs_engrams: lowRs,
+    duplicate_clusters: duplicateClusters,
+    action_taken: confirm ? "executed" : "preview",
+    executed_at: confirm ? today : null
+  };
+}
+
+// src/tools/knowledge-scan.ts
+async function handleKnowledgeScan(args2, paths) {
+  switch (args2.action) {
+    case "scan_zettels":
+      return scanZettelsAction(paths);
+    case "scan_status":
+      return scanStatusAction(paths.knowledgeSurfacingPath);
+    case "consolidation_pass":
+      return consolidationAction(paths, args2.confirm);
+    default:
+      throw new Error(`Unknown knowledge.scan action: ${args2.action}`);
+  }
+}
+function scanZettelsAction(paths) {
+  const state = loadKnowledgeSurfacing(paths.knowledgeSurfacingPath);
+  const candidates = scanZettels(paths.knowledgePath, state);
+  state.zettel_candidates.push(...candidates);
+  saveKnowledgeSurfacing(paths.knowledgeSurfacingPath, state);
+  return {
+    new_candidates: candidates.length,
+    total_scanned: state.scanned_paths.length,
+    total_pending: state.zettel_candidates.filter((c) => c.status === "pending").length,
+    candidates: candidates.map((c) => ({
+      path: c.path,
+      title: c.title,
+      suggested_statement: c.suggested_statement,
+      suggested_type: c.suggested_type,
+      confidence: c.confidence
+    })),
+    _hints: buildHints({
+      next: candidates.length > 0 ? `Found ${candidates.length} zettel-to-engram candidate(s). Review and use datacore.learn to create engrams.` : "No new candidates found.",
+      related: ["datacore.learn", "datacore.knowledge.scan"]
+    })
+  };
+}
+function scanStatusAction(surfacingPath) {
+  const state = loadKnowledgeSurfacing(surfacingPath);
+  const pending = state.zettel_candidates.filter((c) => c.status === "pending").length;
+  const accepted = state.zettel_candidates.filter((c) => c.status === "accepted").length;
+  const rejected = state.zettel_candidates.filter((c) => c.status === "rejected").length;
+  return {
+    last_scan: state.last_zettel_scan,
+    scanned_paths: state.scanned_paths.length,
+    candidates: { pending, accepted, rejected, total: state.zettel_candidates.length },
+    last_consolidation: state.last_consolidation,
+    _hints: buildHints({
+      next: pending > 0 ? `${pending} pending candidate(s). Use scan_zettels to find more, or review candidates.` : "All candidates processed.",
+      related: ["datacore.knowledge.scan"]
+    })
+  };
+}
+function consolidationAction(paths, confirm) {
+  const result = consolidationPass(paths.engramsPath, confirm ?? false);
+  const state = loadKnowledgeSurfacing(paths.knowledgeSurfacingPath);
+  state.last_consolidation = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  state.consolidation_results = result;
+  saveKnowledgeSurfacing(paths.knowledgeSurfacingPath, state);
+  return {
+    low_rs_count: result.low_rs_engrams.length,
+    duplicate_clusters: result.duplicate_clusters.length,
+    action: result.action_taken,
+    low_rs_engrams: result.low_rs_engrams.slice(0, 10),
+    clusters: result.duplicate_clusters.slice(0, 5).map((c) => ({
+      representative: c.representative,
+      duplicates: c.duplicates.length
+    })),
+    _hints: buildHints({
+      next: result.action_taken === "preview" ? `Preview: ${result.low_rs_engrams.length} low-RS + ${result.duplicate_clusters.length} duplicate cluster(s). Set confirm=true to execute.` : `Consolidated: retired ${result.low_rs_engrams.length + result.duplicate_clusters.flatMap((c) => c.duplicates).length} engram(s).`,
+      related: ["datacore.knowledge.scan"]
+    })
+  };
+}
+
 // src/resources.ts
 import {
   ListResourcesRequestSchema,
   ReadResourceRequestSchema,
   ListResourceTemplatesRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import * as fs19 from "fs";
-import * as path19 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 function registerResources(server, storage2) {
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
@@ -4001,11 +5177,11 @@ function registerResources(server, storage2) {
     const journalMatch = uri.match(/^datacore:\/\/journal\/(.+)$/);
     if (journalMatch) {
       const dateStr = journalMatch[1] === "today" ? localDate().date : journalMatch[1];
-      const filePath = path19.join(storage2.journalPath, `${dateStr}.md`);
-      if (!fs19.existsSync(filePath)) {
+      const filePath = path21.join(storage2.journalPath, `${dateStr}.md`);
+      if (!fs23.existsSync(filePath)) {
         return { contents: [{ uri, mimeType: "text/markdown", text: `No journal entry for ${dateStr}` }] };
       }
-      return { contents: [{ uri, mimeType: "text/markdown", text: fs19.readFileSync(filePath, "utf8") }] };
+      return { contents: [{ uri, mimeType: "text/markdown", text: fs23.readFileSync(filePath, "utf8") }] };
     }
     const engramMatch = uri.match(/^datacore:\/\/engrams\/(.+)$/);
     if (engramMatch) {
@@ -4251,8 +5427,8 @@ function registerPrompts(server) {
 
 // src/datacortex.ts
 import { execFile } from "child_process";
-import * as fs20 from "fs";
-import * as path20 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 var DatacortexBridge = class {
   pythonPath;
   scriptPath;
@@ -4262,11 +5438,11 @@ var DatacortexBridge = class {
   }
   findBridgeScript(datacorePath) {
     const candidates = [
-      path20.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
-      path20.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
+      path22.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
+      path22.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
     ];
     for (const candidate of candidates) {
-      if (fs20.existsSync(candidate)) return candidate;
+      if (fs24.existsSync(candidate)) return candidate;
     }
     return null;
   }
@@ -4318,6 +5494,44 @@ var DatacortexBridge = class {
   }
 };
 
+// src/session-tracker.ts
+var SessionTracker = class {
+  sessions = /* @__PURE__ */ new Map();
+  trackInjected(sessionId, engramIds) {
+    if (!sessionId || engramIds.length === 0) return;
+    let set = this.sessions.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.sessions.set(sessionId, set);
+    }
+    for (const id of engramIds) {
+      set.add(id);
+    }
+  }
+  getCoAccessPairs(sessionId) {
+    const set = this.sessions.get(sessionId);
+    if (!set || set.size < 2) return [];
+    const ids = Array.from(set).sort();
+    const pairs = [];
+    for (let i = 0; i < ids.length; i++) {
+      for (let j = i + 1; j < ids.length; j++) {
+        pairs.push([ids[i], ids[j]]);
+      }
+    }
+    return pairs;
+  }
+  getInjectedIds(sessionId) {
+    const set = this.sessions.get(sessionId);
+    return set ? Array.from(set) : [];
+  }
+  clear(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  get size() {
+    return this.sessions.size;
+  }
+};
+
 // src/server.ts
 var storage;
 var updateAvailable = null;
@@ -4327,6 +5541,7 @@ var isFirstRun = false;
 var serverRef = null;
 var datacortexBridge = null;
 var engagementService = null;
+var sessionTracker = new SessionTracker();
 function getEngagementService() {
   if (!engagementService || engagementService.basePath !== storage.basePath) {
     const config = getConfig();
@@ -4382,7 +5597,7 @@ function createServer() {
   serverRef = server;
   return server;
 }
-var ENGRAM_MUTATING_TOOLS = /* @__PURE__ */ new Set(["datacore.learn", "datacore.forget", "datacore.feedback", "datacore.session.end", "datacore.promote", "datacore.resolve"]);
+var ENGRAM_MUTATING_TOOLS = /* @__PURE__ */ new Set(["datacore.learn", "datacore.forget", "datacore.feedback", "datacore.session.end", "datacore.promote", "datacore.resolve", "datacore.schemas", "datacore.exchange", "datacore.knowledge.scan"]);
 async function routeTool(name, args2) {
   const coreTool = TOOLS.find((t) => t.name === name);
   if (coreTool) {
@@ -4396,7 +5611,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, basePath: storage.basePath });
+        result = await handleInject(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath, basePath: storage.basePath, schemasPath: storage.schemasPath });
         break;
       case "datacore.search":
         result = await handleSearch(validated, { journalPath: storage.journalPath, knowledgePath: storage.knowledgePath }, datacortexBridge);
@@ -4414,10 +5629,10 @@ async function routeTool(name, args2) {
         result = await handleFeedback(validated, storage.engramsPath, storage.packsPath, getEngagementService());
         break;
       case "datacore.session.start":
-        result = await handleSessionStart(validated, storage, datacortexBridge, getEngagementService());
+        result = await handleSessionStart(validated, storage, datacortexBridge, getEngagementService(), sessionTracker);
         break;
       case "datacore.session.end":
-        result = await handleSessionEnd(validated, storage, getEngagementService());
+        result = await handleSessionEnd(validated, storage, getEngagementService(), sessionTracker);
         break;
       case "datacore.recall":
         result = await handleRecall(validated, { engramsPath: storage.engramsPath, journalPath: storage.journalPath, knowledgePath: storage.knowledgePath }, datacortexBridge);
@@ -4434,6 +5649,15 @@ async function routeTool(name, args2) {
       case "datacore.packs.export":
         result = await handleExport(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath }, getEngagementService());
         break;
+      case "datacore.knowledge.scan":
+        result = await handleKnowledgeScan(validated, { knowledgePath: storage.knowledgePath, knowledgeSurfacingPath: storage.knowledgeSurfacingPath, engramsPath: storage.engramsPath });
+        break;
+      case "datacore.exchange":
+        result = await handleExchange(validated, { engramsPath: storage.engramsPath, exchangeInboxPath: storage.exchangeInboxPath, exchangeOutboxPath: storage.exchangeOutboxPath }, getEngagementService());
+        break;
+      case "datacore.schemas":
+        result = await handleSchemas(validated, { schemasPath: storage.schemasPath, engramsPath: storage.engramsPath });
+        break;
       case "datacore.resolve":
         result = await handleResolve(validated, storage.engramsPath, getEngagementService());
         break;
@@ -4452,6 +5676,13 @@ async function routeTool(name, args2) {
     if (ENGRAM_MUTATING_TOOLS.has(name) && serverRef) {
       notifyEngramsChanged(serverRef);
     }
+    if (name === "datacore.inject" && result && typeof result === "object") {
+      const injectResult = result;
+      const sessionId = validated.session_id;
+      if (sessionId && injectResult.injected_personal_ids?.length) {
+        sessionTracker.trackInjected(sessionId, injectResult.injected_personal_ids);
+      }
+    }
     return result;
   }
   const modTool = moduleTools.find((t) => t.fullName === name);