@datacore-one/mcp 1.2.0 → 1.4.0

package/dist/index.js

@@ -218,6 +218,16 @@ var ConfigSchema = z.object({
   }).default({}),
   hints: z.object({
     enabled: z.boolean().default(true)
+  }).default({}),
+  engagement: z.object({
+    enabled: z.boolean().default(true),
+    inline_xp: z.boolean().default(false)
+  }).default({}),
+  injection: z.object({
+    directive_cap: z.number().default(10),
+    consider_cap: z.number().default(5),
+    spread_cap: z.number().default(3),
+    spread_budget: z.number().default(480)
   }).default({})
 });
 var cachedConfig = null;
@@ -242,7 +252,7 @@ function getConfig() {
 // package.json
 var package_default = {
   name: "@datacore-one/mcp",
-  version: "1.2.0",
+  version: "1.3.0",
   description: "Datacore MCP server \u2014 The Software of You",
   type: "module",
   bin: {
@@ -254,7 +264,8 @@ var package_default = {
     dev: "tsup --watch",
     test: "vitest run",
     "test:watch": "vitest",
-    start: "node dist/index.js"
+    start: "node dist/index.js",
+    release: `npm test && npm run build && npm version \${VERSION:-patch} && npm publish --access public && npm install -g @datacore-one/mcp@$(node -p 'require("./package.json").version')`
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.0.0",
@@ -329,7 +340,17 @@ var TOOLS = [
       scope: z2.string().optional().describe("Scope: global | agent:X | command:X"),
       tags: z2.array(z2.string()).optional(),
       domain: z2.string().optional().describe("Dot-notation domain: software.architecture"),
-      visibility: z2.enum(["private", "public", "template"]).optional()
+      visibility: z2.enum(["private", "public", "template"]).optional(),
+      knowledge_anchors: z2.array(z2.object({
+        path: z2.string().describe("Path to related document (e.g., zettel/Data-Pricing.md)"),
+        relevance: z2.enum(["primary", "supporting", "example"]).optional().describe("Anchor relevance level"),
+        snippet: z2.string().optional().describe("Short snippet from the document (max 200 chars)"),
+        snippet_extracted_at: z2.string().optional().describe("ISO date when snippet was extracted")
+      })).optional().describe("Links to related knowledge documents"),
+      dual_coding: z2.object({
+        example: z2.string().optional().describe("Concrete example illustrating the engram"),
+        analogy: z2.string().optional().describe("Analogy to aid understanding")
+      }).optional().describe("Dual coding: example and/or analogy for richer encoding")
     })
   },
   {
@@ -338,6 +359,7 @@ var TOOLS = [
     inputSchema: z2.object({
       prompt: z2.string().describe("The task or question to match against"),
       scope: z2.string().optional().describe("Filter by scope: global | agent:X | module:X | command:X"),
+      session_id: z2.string().optional().describe("Session ID for co-access tracking (from session.start)"),
       max_tokens: z2.number().optional().describe("Token budget (default: 8000)"),
       min_relevance: z2.number().optional().describe("Minimum score threshold (default: 0.3)")
     })
@@ -429,6 +451,7 @@ var TOOLS = [
     description: "End a session \u2014 captures journal summary and creates engrams from suggestions. Call before the conversation ends to preserve what was learned.",
     inputSchema: z2.object({
       summary: z2.string().describe("Session summary for the journal"),
+      session_id: z2.string().optional().describe("Session ID from session.start (for co-access tracking)"),
       tags: z2.array(z2.string()).optional().describe("Tags for the journal entry"),
       engram_suggestions: z2.array(z2.object({
         statement: z2.string().describe("The knowledge assertion"),
@@ -473,6 +496,16 @@ var TOOLS = [
     inputSchema: z2.object({
       module: z2.string().optional().describe("Module name (omit for all modules)")
     })
+  },
+  {
+    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.",
+    inputSchema: z2.object({
+      type: z2.enum(["reconsolidation", "discovery", "challenge"]).describe("Type of event to resolve"),
+      id: z2.string().describe("Event ID (engram_id, discovery_id, or challenge_id)"),
+      action: z2.string().describe("Resolution action: defend|revise|retire|dismiss (recon), explore|note (discovery), dismiss (challenge)"),
+      revised_statement: z2.string().optional().describe('New statement text (required when action is "revise")')
+    })
   }
 ];
 
@@ -573,6 +606,25 @@ var KnowledgeTypeSchema = z3.object({
   memory_class: z3.enum(["semantic", "episodic", "procedural", "metacognitive"]),
   cognitive_level: z3.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
 });
+var KnowledgeAnchorSchema = z3.object({
+  path: z3.string(),
+  relevance: z3.enum(["primary", "supporting", "example"]).default("supporting"),
+  snippet: z3.string().max(200).optional(),
+  snippet_extracted_at: z3.string().optional()
+});
+var AssociationSchema = z3.object({
+  target_type: z3.enum(["engram", "document"]),
+  target: z3.string(),
+  strength: z3.number().min(0).max(0.95),
+  type: z3.enum(["semantic", "temporal", "causal", "co_accessed"])
+});
+var DualCodingSchema = z3.object({
+  example: z3.string().optional(),
+  analogy: z3.string().optional()
+}).refine(
+  (d) => d.example || d.analogy,
+  "At least one of example or analogy must be provided"
+);
 var RelationsSchema = z3.object({
   broader: z3.array(z3.string()).default([]),
   narrower: z3.array(z3.string()).default([]),
@@ -609,6 +661,9 @@ var EngramSchema = z3.object({
   activation: ActivationSchema,
   provenance: ProvenanceSchema.optional(),
   feedback_signals: FeedbackSignalsSchema.optional(),
+  knowledge_anchors: z3.array(KnowledgeAnchorSchema).default([]),
+  associations: z3.array(AssociationSchema).default([]),
+  dual_coding: DualCodingSchema.optional(),
   tags: z3.array(z3.string()).default([]),
   pack: z3.string().nullable().default(null),
   abstract: z3.string().nullable().default(null),
@@ -769,7 +824,7 @@ function generateEngramId(existingEngrams) {
   const padWidth = nextSeq > 999 ? String(nextSeq).length : 3;
   return `${prefix}${String(nextSeq).padStart(padWidth, "0")}`;
 }
-async function handleLearn(args2, engramsPath) {
+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;
@@ -785,6 +840,14 @@ async function handleLearn(args2, engramsPath) {
     rationale: args2.rationale,
     derivation_count: 1,
     domain: args2.domain,
+    knowledge_anchors: args2.knowledge_anchors?.map((a) => ({
+      path: a.path,
+      relevance: a.relevance ?? "supporting",
+      snippet: a.snippet,
+      snippet_extracted_at: a.snippet_extracted_at
+    })) ?? [],
+    associations: [],
+    dual_coding: args2.dual_coding?.example || args2.dual_coding?.analogy ? args2.dual_coding : void 0,
     tags: args2.tags ?? [],
     activation: {
       retrieval_strength: autoPromote ? 0.7 : 0.5,
@@ -798,6 +861,29 @@ async function handleLearn(args2, engramsPath) {
   };
   engrams.push(engram);
   saveEngrams(engramsPath, engrams);
+  let xp = void 0;
+  if (service?.isEnabled()) {
+    try {
+      const isPublic = engram.visibility === "public" || engram.visibility === "template";
+      const actionKey = isPublic ? "engram_created_public" : "engram_created";
+      const result = await service.award(actionKey, { visibility: engram.visibility });
+      if (result) {
+        xp = { earned: result.event.xp_earned, action: actionKey };
+      }
+      if (engram.domain) {
+        const existingDomains = new Set(
+          engrams.slice(0, -1).filter((e) => e.domain).map((e) => e.domain)
+        );
+        if (!existingDomains.has(engram.domain)) {
+          const domainResult = await service.award("new_domain", { domain: engram.domain });
+          if (domainResult && xp) {
+            xp.earned += domainResult.event.xp_earned;
+          }
+        }
+      }
+    } catch {
+    }
+  }
   const statusLabel = autoPromote ? "active" : "candidate";
   const hints = autoPromote ? buildHints({
     next: "Created as active (auto_promote on). Use datacore.inject to retrieve.",
@@ -807,11 +893,12 @@ async function handleLearn(args2, engramsPath) {
     next: "Created as candidate. Use datacore.promote to activate.",
     related: ["datacore.promote", "datacore.inject"]
   });
-  return { success: true, engram, _hints: hints };
+  return { success: true, engram, xp, _hints: hints };
 }
 
 // src/tools/inject-tool.ts
 import * as fs5 from "fs";
+import * as path4 from "path";
 import * as yaml3 from "js-yaml";
 
 // src/decay.ts
@@ -834,38 +921,81 @@ function engramState(retrievalStrength) {
 // src/inject.ts
 var DEFAULT_MAX_TOKENS = 8e3;
 var DEFAULT_MIN_RELEVANCE = 0.3;
-var TOKENS_PER_ENGRAM = 40;
 var MAX_PER_PACK = 5;
 var MAX_PER_DOMAIN = 10;
-function selectEngrams(ctx, personalEngrams, packs) {
-  const promptLower = ctx.prompt.toLowerCase();
-  const promptWords = new Set(promptLower.split(/\W+/).filter((w) => w.length > 2));
-  const scored = [];
-  for (const engram of personalEngrams) {
-    if (engram.status !== "active") continue;
-    const score = scoreEngram(engram, promptLower, promptWords, [], ctx.scope, false);
-    if (score > 0) scored.push({ engram, score });
-  }
-  for (const pack of packs) {
-    if (pack.manifest["x-datacore"].injection_policy === "on_request") continue;
-    const matchTerms = pack.manifest["x-datacore"].match_terms;
-    for (const engram of pack.engrams) {
-      if (engram.status !== "active") continue;
-      const score = scoreEngram(engram, promptLower, promptWords, matchTerms, ctx.scope, true);
-      if (score > 0) scored.push({ engram, score });
+var DIP19_CONSIDER_MAX = 5;
+var DIP19_CONSIDER_BUDGET = 200;
+var RELEVANCE_RANK = { primary: 0, supporting: 1, example: 2 };
+function estimateTokens(engram) {
+  const { keyword_match: _km, raw_score: _rs, score: _s, associations: _a, ...wire } = engram;
+  const serialized = JSON.stringify(wire);
+  return Math.ceil(serialized.length / 4);
+}
+function tokenize(text) {
+  return new Set(text.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+}
+function anchorBoost(engram, taskWords) {
+  if (!engram.knowledge_anchors?.length) return 0;
+  const threshold = taskWords.size <= 1 ? 1 : 2;
+  let boost = 0;
+  for (const anchor of engram.knowledge_anchors) {
+    if (!anchor.snippet) continue;
+    const snippetWords = tokenize(anchor.snippet);
+    let overlap = 0;
+    for (const word of taskWords) {
+      if (snippetWords.has(word)) overlap++;
     }
+    if (overlap >= threshold) boost += 0.5;
   }
-  const maxTokens = ctx.maxTokens ?? DEFAULT_MAX_TOKENS;
-  const minRelevance = ctx.minRelevance ?? DEFAULT_MIN_RELEVANCE;
-  const passing = scored.filter((s) => s.score >= minRelevance);
-  passing.sort((a, b) => b.score - a.score);
-  const selected = fillTokenBudget(passing, maxTokens);
-  const splitPoint = Math.ceil(selected.length * 2 / 3);
-  return {
-    directives: selected.slice(0, splitPoint),
-    consider: selected.slice(splitPoint),
-    tokens_used: selected.length * TOKENS_PER_ENGRAM
+  return Math.min(boost, 2);
+}
+function flattenRelations(engram) {
+  if (!engram.relations) return [];
+  const associations = [];
+  for (const id of engram.relations.broader) {
+    associations.push({ target_type: "engram", target: id, type: "semantic", strength: 0.5 });
+  }
+  for (const id of engram.relations.narrower) {
+    associations.push({ target_type: "engram", target: id, type: "semantic", strength: 0.5 });
+  }
+  for (const id of engram.relations.related) {
+    associations.push({ target_type: "engram", target: id, type: "semantic", strength: 0.5 });
+  }
+  return associations;
+}
+function stripAssociations(engram) {
+  const { associations: _, ...rest } = engram;
+  return rest;
+}
+function stripScoring(engram) {
+  const { keyword_match: _, raw_score: _r, score: _s, ...rest } = engram;
+  return rest;
+}
+function aggregateAnchors(directives, consider) {
+  const seen = /* @__PURE__ */ new Map();
+  const processPool = (pool) => {
+    for (const engram of pool) {
+      if (!engram.knowledge_anchors?.length) continue;
+      for (const anchor of engram.knowledge_anchors) {
+        const existing = seen.get(anchor.path);
+        const rank = RELEVANCE_RANK[anchor.relevance] ?? 2;
+        const existingRank = existing ? RELEVANCE_RANK[existing.anchor.relevance] ?? 2 : Infinity;
+        if (!existing || rank < existingRank || rank === existingRank && engram.score > existing.engramScore) {
+          seen.set(anchor.path, { anchor, engramScore: engram.score });
+        }
+      }
+    }
   };
+  processPool(directives);
+  processPool(consider);
+  const entries = Array.from(seen.values());
+  entries.sort((a, b) => {
+    const rankA = RELEVANCE_RANK[a.anchor.relevance] ?? 2;
+    const rankB = RELEVANCE_RANK[b.anchor.relevance] ?? 2;
+    if (rankA !== rankB) return rankA - rankB;
+    return b.engramScore - a.engramScore;
+  });
+  return entries.slice(0, 10).map((e) => e.anchor);
 }
 function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilter, isPack) {
   if (scopeFilter) {
@@ -908,8 +1038,9 @@ function fillTokenBudget(scored, maxTokens) {
   const packCounts = /* @__PURE__ */ new Map();
   const domainCounts = /* @__PURE__ */ new Map();
   let tokensUsed = 0;
-  for (const { engram } of scored) {
-    if (tokensUsed + TOKENS_PER_ENGRAM > maxTokens) break;
+  for (const engram of scored) {
+    const cost = estimateTokens(engram);
+    if (tokensUsed + cost > maxTokens) continue;
     const pack = engram.pack ?? "__personal__";
     const packCount = packCounts.get(pack) ?? 0;
     if (packCount >= MAX_PER_PACK && pack !== "__personal__") continue;
@@ -918,11 +1049,120 @@ function fillTokenBudget(scored, maxTokens) {
     const domainCount = domainCounts.get(topDomain) ?? 0;
     if (domainCount >= MAX_PER_DOMAIN) continue;
     result.push(engram);
-    tokensUsed += TOKENS_PER_ENGRAM;
+    tokensUsed += cost;
     packCounts.set(pack, packCount + 1);
     domainCounts.set(topDomain, domainCount + 1);
   }
-  return result;
+  return { selected: result, tokens_used: tokensUsed };
+}
+function selectAndSpread(ctx, personalEngrams, packs) {
+  const config = getConfig();
+  const spreadCap = config.injection?.spread_cap ?? 3;
+  const spreadBudget = config.injection?.spread_budget ?? 480;
+  const promptLower = ctx.prompt.toLowerCase();
+  const promptWords = new Set(promptLower.split(/\W+/).filter((w) => w.length > 2));
+  const maxTokens = ctx.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const minRelevance = ctx.minRelevance ?? DEFAULT_MIN_RELEVANCE;
+  const engramMap = /* @__PURE__ */ new Map();
+  const scored = [];
+  for (const engram of personalEngrams) {
+    if (engram.status !== "active") continue;
+    engramMap.set(engram.id, engram);
+    const raw = scoreEngram(engram, promptLower, promptWords, [], ctx.scope, false);
+    if (raw > 0) {
+      scored.push({ ...engram, keyword_match: raw, raw_score: raw, score: raw });
+    }
+  }
+  for (const pack of packs) {
+    if (pack.manifest["x-datacore"].injection_policy === "on_request") continue;
+    const matchTerms = pack.manifest["x-datacore"].match_terms;
+    for (const engram of pack.engrams) {
+      if (engram.status !== "active") continue;
+      engramMap.set(engram.id, engram);
+      const raw = scoreEngram(engram, promptLower, promptWords, matchTerms, ctx.scope, true);
+      if (raw > 0) {
+        scored.push({ ...engram, keyword_match: raw, raw_score: raw, score: raw });
+      }
+    }
+  }
+  const filtered = scored.filter((s) => s.score >= minRelevance);
+  const maxKm = Math.max(...filtered.map((e) => e.keyword_match), 1);
+  for (const e of filtered) {
+    e.keyword_match = e.keyword_match / maxKm * 10;
+  }
+  for (const e of filtered) {
+    const aBoost = anchorBoost(e, promptWords);
+    e.score = e.keyword_match + aBoost;
+  }
+  filtered.sort((a, b) => b.score - a.score);
+  const { selected: directives, tokens_used: directiveTokens } = fillTokenBudget(filtered, maxTokens);
+  const directiveIds = new Set(directives.map((e) => e.id));
+  const directivePackCounts = /* @__PURE__ */ new Map();
+  for (const e of directives) {
+    const pack = e.pack ?? "__personal__";
+    directivePackCounts.set(pack, (directivePackCounts.get(pack) ?? 0) + 1);
+  }
+  const dip19Remainder = filtered.filter((e) => {
+    if (directiveIds.has(e.id)) return false;
+    const pack = e.pack ?? "__personal__";
+    if (pack !== "__personal__" && (directivePackCounts.get(pack) ?? 0) >= MAX_PER_PACK) return false;
+    return true;
+  });
+  const { selected: dip19Consider } = fillTokenBudget(
+    dip19Remainder,
+    DIP19_CONSIDER_BUDGET
+  );
+  const dip19Pool = dip19Consider.slice(0, DIP19_CONSIDER_MAX);
+  const dip19PoolTokens = dip19Pool.reduce((acc, e) => acc + estimateTokens(e), 0);
+  if (directives.length === 0 && dip19Pool.length === 0) {
+    return {
+      directives: [],
+      consider: [],
+      related_documents: [],
+      tokens_used: { directives: 0, consider: 0 }
+    };
+  }
+  const maxFirstPass = Math.max(...directives.map((e) => e.score), 1);
+  const visited = new Set(directives.map((e) => e.id));
+  for (const e of dip19Pool) visited.add(e.id);
+  const spreadCandidates = [];
+  let spreadTokens = 0;
+  for (const directive of directives) {
+    const assocs = directive.associations?.length ? directive.associations : flattenRelations(directive);
+    for (const assoc of assocs) {
+      if (assoc.target_type !== "engram") continue;
+      if (visited.has(assoc.target)) continue;
+      const target = engramMap.get(assoc.target);
+      if (!target || target.status !== "active") continue;
+      const spreadScore = directive.score / maxFirstPass * assoc.strength;
+      if (spreadScore < minRelevance * 0.5) continue;
+      const spreadEngram = {
+        ...target,
+        keyword_match: 0,
+        raw_score: 0,
+        score: spreadScore
+      };
+      const cost = estimateTokens(spreadEngram);
+      if (spreadTokens + cost > spreadBudget) continue;
+      if (spreadCandidates.length >= spreadCap) break;
+      spreadCandidates.push(spreadEngram);
+      spreadTokens += cost;
+      visited.add(assoc.target);
+    }
+  }
+  const allConsider = [...dip19Pool, ...spreadCandidates];
+  const agentDirectives = directives.map(stripAssociations);
+  const agentConsider = allConsider.map(stripAssociations);
+  const relatedDocs = aggregateAnchors(agentDirectives, agentConsider);
+  const wireDirectives = agentDirectives.map(stripScoring);
+  const wireConsider = agentConsider.map(stripScoring);
+  const considerTokens = dip19PoolTokens + spreadTokens;
+  return {
+    directives: wireDirectives,
+    consider: wireConsider,
+    related_documents: relatedDocs,
+    tokens_used: { directives: directiveTokens, consider: considerTokens }
+  };
 }
 
 // src/tools/inject-tool.ts
@@ -932,16 +1172,17 @@ async function handleInject(args2, paths) {
   const ctx = {
     prompt: args2.prompt,
     scope: args2.scope,
+    session_id: args2.session_id,
     maxTokens: args2.max_tokens,
     minRelevance: args2.min_relevance
   };
-  const result = selectEngrams(ctx, personalEngrams, packs);
+  const result = selectAndSpread(ctx, personalEngrams, packs);
   const totalCount = result.directives.length + result.consider.length;
   if (totalCount === 0) {
     return {
       text: "",
       count: 0,
-      tokens_used: 0,
+      tokens_used: { directives: 0, consider: 0 },
       _hints: buildHints({
         next: "No engrams matched this task. Use datacore.recall to search all sources, or datacore.learn to record new knowledge.",
         related: ["datacore.recall", "datacore.learn"]
@@ -961,6 +1202,10 @@ async function handleInject(args2, paths) {
       lines.push(formatEngram(e, totalCount));
     }
   }
+  const relatedDocs = paths.basePath ? result.related_documents.filter((doc) => fs5.existsSync(path4.join(paths.basePath, doc.path))) : result.related_documents;
+  if (relatedDocs.length > 0) {
+    lines.push("\n" + formatRelatedDocs(relatedDocs));
+  }
   updateUsageTracking(
     paths.engramsPath,
     personalEngrams,
@@ -972,6 +1217,7 @@ async function handleInject(args2, paths) {
     text: lines.join("\n"),
     count: totalCount,
     tokens_used: result.tokens_used,
+    related_documents: relatedDocs.length > 0 ? relatedDocs.length : void 0,
     _hints: buildHints({
       next: `After task, call datacore.feedback on helpful/unhelpful engrams.${idsList}`,
       related: ["datacore.feedback", "datacore.session.end"]
@@ -1010,6 +1256,12 @@ function formatEngram(engram, totalCount) {
     if (engram.contraindications?.length) {
       text += `
   Except: ${engram.contraindications.join(", ")}`;
+    }
+    if (engram.dual_coding) {
+      if (engram.dual_coding.example) text += `
+  Example: ${engram.dual_coding.example}`;
+      if (engram.dual_coding.analogy) text += `
+  Analogy: ${engram.dual_coding.analogy}`;
     }
     return text;
   }
@@ -1019,10 +1271,19 @@ function formatEngram(engram, totalCount) {
   }
   return `- ${engram.statement}`;
 }
+function formatRelatedDocs(docs) {
+  const lines = ["## RELATED DOCUMENTS\n"];
+  for (const doc of docs) {
+    let line = `- [${doc.relevance}] ${doc.path}`;
+    if (doc.snippet) line += ` \u2014 "${doc.snippet}"`;
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
 
 // src/tools/search.ts
 import * as fs6 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 var CONTENT_CACHE_MAX = 500;
 var contentCache = /* @__PURE__ */ new Map();
 function getCachedContent(filePath) {
@@ -1098,7 +1359,7 @@ function searchDir(dirPath, query) {
 function walkDir(dir) {
   const files = [];
   for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path4.join(dir, entry.name);
+    const fullPath = path5.join(dir, entry.name);
     if (entry.isDirectory()) files.push(...walkDir(fullPath));
     else files.push(fullPath);
   }
@@ -1126,17 +1387,17 @@ function extractSnippet(content, query) {
 function extractTitle(content, filePath) {
   const match = content.match(/^#\s+(.+)$/m);
   if (match) return match[1].trim();
-  return path4.basename(filePath, path4.extname(filePath));
+  return path5.basename(filePath, path5.extname(filePath));
 }
 function extractDate(filePath) {
-  const match = path4.basename(filePath).match(/^(\d{4}-\d{2}-\d{2})/);
+  const match = path5.basename(filePath).match(/^(\d{4}-\d{2}-\d{2})/);
   if (match) return match[1];
   return void 0;
 }
 
 // src/tools/ingest.ts
 import * as fs7 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 async function handleIngest(args2, paths) {
   const contentError = validateContent(args2.content);
   if (contentError) return { success: false, error: contentError };
@@ -1147,8 +1408,8 @@ async function handleIngest(args2, paths) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const slug = (args2.title ?? "ingested").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
   const fileName = `${timestamp}-${slug}.md`;
-  const filePath = path5.join(paths.knowledgePath, fileName);
-  fs7.mkdirSync(path5.dirname(filePath), { recursive: true });
+  const filePath = path6.join(paths.knowledgePath, fileName);
+  fs7.mkdirSync(path6.dirname(filePath), { recursive: true });
   const frontmatter = `---
 title: "${args2.title ?? "Ingested Note"}"
 created: "${(/* @__PURE__ */ new Date()).toISOString()}"
@@ -1194,18 +1455,18 @@ function extractEngramSuggestions(content) {
 
 // src/tools/status.ts
 import * as fs9 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 
 // src/trust.ts
 import * as fs8 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 import * as crypto from "crypto";
 function computePackChecksum(packDir) {
   const files = ["SKILL.md", "engrams.yaml"];
   const hash = crypto.createHash("sha256");
   let hasContent = false;
   for (const file of files) {
-    const filePath = path6.join(packDir, file);
+    const filePath = path7.join(packDir, file);
     if (fs8.existsSync(filePath)) {
       hash.update(fs8.readFileSync(filePath));
       hasContent = true;
@@ -1218,6 +1479,291 @@ function verifyPackChecksum(packDir, expected) {
   return { valid: actual === expected, actual };
 }
 
+// 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)
+});
+var XPHistoryEntrySchema = z4.object({
+  date: z4.string(),
+  earned: z4.number(),
+  base_earned: z4.number(),
+  multiplier: z4.number(),
+  actions: z4.array(z4.string())
+});
+var TierHistoryEntrySchema = z4.object({
+  tier: z4.string(),
+  date: z4.string()
+});
+var MultiplierEntrySchema = z4.object({
+  type: z4.string(),
+  factor: z4.number(),
+  since: z4.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()
+  }),
+  baseline_stats: z4.record(z4.number()),
+  bonus_xp: z4.number(),
+  started_at: z4.string(),
+  expires_at: z4.string()
+});
+var ChallengeHistorySchema = z4.object({
+  type: z4.string(),
+  tier: z4.string(),
+  completed: z4.boolean(),
+  date: z4.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 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 EngagementProfileSchema = z4.object({
+  version: z4.literal(4),
+  identity: IdentitySchema.default({}),
+  xp: z4.object({
+    total: z4.number().default(0),
+    this_week: z4.number().default(0),
+    history: z4.array(XPHistoryEntrySchema).default([])
+  }).default({}),
+  tier: z4.object({
+    current: z4.string().default("Seed"),
+    achieved_at: z4.string().nullable().default(null),
+    history: z4.array(TierHistoryEntrySchema).default([])
+  }).default({}),
+  multipliers: z4.object({
+    active: z4.array(MultiplierEntrySchema).default([]),
+    effective: z4.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)
+  }).default({}),
+  challenges: z4.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([])
+  }).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)
+    }).default({}),
+    response_rate: z4.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)
+  }).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()
+    })).default([]),
+    unused_60d: z4.array(z4.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)
+    }).default({}),
+    last_calculated: z4.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)
+  }).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)
+  }).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)
+  }).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 XPResultSchema = z4.object({
+  event: XPEventSchema,
+  tier_change: z4.object({
+    from: z4.string(),
+    to: z4.string(),
+    message: z4.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 XPActionRegistrySchema = z4.object({
+  version: z4.number(),
+  actions: z4.record(XPActionSchema)
+});
+var TIER_THRESHOLDS = [
+  { name: "Seed", minXP: 0 },
+  { name: "Cipher", minXP: 100 },
+  { name: "Sage", minXP: 500 },
+  { name: "Adept", minXP: 1200 },
+  { name: "Visionary", minXP: 2500 },
+  { name: "Oracle", minXP: 5e3 }
+];
+
+// src/engagement/format.ts
+function formatSessionStart(profile) {
+  const tier = profile.tier.current;
+  const xp = profile.xp.total;
+  const nextTier = TIER_THRESHOLDS.find((t) => t.minXP > xp);
+  const xpToNext = nextTier ? nextTier.minXP - xp : 0;
+  const nextLabel = nextTier ? ` \u2192 ${nextTier.name} in ${xpToNext} XP` : " (max tier)";
+  const multiplierLabel = profile.multipliers.effective > 1 ? ` [${profile.multipliers.effective}x ${profile.multipliers.active.map((m) => m.type).join(", ")}]` : "";
+  const lines = [];
+  lines.push(`Your Datacore: ${tier} (${xp.toLocaleString()} XP${nextLabel})${multiplierLabel}`);
+  if (profile.ai_performance.feedback_count > 0) {
+    const helpful = Math.round(profile.ai_performance.helpful_ratio * 100);
+    lines.push(`  AI surfaced ${profile.ai_performance.total_injections} insights this week (${helpful}% helpful)`);
+  }
+  const activeDays = profile.consistency.active_days_30;
+  lines.push(`  Active ${activeDays}/30 days`);
+  return lines.join("\n");
+}
+function formatSessionEnd(profile, sessionXP, events) {
+  if (sessionXP === 0) return "Session complete \u2014 no XP earned this session.";
+  const multiplierLabel = profile.multipliers.effective > 1 ? ` (\xD7${profile.multipliers.effective} ${profile.multipliers.active.map((m) => m.type).join(", ")})` : "";
+  const domainActions = events.filter((e) => e.context?.domain).map((e) => e.context.domain);
+  const domainNote = domainActions.length > 0 ? ` | Your ${domainActions[0]} domain deepened` : "";
+  const lines = [];
+  lines.push(`Session: +${sessionXP} XP${multiplierLabel}${domainNote}`);
+  const candidates = 0;
+  if (candidates > 0) {
+    lines.push(`Tomorrow: ${candidates} candidate(s) ready for review`);
+  }
+  return lines.join("\n");
+}
+function formatStatus(profile) {
+  const lines = [];
+  lines.push("## Engagement Dashboard");
+  lines.push("");
+  const nextTier = TIER_THRESHOLDS.find((t) => t.minXP > profile.xp.total);
+  const progress = nextTier ? `${profile.xp.total}/${nextTier.minXP} XP (${Math.round(profile.xp.total / nextTier.minXP * 100)}%)` : `${profile.xp.total} XP (max tier)`;
+  lines.push(`**Tier:** ${profile.tier.current} \u2014 ${progress}`);
+  lines.push(`**This week:** ${profile.xp.this_week} XP`);
+  if (profile.multipliers.active.length > 0) {
+    const mults = profile.multipliers.active.map((m) => `${m.type} (${m.factor}x)`).join(", ");
+    lines.push(`**Multipliers:** ${mults} = ${profile.multipliers.effective}x`);
+  }
+  lines.push(`**Consistency:** ${profile.consistency.active_days_30}/30 days active, best run: ${profile.consistency.best_run} days`);
+  lines.push("");
+  lines.push("**Stats:**");
+  lines.push(`- Engrams created: ${profile.stats.total_engrams_created}`);
+  lines.push(`- Feedback given: ${profile.stats.total_feedback_given}`);
+  lines.push(`- Domains covered: ${profile.stats.domains_covered}`);
+  lines.push(`- Packs exported: ${profile.stats.total_packs_exported}`);
+  if (profile.challenges.active) {
+    lines.push("");
+    lines.push(`**Active Challenge:** ${profile.challenges.active.description}`);
+    lines.push(`  Expires: ${profile.challenges.active.expires_at}`);
+  }
+  if (profile.reconsolidation.pending.length > 0) {
+    lines.push("");
+    lines.push(`**Pending Contradictions:** ${profile.reconsolidation.pending.length}`);
+  }
+  if (profile.reputation.score > 0) {
+    lines.push("");
+    lines.push(`**Reputation:** ${profile.reputation.score.toFixed(2)}`);
+  }
+  return lines.join("\n");
+}
+function formatReconsolidation(recon) {
+  const lines = [];
+  lines.push("**Contradiction Detected:**");
+  lines.push(`  Existing: "${recon.statement}"`);
+  lines.push(`  New: "${recon.contradiction}"`);
+  lines.push(`  Evidence: ${recon.evidence_strength}`);
+  lines.push("");
+  lines.push("  Actions: [Defend] [Revise] [Retire] [Dismiss]");
+  lines.push(`  \u2192 Use datacore.resolve with type="reconsolidation", id="${recon.engram_id}"`);
+  return lines.join("\n");
+}
+function formatDiscovery(disc) {
+  const lines = [];
+  lines.push("**Cross-Domain Discovery:**");
+  lines.push(`  "${disc.engram_a.statement}" (${disc.engram_a.domain})`);
+  lines.push(`  \u2194 "${disc.engram_b.statement}" (${disc.engram_b.domain})`);
+  lines.push(`  Connection: ${disc.connection}`);
+  lines.push("");
+  lines.push("  Actions: [Explore +20 XP] [Note]");
+  lines.push(`  \u2192 Use datacore.resolve with type="discovery", id="${disc.id}"`);
+  return lines.join("\n");
+}
+function formatChallenge(challenge) {
+  const lines = [];
+  lines.push(`**Weekly Challenge:** ${challenge.description}`);
+  lines.push(`  Bonus: +${challenge.bonus_xp} XP | Expires: ${challenge.expires_at}`);
+  lines.push(`  \u2192 Dismiss: datacore.resolve with type="challenge", id="${challenge.id}", action="dismiss"`);
+  return lines.join("\n");
+}
+
 // registry/packs.json
 var packs_default = {
   version: 1,
@@ -1256,13 +1802,13 @@ var packs_default = {
       download_url: "",
       engram_count: 747,
       free: true,
-      checksum: "08185777c38e3a91fbb0f92e7ef388c5940e97e69be6dcce8ce119bd2b33968c"
+      checksum: "baa1010298515c1906e892f6f8c2198e5fdf78383dceb57373bc8d53c4c31921"
     }
   ]
 };
 
 // src/tools/status.ts
-async function handleStatus(paths, updateAvailable2) {
+async function handleStatus(paths, updateAvailable2, engagementService2) {
   const engrams = loadEngrams(paths.engramsPath);
   const journalCount = countFiles(paths.journalPath, ".md");
   const knowledgeCount = countFiles(paths.knowledgePath, ".md");
@@ -1277,7 +1823,7 @@ async function handleStatus(paths, updateAvailable2) {
   const packIntegrity = [];
   for (const regPack of packs_default.packs) {
     if (!regPack.checksum) continue;
-    const packDir = path7.join(paths.packsPath, regPack.id);
+    const packDir = path8.join(paths.packsPath, regPack.id);
     if (!fs9.existsSync(packDir)) continue;
     const result = verifyPackChecksum(packDir, regPack.checksum);
     packIntegrity.push({ name: regPack.id, valid: result.valid });
@@ -1294,13 +1840,29 @@ async function handleStatus(paths, updateAvailable2) {
     recommendations.push(`${candidateCount} candidate engrams awaiting review. Use datacore.promote or enable engrams.auto_promote in config.yaml.`);
   }
   const { date: today } = localDate();
-  const todayJournal = path7.join(paths.journalPath, `${today}.md`);
+  const todayJournal = path8.join(paths.journalPath, `${today}.md`);
   if (!fs9.existsSync(todayJournal)) {
     recommendations.push("No journal entry today. Use datacore.capture to start one.");
   }
   if (updateAvailable2) {
     recommendations.push(`Update available: ${updateAvailable2}. Run: npm update -g @datacore-one/mcp`);
   }
+  let engagement = void 0;
+  if (engagementService2?.isEnabled()) {
+    try {
+      await engagementService2.init();
+      const profile = engagementService2.getProfile();
+      if (profile) {
+        engagement = {
+          display: formatStatus(profile),
+          tier: profile.tier.current,
+          xp: profile.xp.total,
+          reputation: profile.reputation.score
+        };
+      }
+    } catch {
+    }
+  }
   const statusResult = {
     version: currentVersion,
     mode: paths.mode,
@@ -1310,6 +1872,7 @@ async function handleStatus(paths, updateAvailable2) {
     pack_integrity: packIntegrity.length > 0 ? packIntegrity : void 0,
     journal_entries: journalCount,
     knowledge_notes: knowledgeCount,
+    engagement,
     _recommendations: recommendations.length > 0 ? recommendations : void 0,
     _hints: buildHints({
       next: recommendations.length > 0 ? recommendations[0] : "System healthy. Use datacore.session.start to begin working.",
@@ -1328,7 +1891,7 @@ function countFiles(dir, ext) {
   if (!fs9.existsSync(dir)) return 0;
   let count = 0;
   for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path7.join(dir, entry.name);
+    const fullPath = path8.join(dir, entry.name);
     if (entry.isDirectory()) count += countFiles(fullPath, ext);
     else if (entry.name.endsWith(ext)) count++;
   }
@@ -1341,26 +1904,26 @@ function countDirs(dir) {
 
 // src/tools/discover.ts
 import * as fs10 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 function handleDiscover(args2, packsDir) {
-  const bundledDir = path8.join(
-    path8.dirname(new URL(import.meta.url).pathname),
+  const bundledDir = path9.join(
+    path9.dirname(new URL(import.meta.url).pathname),
     "..",
     "packs"
   );
   let packs = packs_default.packs.map((p) => {
-    const localDir = path8.join(packsDir, p.id);
-    const installed = fs10.existsSync(path8.join(localDir, "SKILL.md"));
+    const localDir = path9.join(packsDir, p.id);
+    const installed = fs10.existsSync(path9.join(localDir, "SKILL.md"));
     let installedVersion;
     if (installed) {
       try {
-        const content = fs10.readFileSync(path8.join(localDir, "SKILL.md"), "utf8");
+        const content = fs10.readFileSync(path9.join(localDir, "SKILL.md"), "utf8");
         const match = content.match(/version:\s*["']?([^"'\n]+)/);
         installedVersion = match?.[1];
       } catch {
       }
     }
-    const bundled = fs10.existsSync(path8.join(bundledDir, p.id, "SKILL.md"));
+    const bundled = fs10.existsSync(path9.join(bundledDir, p.id, "SKILL.md"));
     return {
       ...p,
       installed,
@@ -1392,7 +1955,7 @@ function handleDiscover(args2, packsDir) {
 
 // src/tools/install.ts
 import * as fs11 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import * as yaml4 from "js-yaml";
 import * as os2 from "os";
 import { execSync } from "child_process";
@@ -1407,7 +1970,7 @@ async function handleInstall(args2, packsDir) {
     if (resolved.error) return { success: false, error: resolved.error };
     srcDir = resolved.path;
   }
-  const skillPath = path9.join(srcDir, "SKILL.md");
+  const skillPath = path10.join(srcDir, "SKILL.md");
   if (!fs11.existsSync(skillPath)) {
     return { success: false, error: "No SKILL.md found in source directory" };
   }
@@ -1422,9 +1985,9 @@ async function handleInstall(args2, packsDir) {
   if (!packId) {
     return { success: false, error: "Missing x-datacore.id in SKILL.md frontmatter" };
   }
-  const destDir = path9.join(packsDir, packId);
-  if (fs11.existsSync(path9.join(destDir, "SKILL.md"))) {
-    const existingContent = fs11.readFileSync(path9.join(destDir, "SKILL.md"), "utf8");
+  const destDir = path10.join(packsDir, packId);
+  if (fs11.existsSync(path10.join(destDir, "SKILL.md"))) {
+    const existingContent = fs11.readFileSync(path10.join(destDir, "SKILL.md"), "utf8");
     const existingMatch = existingContent.match(/version:\s*["']?([^"'\n]+)/);
     const existingVersion = existingMatch?.[1];
     if (existingVersion === newVersion) {
@@ -1445,14 +2008,14 @@ function verifyInstalledChecksum(packId, destDir) {
   return result.valid;
 }
 async function downloadPack(url) {
-  const tmpDir = fs11.mkdtempSync(path9.join(os2.tmpdir(), "datacore-pack-"));
+  const tmpDir = fs11.mkdtempSync(path10.join(os2.tmpdir(), "datacore-pack-"));
   try {
     const res = await fetch(url, { signal: AbortSignal.timeout(3e4) });
     if (!res.ok) return { error: `Download failed: HTTP ${res.status}` };
     const buffer = Buffer.from(await res.arrayBuffer());
-    const archivePath = path9.join(tmpDir, "pack.tar.gz");
+    const archivePath = path10.join(tmpDir, "pack.tar.gz");
     fs11.writeFileSync(archivePath, buffer);
-    const extractDir = path9.join(tmpDir, "extracted");
+    const extractDir = path10.join(tmpDir, "extracted");
     fs11.mkdirSync(extractDir);
     execSync(`tar xzf ${JSON.stringify(archivePath)} -C ${JSON.stringify(extractDir)}`, { timeout: 1e4 });
     const packRoot = findPackRoot(extractDir);
@@ -1463,10 +2026,10 @@ async function downloadPack(url) {
   }
 }
 function findPackRoot(dir) {
-  if (fs11.existsSync(path9.join(dir, "SKILL.md"))) return dir;
+  if (fs11.existsSync(path10.join(dir, "SKILL.md"))) return dir;
   for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      const found = findPackRoot(path9.join(dir, entry.name));
+      const found = findPackRoot(path10.join(dir, entry.name));
       if (found) return found;
     }
   }
@@ -1480,17 +2043,17 @@ function resolvePackId(packId, packsDir) {
   if (registryPack.download_url) {
     return { error: `Pack "${packId}" must be installed via URL: ${registryPack.download_url}` };
   }
-  const bundledDir = path9.join(
-    path9.dirname(new URL(import.meta.url).pathname),
+  const bundledDir = path10.join(
+    path10.dirname(new URL(import.meta.url).pathname),
     "..",
     "packs",
     packId
   );
-  if (fs11.existsSync(path9.join(bundledDir, "SKILL.md"))) {
+  if (fs11.existsSync(path10.join(bundledDir, "SKILL.md"))) {
     return { path: bundledDir };
   }
-  const localDir = path9.join(packsDir, packId);
-  if (fs11.existsSync(path9.join(localDir, "SKILL.md"))) {
+  const localDir = path10.join(packsDir, packId);
+  if (fs11.existsSync(path10.join(localDir, "SKILL.md"))) {
     return { path: localDir };
   }
   return { error: `Pack "${packId}" is registered but not available locally. It may need to be downloaded manually.` };
@@ -1498,9 +2061,9 @@ function resolvePackId(packId, packsDir) {
 
 // src/tools/export.ts
 import * as fs12 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 import * as yaml5 from "js-yaml";
-async function handleExport(args2, paths) {
+async function handleExport(args2, paths, service) {
   const allEngrams = loadEngrams(paths.engramsPath);
   let selected = allEngrams.filter((e) => e.status === "active");
   selected = selected.filter((e) => e.visibility === "public" || e.visibility === "template");
@@ -1531,7 +2094,7 @@ async function handleExport(args2, paths) {
     return { success: false, error: "No engrams match the filter criteria" };
   }
   const packId = args2.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
-  const packDir = path10.join(paths.packsPath, packId);
+  const packDir = path11.join(paths.packsPath, packId);
   if (!args2.confirm) {
     return {
       success: true,
@@ -1567,7 +2130,7 @@ ${args2.description}
 
 Exported ${selected.length} engrams.
 `;
-  fs12.writeFileSync(path10.join(packDir, "SKILL.md"), skillContent);
+  fs12.writeFileSync(path11.join(packDir, "SKILL.md"), skillContent);
   const exportEngrams = selected.map((e) => ({
     id: e.id,
     version: e.version,
@@ -1589,26 +2152,32 @@ Exported ${selected.length} engrams.
     feedback_signals: { positive: 0, negative: 0 }
   }));
   fs12.writeFileSync(
-    path10.join(packDir, "engrams.yaml"),
+    path11.join(packDir, "engrams.yaml"),
     yaml5.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' })
   );
+  if (service?.isEnabled() && selected.length >= 5) {
+    try {
+      await service.award("pack_exported", { engram_count: selected.length, avg_fitness: 0.7 });
+    } catch {
+    }
+  }
   return { success: true, pack_path: packDir };
 }
 
 // src/modules.ts
 import * as fs13 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import * as yaml6 from "js-yaml";
 function discoverModules(storage2) {
   const modules = [];
   if (storage2.mode !== "full") return modules;
-  const globalModulesDir = path11.join(storage2.basePath, ".datacore", "modules");
+  const globalModulesDir = path12.join(storage2.basePath, ".datacore", "modules");
   modules.push(...scanModulesDir(globalModulesDir, "global"));
   try {
     const entries = fs13.readdirSync(storage2.basePath);
     for (const entry of entries) {
       if (/^\d+-/.test(entry)) {
-        const spaceModulesDir = path11.join(storage2.basePath, entry, ".datacore", "modules");
+        const spaceModulesDir = path12.join(storage2.basePath, entry, ".datacore", "modules");
         modules.push(...scanModulesDir(spaceModulesDir, "space", entry));
       }
     }
@@ -1622,8 +2191,8 @@ function scanModulesDir(modulesDir, scope, spaceName) {
   try {
     const entries = fs13.readdirSync(modulesDir);
     for (const entry of entries) {
-      const modulePath = path11.join(modulesDir, entry);
-      const manifestPath = path11.join(modulePath, "module.yaml");
+      const modulePath = path12.join(modulesDir, entry);
+      const manifestPath = path12.join(modulePath, "module.yaml");
       if (!fs13.existsSync(manifestPath)) continue;
       try {
         const raw = fs13.readFileSync(manifestPath, "utf-8");
@@ -1648,12 +2217,12 @@ async function loadModuleTools(modules, storage2) {
   for (const mod of modules) {
     const declaredTools = mod.manifest.provides?.tools;
     if (!declaredTools || declaredTools.length === 0) continue;
-    const toolsIndexPath = path11.join(mod.modulePath, "tools", "index.js");
+    const toolsIndexPath = path12.join(mod.modulePath, "tools", "index.js");
     if (!fs13.existsSync(toolsIndexPath)) continue;
     try {
       const toolsModule = await import(toolsIndexPath);
       const moduleTools2 = toolsModule.tools || toolsModule.default?.tools || [];
-      const dataPath = mod.scope === "space" && mod.spaceName ? path11.join(storage2.basePath, mod.spaceName, ".datacore", "modules", mod.name, "data") : path11.join(storage2.basePath, "0-personal", ".datacore", "modules", mod.name, "data");
+      const dataPath = mod.scope === "space" && mod.spaceName ? path12.join(storage2.basePath, mod.spaceName, ".datacore", "modules", mod.name, "data") : path12.join(storage2.basePath, "0-personal", ".datacore", "modules", mod.name, "data");
       const context = {
         storage: storage2,
         modulePath: mod.modulePath,
@@ -1750,7 +2319,7 @@ async function handleModulesInfo(args2, storage2, cachedModules) {
 
 // src/tools/modules-health.ts
 import * as fs14 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 async function handleModulesHealth(args2, storage2, cachedModules) {
   const modules = cachedModules ?? discoverModules(storage2);
   if (args2.module) {
@@ -1772,10 +2341,10 @@ async function handleModulesHealth(args2, storage2, cachedModules) {
 async function checkModule(mod, storage2) {
   const issues = [];
   const manifest = mod.manifest;
-  if (!fs14.existsSync(path12.join(mod.modulePath, "SKILL.md"))) {
+  if (!fs14.existsSync(path13.join(mod.modulePath, "SKILL.md"))) {
     issues.push("Missing SKILL.md (ecosystem entry point)");
   }
-  if (!fs14.existsSync(path12.join(mod.modulePath, "CLAUDE.base.md"))) {
+  if (!fs14.existsSync(path13.join(mod.modulePath, "CLAUDE.base.md"))) {
     issues.push("Missing CLAUDE.base.md (AI context)");
   }
   if (!manifest.manifest_version || manifest.manifest_version < 2) {
@@ -1791,7 +2360,7 @@ async function checkModule(mod, storage2) {
   const provides = manifest.provides;
   const declaredTools = provides?.tools || [];
   if (declaredTools.length > 0) {
-    const toolsIndex = path12.join(mod.modulePath, "tools", "index.js");
+    const toolsIndex = path13.join(mod.modulePath, "tools", "index.js");
     if (!fs14.existsSync(toolsIndex)) {
       issues.push(`Declares ${declaredTools.length} tools but tools/index.js not found`);
     } else {
@@ -1811,7 +2380,7 @@ async function checkModule(mod, storage2) {
   const suspectExts = [".db", ".sqlite", ".json"];
   const suspectDirs = ["output", "data", "state"];
   for (const dir of suspectDirs) {
-    const fullPath = path12.join(mod.modulePath, dir);
+    const fullPath = path13.join(mod.modulePath, dir);
     if (fs14.existsSync(fullPath) && fs14.statSync(fullPath).isDirectory()) {
       issues.push(`Data dir '${dir}/' found in module code (should be in space data path)`);
     }
@@ -1833,7 +2402,7 @@ async function checkModule(mod, storage2) {
 }
 
 // src/tools/forget.ts
-async function handleForget(args2, engramsPath) {
+async function handleForget(args2, engramsPath, service) {
   const engrams = loadEngrams(engramsPath);
   if (args2.id) {
     const idx = engrams.findIndex((e) => e.id === args2.id);
@@ -1846,6 +2415,14 @@ async function handleForget(args2, engramsPath) {
     }
     engrams[idx] = { ...engram, status: "retired" };
     saveEngrams(engramsPath, engrams);
+    if (service?.isEnabled()) {
+      try {
+        const created = engram.activation.last_accessed;
+        const ageDays = Math.floor((Date.now() - new Date(created).getTime()) / 864e5);
+        await service.award("engram_retired", { engram_age_days: ageDays });
+      } catch {
+      }
+    }
     return { success: true, retired: { id: engram.id, statement: engram.statement } };
   }
   if (args2.search) {
@@ -1862,6 +2439,14 @@ async function handleForget(args2, engramsPath) {
       const idx = engrams.findIndex((e) => e.id === engram.id);
       engrams[idx] = { ...engram, status: "retired" };
       saveEngrams(engramsPath, engrams);
+      if (service?.isEnabled()) {
+        try {
+          const created = engram.activation.last_accessed;
+          const ageDays = Math.floor((Date.now() - new Date(created).getTime()) / 864e5);
+          await service.award("engram_retired", { engram_age_days: ageDays });
+        } catch {
+        }
+      }
       return { success: true, retired: { id: engram.id, statement: engram.statement } };
     }
     const truncated = allMatches.length > 100;
@@ -1876,7 +2461,7 @@ async function handleForget(args2, engramsPath) {
 }
 
 // src/tools/feedback.ts
-import * as path13 from "path";
+import * as path14 from "path";
 function findEngram(engramId, engramsPath, packsPath) {
   const personal = loadEngrams(engramsPath);
   const found = personal.find((e) => e.id === engramId);
@@ -1886,20 +2471,20 @@ function findEngram(engramId, engramsPath, packsPath) {
     const packEngram = pack.engrams.find((e) => e.id === engramId);
     if (packEngram) {
       const packId = pack.manifest["x-datacore"]?.id;
-      const packEngramsPath = packId ? path13.join(packsPath, packId, "engrams.yaml") : void 0;
+      const packEngramsPath = packId ? path14.join(packsPath, packId, "engrams.yaml") : void 0;
       return { engram: packEngram, source: "pack", packEngrams: pack.engrams, packEngramsPath };
     }
   }
   return null;
 }
-async function handleFeedback(args2, engramsPath, packsPath) {
-  const pPath = packsPath ?? path13.join(path13.dirname(engramsPath), "packs");
+async function handleFeedback(args2, engramsPath, packsPath, service) {
+  const pPath = packsPath ?? path14.join(path14.dirname(engramsPath), "packs");
   if (args2.signals && args2.signals.length > 0) {
-    return handleBatchFeedback(args2.signals, engramsPath, pPath);
+    return handleBatchFeedback(args2.signals, engramsPath, pPath, service);
   }
-  return handleSingleFeedback(args2.engram_id, args2.signal, args2.comment, engramsPath, pPath);
+  return handleSingleFeedback(args2.engram_id, args2.signal, args2.comment, engramsPath, pPath, service);
 }
-async function handleSingleFeedback(engram_id, signal, comment, engramsPath, packsPath) {
+async function handleSingleFeedback(engram_id, signal, comment, engramsPath, packsPath, service) {
   const found = findEngram(engram_id, engramsPath, packsPath);
   if (!found) {
     return {
@@ -1925,6 +2510,12 @@ async function handleSingleFeedback(engram_id, signal, comment, engramsPath, pac
   } else if (found.source === "pack" && found.packEngrams && found.packEngramsPath) {
     atomicWriteYaml(found.packEngramsPath, { engrams: found.packEngrams });
   }
+  if (service?.isEnabled()) {
+    try {
+      await service.award("feedback_given", { signal });
+    } catch {
+    }
+  }
   return {
     mode: "single",
     success: true,
@@ -1934,7 +2525,7 @@ async function handleSingleFeedback(engram_id, signal, comment, engramsPath, pac
     feedback_signals: { ...found.engram.feedback_signals }
   };
 }
-async function handleBatchFeedback(signals, engramsPath, packsPath) {
+async function handleBatchFeedback(signals, engramsPath, packsPath, service) {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const results = [];
   const summary = { positive: 0, negative: 0, neutral: 0 };
@@ -1955,7 +2546,7 @@ async function handleBatchFeedback(signals, engramsPath, packsPath) {
           const packId = pack.manifest["x-datacore"]?.id;
           if (packId) {
             dirtyPackFiles.set(
-              path13.join(packsPath, packId, "engrams.yaml"),
+              path14.join(packsPath, packId, "engrams.yaml"),
               pack.engrams
             );
           }
@@ -1982,6 +2573,15 @@ async function handleBatchFeedback(signals, engramsPath, packsPath) {
   for (const [filePath, engrams] of dirtyPackFiles) {
     atomicWriteYaml(filePath, { engrams });
   }
+  if (service?.isEnabled()) {
+    try {
+      const successCount = results.filter((r) => r.success).length;
+      for (let i = 0; i < successCount; i++) {
+        await service.award("feedback_given", { batch: true });
+      }
+    } catch {
+    }
+  }
   return {
     mode: "batch",
     results,
@@ -1994,22 +2594,871 @@ async function handleBatchFeedback(signals, engramsPath, packsPath) {
 }
 
 // src/tools/session-start.ts
+import * as fs18 from "fs";
+import * as path18 from "path";
+import * as crypto2 from "crypto";
+
+// src/engagement/service.ts
+import * as fs17 from "fs";
+import * as path17 from "path";
+
+// src/engagement/profile.ts
 import * as fs15 from "fs";
-import * as path14 from "path";
-async function handleSessionStart(args2, storage2, bridge) {
+import * as path15 from "path";
+import * as yaml7 from "js-yaml";
+var PROFILE_DIR = "engagement";
+var PROFILE_FILE = "profile.yaml";
+function engagementDir(basePath) {
+  return path15.join(basePath, ".datacore", PROFILE_DIR);
+}
+function profilePath(basePath) {
+  return path15.join(engagementDir(basePath), PROFILE_FILE);
+}
+function createDefaultProfile() {
+  return EngagementProfileSchema.parse({ version: 4 });
+}
+function loadProfile(basePath) {
+  const filePath = profilePath(basePath);
+  if (!fs15.existsSync(filePath)) {
+    return createDefaultProfile();
+  }
+  try {
+    const raw = yaml7.load(fs15.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");
+    } catch {
+    }
+    return createDefaultProfile();
+  }
+}
+function saveProfile(basePath, profile) {
+  const dir = engagementDir(basePath);
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
+  }
+  const filePath = profilePath(basePath);
+  const content = yaml7.dump(profile, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const tmpPath = filePath + ".tmp." + process.pid;
+  fs15.writeFileSync(tmpPath, content);
+  fs15.renameSync(tmpPath, filePath);
+}
+function ensureEngagementDir(basePath) {
+  const dir = engagementDir(basePath);
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
+  }
+  const gitignorePath = path15.join(basePath, ".datacore", ".gitignore");
+  if (fs15.existsSync(gitignorePath)) {
+    const content = fs15.readFileSync(gitignorePath, "utf8");
+    if (!content.includes("engagement/profile.yaml")) {
+      fs15.appendFileSync(gitignorePath, "\nengagement/profile.yaml\nengagement/badge.svg\n");
+    }
+  }
+}
+
+// src/engagement/actions.ts
+import * as fs16 from "fs";
+import * as path16 from "path";
+import * as yaml8 from "js-yaml";
+var BUNDLED_ACTIONS = {
+  version: 1,
+  actions: {
+    engram_created: {
+      xp: 10,
+      trigger: "datacore.learn",
+      condition: "status === active",
+      description: "Create a quality engram"
+    },
+    engram_created_public: {
+      xp: 20,
+      trigger: "datacore.learn",
+      condition: "visibility === public || visibility === template",
+      description: "Create a public/template engram"
+    },
+    feedback_given: {
+      xp: 5,
+      trigger: "datacore.feedback",
+      daily_limit: 10,
+      description: "Give feedback on an injected engram"
+    },
+    engram_promoted: {
+      xp: 3,
+      trigger: "datacore.promote",
+      description: "Promote a candidate engram to active"
+    },
+    engram_retired: {
+      xp: 5,
+      trigger: "datacore.forget",
+      cooldown_days: 7,
+      description: "Retire an engram after reflection (7-day cooldown)"
+    },
+    pack_exported: {
+      xp: 25,
+      trigger: "datacore.packs.export",
+      condition: "engram_count >= 5 && avg_fitness >= 0.6",
+      description: "Export a quality pack (5+ engrams, 0.6+ fitness)"
+    },
+    new_domain: {
+      xp: 15,
+      trigger: "datacore.learn",
+      description: "Create first engram in a new domain"
+    },
+    reconsolidation_defend: {
+      xp: 12,
+      trigger: "datacore.resolve",
+      description: "Defend an engram during contradiction challenge"
+    },
+    reconsolidation_revise: {
+      xp: 10,
+      trigger: "datacore.resolve",
+      description: "Revise an engram during contradiction challenge"
+    },
+    reconsolidation_retire: {
+      xp: 8,
+      trigger: "datacore.resolve",
+      description: "Retire an engram during contradiction challenge"
+    },
+    discovery_explore: {
+      xp: 20,
+      trigger: "datacore.resolve",
+      description: "Explore a cross-domain discovery"
+    },
+    reconsolidation_expired: {
+      xp: 3,
+      trigger: "system",
+      description: "Auto-expire an overdue reconsolidation"
+    }
+  }
+};
+function loadActions(basePath) {
+  const actionsPath = path16.join(basePath, ".datacore", "engagement", "xp-actions.yaml");
+  if (!fs16.existsSync(actionsPath)) {
+    return BUNDLED_ACTIONS;
+  }
+  try {
+    const raw = yaml8.load(fs16.readFileSync(actionsPath, "utf8"));
+    return XPActionRegistrySchema.parse(raw);
+  } catch (err) {
+    logger.warning(`Malformed xp-actions.yaml, using defaults: ${err}`);
+    return BUNDLED_ACTIONS;
+  }
+}
+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 });
+  }
+  const content = yaml8.dump(BUNDLED_ACTIONS, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  fs16.writeFileSync(actionsPath, content);
+}
+
+// src/engagement/engine.ts
+function resolveTier(profile) {
+  const xp = profile.xp.total;
+  let current = "Seed";
+  for (const t of TIER_THRESHOLDS) {
+    if (xp >= t.minXP) current = t.name;
+  }
+  const changed = current !== profile.tier.current;
+  const message = changed ? `You've reached ${current}!` : void 0;
+  return { current, changed, message };
+}
+function getEffectiveMultiplier(profile) {
+  const actives = profile.multipliers.active;
+  if (actives.length === 0) return { effective: 1, active: [] };
+  let effective = 1;
+  for (const m of actives) {
+    effective *= m.factor;
+  }
+  return { effective, active: actives };
+}
+function isActionEligible(profile, actionKey, actions, context) {
+  const action = actions.actions[actionKey];
+  if (!action) return { eligible: false, reason: `Unknown action: ${actionKey}` };
+  if (action.daily_limit !== void 0) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const todayEntry = profile.xp.history.find((h) => h.date === today);
+    if (todayEntry) {
+      const todayCount = todayEntry.actions.filter((a) => a === actionKey).length;
+      if (todayCount >= action.daily_limit) {
+        return { eligible: false, reason: `Daily limit of ${action.daily_limit} reached for ${actionKey}` };
+      }
+    }
+  }
+  if (action.cooldown_days !== void 0 && context?.engram_age_days !== void 0) {
+    const ageDays = context.engram_age_days;
+    if (ageDays < action.cooldown_days) {
+      return { eligible: false, reason: `Cooldown: engram must be at least ${action.cooldown_days} days old (current: ${ageDays})` };
+    }
+  }
+  return { eligible: true };
+}
+function awardXP(profile, actionKey, actions, context) {
+  const eligibility = isActionEligible(profile, actionKey, actions, context);
+  if (!eligibility.eligible) return null;
+  const action = actions.actions[actionKey];
+  const { effective } = getEffectiveMultiplier(profile);
+  const baseXP = action.xp;
+  const earnedXP = Math.round(baseXP * effective);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const today = now.split("T")[0];
+  const event = {
+    action_key: actionKey,
+    xp_base: baseXP,
+    multiplier: effective,
+    xp_earned: earnedXP,
+    timestamp: now,
+    context
+  };
+  const updated = JSON.parse(JSON.stringify(profile));
+  updated.xp.total += earnedXP;
+  updated.xp.this_week += earnedXP;
+  let todayEntry = updated.xp.history.find((h) => h.date === today);
+  if (!todayEntry) {
+    todayEntry = { date: today, earned: 0, base_earned: 0, multiplier: effective, actions: [] };
+    updated.xp.history.push(todayEntry);
+  }
+  todayEntry.earned += earnedXP;
+  todayEntry.base_earned += baseXP;
+  todayEntry.actions.push(actionKey);
+  if (actionKey === "engram_created" || actionKey === "engram_created_public") {
+    updated.stats.total_engrams_created++;
+  }
+  if (actionKey === "feedback_given") {
+    updated.stats.total_feedback_given++;
+  }
+  if (actionKey === "engram_retired") {
+    updated.stats.total_engrams_retired++;
+  }
+  if (actionKey === "pack_exported") {
+    updated.stats.total_packs_exported++;
+  }
+  if (actionKey === "new_domain") {
+    updated.stats.domains_covered++;
+  }
+  if (!updated.stats.first_activity) {
+    updated.stats.first_activity = today;
+  }
+  return { event, profile: updated };
+}
+function updateConsistency(profile) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  if (updated.consistency.last_active === today) return updated;
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+  const cutoff = thirtyDaysAgo.toISOString().split("T")[0];
+  const activeDays = updated.xp.history.filter((h) => h.date >= cutoff && h.date <= today).length;
+  updated.consistency.active_days_30 = activeDays;
+  updated.consistency.last_active = today;
+  const sortedDates = updated.xp.history.map((h) => h.date).sort();
+  let currentRun = 1;
+  let bestRun = updated.consistency.best_run;
+  for (let i = 1; i < sortedDates.length; i++) {
+    const prev = new Date(sortedDates[i - 1]);
+    const curr = new Date(sortedDates[i]);
+    const diffDays = Math.round((curr.getTime() - prev.getTime()) / 864e5);
+    if (diffDays === 1) {
+      currentRun++;
+      if (currentRun > bestRun) bestRun = currentRun;
+    } else if (diffDays > 1) {
+      currentRun = 1;
+    }
+  }
+  updated.consistency.best_run = bestRun;
+  return updated;
+}
+
+// src/engagement/multipliers.ts
+function evaluateMultipliers(profile) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const multipliers = [];
+  if (profile.identity.erc8004_registered) {
+    multipliers.push({ type: "verified", factor: 1.5, since: today });
+  }
+  if (profile.stats.total_packs_exported >= 3 && profile.stats.total_feedback_received >= 20 && profile.stats.feedback_positive_ratio >= 0.85) {
+    multipliers.push({ type: "top_teacher", factor: 1.25, since: today });
+  }
+  if (profile.reconsolidation.total_resolved >= 5 && profile.discoveries.total >= 3 && profile.reconsolidation.response_rate >= 0.8 && profile.discoveries.explore_rate >= 0.5) {
+    multipliers.push({ type: "top_learner", factor: 1.25, since: today });
+  }
+  return multipliers;
+}
+function recalculateWeekly(profile) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  const newMultipliers = evaluateMultipliers(updated);
+  updated.multipliers.active = newMultipliers;
+  let effective = 1;
+  for (const m of newMultipliers) {
+    effective *= m.factor;
+  }
+  updated.multipliers.effective = effective;
+  const now = /* @__PURE__ */ new Date();
+  const day = now.getDay();
+  const diff = day === 0 ? 6 : day - 1;
+  const weekStart = new Date(now);
+  weekStart.setDate(weekStart.getDate() - diff);
+  weekStart.setHours(0, 0, 0, 0);
+  const weekStartStr = weekStart.toISOString().split("T")[0];
+  updated.xp.this_week = updated.xp.history.filter((h) => h.date >= weekStartStr).reduce((sum, h) => sum + h.earned, 0);
+  return updated;
+}
+
+// src/engagement/reputation.ts
+function calculateReputation(profile) {
+  const feedbackCount = profile.stats.total_feedback_given;
+  const feedbackQuality = feedbackCount > 0 ? Math.min(1, profile.stats.feedback_positive_ratio * (Math.log(feedbackCount) / Math.log(100))) : 0;
+  const verificationBonus = profile.identity.erc8004_registered ? 1 : 0;
+  const stakeSignal = 0;
+  const totalResolved = profile.reconsolidation.total_resolved;
+  const curationHonesty = totalResolved >= 5 ? (profile.reconsolidation.outcomes.revised + profile.reconsolidation.outcomes.retired) / totalResolved : 0;
+  let tenureDays = 0;
+  if (profile.stats.first_activity) {
+    const first = new Date(profile.stats.first_activity);
+    tenureDays = Math.max(0, Math.floor((Date.now() - first.getTime()) / 864e5));
+  }
+  const tenureSignal = tenureDays > 0 ? Math.min(1, Math.log(tenureDays) / Math.log(365)) : 0;
+  const domainBreadth = Math.min(1, profile.stats.domains_covered / 10);
+  const conflictPenalty = 0;
+  const score = 0.3 * feedbackQuality + 0.25 * verificationBonus + 0.15 * stakeSignal + 0.15 * curationHonesty + 0.1 * tenureSignal + 0.05 * domainBreadth - 0.5 * conflictPenalty;
+  return Math.max(0, score);
+}
+function updateReputation(profile) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  const score = calculateReputation(updated);
+  updated.reputation.score = Math.round(score * 100) / 100;
+  updated.reputation.last_calculated = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return updated;
+}
+
+// src/engagement/migrate.ts
+function calculateRetroactiveXP(engrams) {
+  const quality = engrams.filter((e) => e.status === "active");
+  const qualityCount = quality.length;
+  const publicCount = quality.filter((e) => e.visibility === "public" || e.visibility === "template").length;
+  let totalPositiveFeedback = 0;
+  let totalFeedbackGiven = 0;
+  for (const e of engrams) {
+    totalPositiveFeedback += e.feedback_signals?.positive ?? 0;
+    totalFeedbackGiven += (e.feedback_signals?.positive ?? 0) + (e.feedback_signals?.negative ?? 0) + (e.feedback_signals?.neutral ?? 0);
+  }
+  const domains = new Set(engrams.filter((e) => e.domain).map((e) => e.domain));
+  const domainCount = domains.size;
+  const packsExported = 0;
+  return qualityCount * 10 + publicCount * 10 + totalPositiveFeedback * 5 + totalFeedbackGiven * 5 + domainCount * 20 + packsExported * 25;
+}
+function migrateProfile(basePath, engrams) {
+  ensureEngagementDir(basePath);
+  const profile = createDefaultProfile();
+  const retroXP = calculateRetroactiveXP(engrams);
+  profile.xp.total = retroXP;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const tierResult = resolveTier(profile);
+  profile.tier.current = tierResult.current;
+  if (tierResult.current !== "Seed") {
+    profile.tier.achieved_at = today;
+    profile.tier.history.push({ tier: tierResult.current, date: today });
+  }
+  const active = engrams.filter((e) => e.status === "active");
+  profile.stats.total_engrams_created = active.length;
+  profile.stats.domains_covered = new Set(engrams.filter((e) => e.domain).map((e) => e.domain)).size;
+  profile.stats.public_engrams = active.filter((e) => e.visibility === "public" || e.visibility === "template").length;
+  profile.stats.first_activity = today;
+  writeDefaultActions(basePath);
+  saveProfile(basePath, profile);
+  logger.info(`Engagement migration: ${retroXP} retroactive XP \u2192 ${profile.tier.current} tier`);
+  return profile;
+}
+
+// src/engagement/service.ts
+var EngagementService = class {
+  constructor(basePath, config) {
+    this.basePath = basePath;
+    this.config = config;
+  }
+  profile = null;
+  sessionEvents = [];
+  dirty = false;
+  sessionActive = false;
+  actions = null;
+  initialized = false;
+  isEnabled() {
+    return this.config.enabled;
+  }
+  async init() {
+    if (!this.isEnabled() || this.initialized) return;
+    ensureEngagementDir(this.basePath);
+    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)) {
+        const engrams = loadEngrams(actualEngramsPath);
+        if (engrams.length > 0) {
+          this.profile = migrateProfile(this.basePath, engrams);
+        } else {
+          this.profile = loadProfile(this.basePath);
+        }
+      } else {
+        this.profile = loadProfile(this.basePath);
+      }
+    } else {
+      this.profile = loadProfile(this.basePath);
+    }
+    this.actions = loadActions(this.basePath);
+    this.initialized = true;
+  }
+  async award(actionKey, context) {
+    if (!this.isEnabled()) return null;
+    if (!this.initialized) await this.init();
+    if (!this.profile || !this.actions) return null;
+    const result = awardXP(this.profile, actionKey, this.actions, context);
+    if (!result) return null;
+    this.profile = result.profile;
+    this.sessionEvents.push(result.event);
+    this.dirty = true;
+    const tierResult = resolveTier(this.profile);
+    let tierChange = null;
+    if (tierResult.changed) {
+      this.profile.tier.current = tierResult.current;
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      this.profile.tier.achieved_at = today;
+      this.profile.tier.history.push({ tier: tierResult.current, date: today });
+      tierChange = {
+        from: this.profile.tier.history.length > 1 ? this.profile.tier.history[this.profile.tier.history.length - 2].tier : "Seed",
+        to: tierResult.current,
+        message: tierResult.message
+      };
+    }
+    if (!this.sessionActive) {
+      await this.flush();
+    }
+    return { event: result.event, tier_change: tierChange };
+  }
+  async flush() {
+    if (!this.dirty || !this.profile) return;
+    this.profile = updateConsistency(this.profile);
+    this.profile = recalculateWeekly(this.profile);
+    this.profile = updateReputation(this.profile);
+    saveProfile(this.basePath, this.profile);
+    this.dirty = false;
+  }
+  getSessionSummary() {
+    const actions = {};
+    let totalXP = 0;
+    let baseXP = 0;
+    for (const event of this.sessionEvents) {
+      totalXP += event.xp_earned;
+      baseXP += event.xp_base;
+      actions[event.action_key] = (actions[event.action_key] ?? 0) + 1;
+    }
+    return {
+      total_xp: totalXP,
+      base_xp: baseXP,
+      multiplier: this.profile?.multipliers.effective ?? 1,
+      events: [...this.sessionEvents],
+      actions
+    };
+  }
+  getProfile() {
+    if (!this.isEnabled()) return null;
+    return this.profile;
+  }
+  markSessionActive() {
+    this.sessionActive = true;
+    this.sessionEvents = [];
+  }
+  markSessionEnded() {
+    this.sessionActive = false;
+  }
+  /**
+   * Apply a profile transformation (e.g., from resolve, expire, challenge generation).
+   * Marks profile dirty so next flush persists changes.
+   */
+  applyProfileUpdate(updater) {
+    if (!this.profile) return;
+    this.profile = updater(this.profile);
+    this.dirty = true;
+  }
+};
+
+// src/engagement/reconsolidation.ts
+function resolveReconsolidation(profile, engramId, outcome) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  const idx = updated.reconsolidation.pending.findIndex(
+    (p) => p.engram_id === engramId || p.contradicting_id === engramId
+  );
+  if (idx === -1) return updated;
+  updated.reconsolidation.pending.splice(idx, 1);
+  updated.reconsolidation.total_resolved++;
+  if (outcome === "defend") updated.reconsolidation.outcomes.defended++;
+  else if (outcome === "revise") updated.reconsolidation.outcomes.revised++;
+  else if (outcome === "retire") updated.reconsolidation.outcomes.retired++;
+  else if (outcome === "dismiss") updated.reconsolidation.outcomes.dismissed++;
+  const totalOutcomes = updated.reconsolidation.outcomes.defended + updated.reconsolidation.outcomes.revised + updated.reconsolidation.outcomes.retired;
+  const totalAll = totalOutcomes + updated.reconsolidation.outcomes.dismissed;
+  updated.reconsolidation.response_rate = totalAll > 0 ? totalOutcomes / totalAll : 0;
+  return updated;
+}
+function expireReconsolidations(profile) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const expired = [];
+  const remaining = [];
+  for (const pending of updated.reconsolidation.pending) {
+    if (pending.expires_at <= now) {
+      expired.push(pending);
+    } else {
+      remaining.push(pending);
+    }
+  }
+  if (expired.length === 0) return updated;
+  updated.reconsolidation.pending = remaining;
+  for (const _entry of expired) {
+    updated.xp.total += 3;
+    updated.reconsolidation.total_resolved++;
+    updated.reconsolidation.outcomes.retired++;
+  }
+  const totalOutcomes = updated.reconsolidation.outcomes.defended + updated.reconsolidation.outcomes.revised + updated.reconsolidation.outcomes.retired;
+  const totalAll = totalOutcomes + updated.reconsolidation.outcomes.dismissed;
+  updated.reconsolidation.response_rate = totalAll > 0 ? totalOutcomes / totalAll : 0;
+  return updated;
+}
+
+// src/engagement/discovery.ts
+var MIN_ENGRAMS = 20;
+var MIN_DOMAINS = 3;
+var MIN_DAYS_BETWEEN_DISCOVERIES = 2;
+function extractKeywords(statement) {
+  const stopwords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "it",
+    "its",
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "by",
+    "with"
+  ]);
+  const tokens = statement.toLowerCase().split(/\s+|[.,;:!?()[\]{}]/).filter((t) => t.length > 0 && !stopwords.has(t));
+  return new Set(tokens);
+}
+function daysBetween(dateA, dateB) {
+  const a = new Date(dateA);
+  const b = new Date(dateB);
+  return Math.abs(a.getTime() - b.getTime()) / (1e3 * 60 * 60 * 24);
+}
+function generateDiscoveryCandidates(engrams, profile) {
+  if (engrams.length < MIN_ENGRAMS) return [];
+  const domains = new Set(engrams.map((e) => e.domain).filter(Boolean));
+  if (domains.size < MIN_DOMAINS) return [];
+  if (profile.discoveries.last_offered) {
+    const daysSinceLast = daysBetween(
+      profile.discoveries.last_offered,
+      (/* @__PURE__ */ new Date()).toISOString()
+    );
+    if (daysSinceLast < MIN_DAYS_BETWEEN_DISCOVERIES) return [];
+  }
+  const withDomains = engrams.filter(
+    (e) => e.domain && e.status === "active"
+  );
+  const keywordMap = /* @__PURE__ */ new Map();
+  for (const e of withDomains) {
+    keywordMap.set(e.id, extractKeywords(e.statement));
+  }
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < withDomains.length; i++) {
+    for (let j = i + 1; j < withDomains.length; j++) {
+      const a = withDomains[i];
+      const b = withDomains[j];
+      if (a.domain === b.domain) continue;
+      const pairKey = [a.id, b.id].sort().join(":");
+      if (seen.has(pairKey)) continue;
+      seen.add(pairKey);
+      const kwA = keywordMap.get(a.id);
+      const kwB = keywordMap.get(b.id);
+      const intersection = new Set([...kwA].filter((x) => kwB.has(x)));
+      if (intersection.size === 0) continue;
+      candidates.push({
+        engram_a: { id: a.id, domain: a.domain, statement: a.statement },
+        engram_b: { id: b.id, domain: b.domain, statement: b.statement },
+        overlap_size: intersection.size
+      });
+    }
+  }
+  candidates.sort((a, b) => b.overlap_size - a.overlap_size);
+  return candidates;
+}
+function offerDiscovery(profile, discovery) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = `disc-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  const entry = {
+    id,
+    engram_a: discovery.engram_a,
+    engram_b: discovery.engram_b,
+    connection: discovery.connection,
+    offered_at: now
+  };
+  updated.discoveries.pending.push(entry);
+  updated.discoveries.total++;
+  updated.discoveries.last_offered = now;
+  return updated;
+}
+function resolveDiscovery(profile, discoveryId, action) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  const idx = updated.discoveries.pending.findIndex((d) => d.id === discoveryId);
+  if (idx === -1) return updated;
+  updated.discoveries.pending.splice(idx, 1);
+  if (action === "explore") {
+    updated.discoveries.explored++;
+  } else {
+    updated.discoveries.noted++;
+  }
+  const totalResolved = updated.discoveries.explored + updated.discoveries.noted;
+  updated.discoveries.explore_rate = totalResolved > 0 ? updated.discoveries.explored / totalResolved : 0;
+  return updated;
+}
+
+// src/engagement/challenges.ts
+var GETTING_STARTED_CHALLENGES = [
+  {
+    type: "first_steps",
+    tier: "Seed",
+    description: "Create your first engram",
+    metric: "total_engrams_created",
+    target_delta: 5,
+    bonus_xp: 15
+  },
+  {
+    type: "first_feedback",
+    tier: "Seed",
+    description: "Give feedback",
+    metric: "total_feedback_given",
+    target_delta: 3,
+    bonus_xp: 10
+  },
+  {
+    type: "explore_domain",
+    tier: "Seed",
+    description: "Explore a new domain",
+    metric: "domains_covered",
+    target_delta: 1,
+    bonus_xp: 10
+  }
+];
+var REGULAR_CHALLENGES = [
+  {
+    type: "first_steps",
+    tier: "Seed",
+    description: "Create your first engram",
+    metric: "total_engrams_created",
+    target_delta: 5,
+    bonus_xp: 15
+  },
+  {
+    type: "first_feedback",
+    tier: "Seed",
+    description: "Give feedback",
+    metric: "total_feedback_given",
+    target_delta: 3,
+    bonus_xp: 10
+  },
+  {
+    type: "domain_deep_dive",
+    tier: "Cipher",
+    description: "Deep dive into a new domain",
+    metric: "domains_covered",
+    target_delta: 1,
+    bonus_xp: 15
+  },
+  {
+    type: "synthesis",
+    tier: "Sage",
+    description: "Synthesize knowledge across domains",
+    metric: "domains_covered",
+    target_delta: 2,
+    bonus_xp: 20
+  },
+  {
+    type: "mentorship",
+    tier: "Adept",
+    description: "Share your knowledge by exporting a pack",
+    metric: "total_packs_exported",
+    target_delta: 1,
+    bonus_xp: 25
+  },
+  {
+    type: "impact",
+    tier: "Visionary",
+    description: "Achieve a high positive feedback ratio",
+    metric: "feedback_positive_ratio",
+    target_delta: 0.85,
+    bonus_xp: 25
+  },
+  {
+    type: "network",
+    tier: "Oracle",
+    description: "Build your feedback network",
+    metric: "total_feedback_received",
+    target_delta: 10,
+    bonus_xp: 30
+  }
+];
+var TIER_ORDER = {
+  Seed: 0,
+  Cipher: 1,
+  Sage: 2,
+  Adept: 3,
+  Visionary: 4,
+  Oracle: 5
+};
+function tierRank(tier) {
+  return TIER_ORDER[tier] ?? 0;
+}
+var WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
+var GETTING_STARTED_THRESHOLD = 10;
+function generateChallenge(profile) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  if (updated.challenges.active) return updated;
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + WEEK_MS);
+  const currentTierRank = tierRank(updated.tier.current);
+  let pool;
+  if (updated.stats.total_engrams_created < GETTING_STARTED_THRESHOLD && !updated.challenges.graduated) {
+    const completedTypes = new Set(
+      updated.challenges.history.filter((h) => h.completed).map((h) => h.type)
+    );
+    pool = GETTING_STARTED_CHALLENGES.filter((c) => !completedTypes.has(c.type));
+    if (pool.length === 0) {
+      updated.challenges.graduated = true;
+      pool = REGULAR_CHALLENGES.filter((c) => tierRank(c.tier) <= currentTierRank);
+    }
+  } else {
+    pool = REGULAR_CHALLENGES.filter((c) => tierRank(c.tier) <= currentTierRank);
+  }
+  if (pool.length === 0) return updated;
+  const recentTypes = new Set(
+    updated.challenges.history.slice(-3).map((h) => h.type)
+  );
+  let chosen = pool.find((c) => !recentTypes.has(c.type));
+  if (!chosen) chosen = pool[0];
+  const baselineStats = {};
+  for (const [key, value] of Object.entries(updated.stats)) {
+    if (typeof value === "number") {
+      baselineStats[key] = value;
+    }
+  }
+  const id = `chal-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  const challenge = {
+    id,
+    type: chosen.type,
+    tier: chosen.tier,
+    description: chosen.description,
+    criteria: {
+      metric: chosen.metric,
+      target_delta: chosen.target_delta
+    },
+    baseline_stats: baselineStats,
+    bonus_xp: chosen.bonus_xp,
+    started_at: now.toISOString(),
+    expires_at: expiresAt.toISOString()
+  };
+  updated.challenges.active = challenge;
+  return updated;
+}
+function checkChallengeCompletion(profile, challenge) {
+  const metric = challenge.criteria.metric;
+  const targetDelta = challenge.criteria.target_delta;
+  const baselineValue = challenge.baseline_stats[metric] ?? 0;
+  if (metric === "feedback_positive_ratio") {
+    const currentValue2 = profile.stats[metric] ?? 0;
+    return currentValue2 >= targetDelta;
+  }
+  const currentValue = profile.stats[metric] ?? 0;
+  const delta = currentValue - baselineValue;
+  return delta >= targetDelta;
+}
+function resolveChallenge(profile, challengeId) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  if (!updated.challenges.active || updated.challenges.active.id !== challengeId) {
+    return updated;
+  }
+  const challenge = updated.challenges.active;
+  if (!checkChallengeCompletion(updated, challenge)) {
+    return updated;
+  }
+  updated.xp.total += challenge.bonus_xp;
+  const entry = {
+    type: challenge.type,
+    tier: challenge.tier,
+    completed: true,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  };
+  updated.challenges.history.push(entry);
+  updated.challenges.completed++;
+  updated.challenges.active = null;
+  return updated;
+}
+function dismissChallenge(profile, challengeId) {
+  const updated = JSON.parse(JSON.stringify(profile));
+  if (!updated.challenges.active || updated.challenges.active.id !== challengeId) {
+    return updated;
+  }
+  const challenge = updated.challenges.active;
+  const entry = {
+    type: challenge.type,
+    tier: challenge.tier,
+    completed: false,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  };
+  updated.challenges.history.push(entry);
+  updated.challenges.dismissed++;
+  updated.challenges.active = null;
+  return updated;
+}
+
+// src/tools/session-start.ts
+async function handleSessionStart(args2, storage2, bridge, engagementService2) {
+  const session_id = crypto2.randomUUID();
   let engrams = null;
   if (args2.task) {
     const injectResult = await handleInject(
-      { prompt: args2.task, scope: args2.tags?.length ? `tags:${args2.tags.join(",")}` : void 0 },
-      { engramsPath: storage2.engramsPath, packsPath: storage2.packsPath }
+      { prompt: args2.task, session_id, scope: args2.tags?.length ? `tags:${args2.tags.join(",")}` : void 0 },
+      { engramsPath: storage2.engramsPath, packsPath: storage2.packsPath, basePath: storage2.basePath }
     );
     if (injectResult.count > 0) {
       engrams = { text: injectResult.text, count: injectResult.count };
     }
   }
   const { date: today } = localDate();
-  const journalFile = path14.join(storage2.journalPath, `${today}.md`);
-  const journal_today = fs15.existsSync(journalFile) ? fs15.readFileSync(journalFile, "utf8") : null;
+  const journalFile = path18.join(storage2.journalPath, `${today}.md`);
+  const journal_today = fs18.existsSync(journalFile) ? fs18.readFileSync(journalFile, "utf8") : null;
   const allEngrams = loadEngrams(storage2.engramsPath);
   const pending_candidates = allEngrams.filter((e) => e.status === "candidate").length;
   const recommendations = [];
@@ -2028,7 +3477,79 @@ async function handleSessionStart(args2, storage2, bridge) {
   });
   const activeCount = allEngrams.filter((e) => e.status === "active").length;
   const guide = activeCount === 0 ? SESSION_GUIDE_FULL : SESSION_GUIDE_SHORT;
-  return { engrams, journal_today, pending_candidates, recommendations, guide, _hints: hints };
+  let engagement;
+  if (engagementService2?.isEnabled()) {
+    try {
+      await engagementService2.init();
+      engagementService2.markSessionActive();
+      engagementService2.applyProfileUpdate((p) => expireReconsolidations(p));
+      const profileAfterExpire = engagementService2.getProfile();
+      if (profileAfterExpire?.challenges.active) {
+        if (checkChallengeCompletion(profileAfterExpire, profileAfterExpire.challenges.active)) {
+          engagementService2.applyProfileUpdate((p) => resolveChallenge(p, p.challenges.active.id));
+        }
+      }
+      engagementService2.applyProfileUpdate((p) => generateChallenge(p));
+      const profileForDiscovery = engagementService2.getProfile();
+      if (profileForDiscovery) {
+        const candidates = generateDiscoveryCandidates(allEngrams, profileForDiscovery);
+        if (candidates.length > 0) {
+          const topCandidate = candidates[0];
+          engagementService2.applyProfileUpdate((p) => offerDiscovery(p, {
+            engram_a: topCandidate.engram_a,
+            engram_b: topCandidate.engram_b,
+            connection: `Shared concepts across ${topCandidate.engram_a.domain} and ${topCandidate.engram_b.domain}`
+          }));
+        }
+      }
+      const profile = engagementService2.getProfile();
+      if (profile) {
+        const displayLines = [formatSessionStart(profile)];
+        for (const recon of profile.reconsolidation.pending.slice(0, 2)) {
+          displayLines.push("");
+          displayLines.push(formatReconsolidation({
+            engram_id: recon.engram_id,
+            statement: recon.statement,
+            contradiction: recon.contradiction,
+            evidence_strength: recon.evidence_strength
+          }));
+        }
+        for (const disc of profile.discoveries.pending.slice(0, 1)) {
+          displayLines.push("");
+          displayLines.push(formatDiscovery({
+            id: disc.id,
+            engram_a: disc.engram_a,
+            engram_b: disc.engram_b,
+            connection: disc.connection
+          }));
+        }
+        if (profile.challenges.active) {
+          displayLines.push("");
+          displayLines.push(formatChallenge({
+            id: profile.challenges.active.id,
+            description: profile.challenges.active.description,
+            bonus_xp: profile.challenges.active.bonus_xp,
+            expires_at: profile.challenges.active.expires_at
+          }));
+        }
+        engagement = {
+          tier: profile.tier.current,
+          xp: profile.xp.total,
+          multiplier: profile.multipliers.effective,
+          active_challenge: profile.challenges.active ? {
+            id: profile.challenges.active.id,
+            description: profile.challenges.active.description,
+            expires_at: profile.challenges.active.expires_at
+          } : null,
+          pending_reconsolidations: profile.reconsolidation.pending.length,
+          pending_discoveries: profile.discoveries.pending.length,
+          display: displayLines.join("\n")
+        };
+      }
+    } catch {
+    }
+  }
+  return { session_id, engrams, journal_today, pending_candidates, recommendations, guide, engagement, _hints: hints };
 }
 var SESSION_GUIDE_FULL = `## Datacore Quick Start
 
@@ -2057,7 +3578,7 @@ 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) {
+async function handleSessionEnd(args2, storage2, engagementService2) {
   const captureResult = await handleCapture(
     { type: "journal", content: args2.summary, tags: args2.tags },
     storage2
@@ -2067,16 +3588,34 @@ async function handleSessionEnd(args2, storage2) {
     for (const suggestion of args2.engram_suggestions) {
       await handleLearn(
         { statement: suggestion.statement, type: suggestion.type },
-        storage2.engramsPath
+        storage2.engramsPath,
+        engagementService2
       );
       engramsCreated++;
     }
   }
   const autoPromote = getConfig().engrams.auto_promote;
   const statusLabel = autoPromote ? "active" : "candidates";
+  let engagement = void 0;
+  if (engagementService2?.isEnabled()) {
+    try {
+      const sessionSummary = engagementService2.getSessionSummary();
+      await engagementService2.flush();
+      engagementService2.markSessionEnded();
+      const profile = engagementService2.getProfile();
+      engagement = {
+        session_xp: sessionSummary.total_xp,
+        total_xp: profile?.xp.total ?? 0,
+        tier: profile?.tier.current ?? "Seed",
+        display: profile ? formatSessionEnd(profile, sessionSummary.total_xp, sessionSummary.events) : ""
+      };
+    } catch {
+    }
+  }
   return {
     journal_path: captureResult.path ?? null,
     engrams_created: engramsCreated,
+    engagement,
     _hints: buildHints({
       next: engramsCreated > 0 ? `Session captured. ${engramsCreated} engram(s) created as ${statusLabel}.` : "Session captured.",
       related: ["datacore.session.start", "datacore.status"]
@@ -2160,7 +3699,7 @@ async function handleRecall(args2, storage2, bridge) {
 }
 
 // src/tools/promote.ts
-async function handlePromote(args2, engramsPath) {
+async function handlePromote(args2, engramsPath, service) {
   const targetIds = args2.ids ?? (args2.id ? [args2.id] : []);
   if (targetIds.length === 0) {
     return {
@@ -2199,6 +3738,14 @@ async function handlePromote(args2, engramsPath) {
   }
   if (promoted.length > 0) {
     atomicWriteYaml(engramsPath, { engrams });
+    if (service?.isEnabled()) {
+      try {
+        for (const _ of promoted) {
+          await service.award("engram_promoted", {});
+        }
+      } catch {
+      }
+    }
   }
   return {
     success: errors.length === 0,
@@ -2211,14 +3758,169 @@ async function handlePromote(args2, engramsPath) {
   };
 }
 
+// src/tools/resolve.ts
+async function handleResolve(args2, engramsPath, service) {
+  if (!service?.isEnabled()) {
+    return { success: false, type: args2.type, action: args2.action, error: "Engagement system is disabled" };
+  }
+  const profile = service.getProfile();
+  if (!profile) {
+    return { success: false, type: args2.type, action: args2.action, error: "No engagement profile loaded" };
+  }
+  try {
+    switch (args2.type) {
+      case "reconsolidation":
+        return await handleReconsolidationResolve(args2, engramsPath, service);
+      case "discovery":
+        return await handleDiscoveryResolve(args2, service);
+      case "challenge":
+        return handleChallengeResolve(args2, service);
+      default:
+        return { success: false, type: args2.type, action: args2.action, error: `Unknown resolve type: ${args2.type}` };
+    }
+  } catch (err) {
+    return { success: false, type: args2.type, action: args2.action, error: `${err}` };
+  }
+}
+async function handleReconsolidationResolve(args2, engramsPath, service) {
+  const profile = service.getProfile();
+  const pending = profile.reconsolidation.pending.find(
+    (r) => r.engram_id === args2.id || r.contradicting_id === args2.id
+  );
+  if (!pending) {
+    return { success: false, type: "reconsolidation", action: args2.action, error: `No pending reconsolidation for engram ${args2.id}` };
+  }
+  const validActions = ["defend", "revise", "retire", "dismiss"];
+  if (!validActions.includes(args2.action)) {
+    return { success: false, type: "reconsolidation", action: args2.action, error: `Invalid action. Must be one of: ${validActions.join(", ")}` };
+  }
+  if (args2.action === "revise" && !args2.revised_statement) {
+    return { success: false, type: "reconsolidation", action: args2.action, error: "revised_statement is required for revise action" };
+  }
+  if (args2.action === "revise") {
+    const engrams = loadEngrams(engramsPath);
+    const engram = engrams.find((e) => e.id === args2.id);
+    if (engram) {
+      engram.statement = args2.revised_statement;
+      saveEngrams(engramsPath, engrams);
+    }
+  } else if (args2.action === "retire") {
+    const engrams = loadEngrams(engramsPath);
+    const engram = engrams.find((e) => e.id === args2.id);
+    if (engram) {
+      engram.status = "retired";
+      saveEngrams(engramsPath, engrams);
+    }
+  }
+  const outcome = args2.action;
+  service.applyProfileUpdate((p) => resolveReconsolidation(p, args2.id, outcome));
+  const xpActionMap = {
+    defend: "reconsolidation_defend",
+    revise: "reconsolidation_revise",
+    retire: "reconsolidation_retire",
+    dismiss: ""
+  };
+  let xpEarned = 0;
+  const xpAction = xpActionMap[args2.action];
+  if (xpAction) {
+    const result = await service.award(xpAction, {});
+    if (result) xpEarned = result.event.xp_earned;
+  }
+  const messages = {
+    defend: "Engram defended \u2014 both engrams retained.",
+    revise: "Engram revised with updated statement.",
+    retire: "Old engram retired.",
+    dismiss: "Contradiction dismissed as false positive."
+  };
+  return {
+    success: true,
+    type: "reconsolidation",
+    action: args2.action,
+    xp_earned: xpEarned,
+    message: messages[args2.action],
+    _hints: buildHints({
+      next: xpEarned > 0 ? `+${xpEarned} XP for reconsolidation.` : "Contradiction dismissed.",
+      related: ["datacore.status"]
+    })
+  };
+}
+async function handleDiscoveryResolve(args2, service) {
+  const profile = service.getProfile();
+  const pending = profile.discoveries.pending.find((d) => d.id === args2.id);
+  if (!pending) {
+    return { success: false, type: "discovery", action: args2.action, error: `No pending discovery ${args2.id}` };
+  }
+  const validActions = ["explore", "note"];
+  if (!validActions.includes(args2.action)) {
+    return { success: false, type: "discovery", action: args2.action, error: `Invalid action. Must be one of: ${validActions.join(", ")}` };
+  }
+  const action = args2.action;
+  service.applyProfileUpdate((p) => resolveDiscovery(p, args2.id, action));
+  let xpEarned = 0;
+  if (action === "explore") {
+    const result = await service.award("discovery_explore", {});
+    if (result) xpEarned = result.event.xp_earned;
+  }
+  return {
+    success: true,
+    type: "discovery",
+    action: args2.action,
+    xp_earned: xpEarned,
+    message: action === "explore" ? "Discovery explored \u2014 synthesis engram created." : "Discovery noted.",
+    _hints: buildHints({
+      next: xpEarned > 0 ? `+${xpEarned} XP for exploring discovery.` : "Discovery noted for later.",
+      related: ["datacore.status"]
+    })
+  };
+}
+function handleChallengeResolve(args2, service) {
+  const profile = service.getProfile();
+  if (!profile.challenges.active || profile.challenges.active.id !== args2.id) {
+    return { success: false, type: "challenge", action: args2.action, error: `No active challenge with id ${args2.id}` };
+  }
+  if (args2.action === "complete") {
+    if (!checkChallengeCompletion(profile, profile.challenges.active)) {
+      return { success: false, type: "challenge", action: "complete", error: "Challenge criteria not yet met" };
+    }
+    service.applyProfileUpdate((p) => resolveChallenge(p, args2.id));
+    const bonusXP = profile.challenges.active.bonus_xp;
+    return {
+      success: true,
+      type: "challenge",
+      action: "complete",
+      xp_earned: bonusXP,
+      message: `Challenge completed! +${bonusXP} bonus XP.`,
+      _hints: buildHints({
+        next: `+${bonusXP} XP bonus for completing the challenge.`,
+        related: ["datacore.status"]
+      })
+    };
+  }
+  if (args2.action === "dismiss") {
+    service.applyProfileUpdate((p) => dismissChallenge(p, args2.id));
+    return {
+      success: true,
+      type: "challenge",
+      action: "dismiss",
+      xp_earned: 0,
+      message: "Challenge dismissed \u2014 no penalty.",
+      _hints: buildHints({
+        next: "A new challenge will be offered next week.",
+        related: ["datacore.status"]
+      })
+    };
+  }
+  return { success: false, type: "challenge", action: args2.action, error: 'Invalid action. Must be "complete" or "dismiss".' };
+}
+
 // src/resources.ts
 import {
   ListResourcesRequestSchema,
   ReadResourceRequestSchema,
   ListResourceTemplatesRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs19 from "fs";
+import * as path19 from "path";
 function registerResources(server, storage2) {
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
@@ -2299,11 +4001,11 @@ function registerResources(server, storage2) {
     const journalMatch = uri.match(/^datacore:\/\/journal\/(.+)$/);
     if (journalMatch) {
       const dateStr = journalMatch[1] === "today" ? localDate().date : journalMatch[1];
-      const filePath = path15.join(storage2.journalPath, `${dateStr}.md`);
-      if (!fs16.existsSync(filePath)) {
+      const filePath = path19.join(storage2.journalPath, `${dateStr}.md`);
+      if (!fs19.existsSync(filePath)) {
         return { contents: [{ uri, mimeType: "text/markdown", text: `No journal entry for ${dateStr}` }] };
       }
-      return { contents: [{ uri, mimeType: "text/markdown", text: fs16.readFileSync(filePath, "utf8") }] };
+      return { contents: [{ uri, mimeType: "text/markdown", text: fs19.readFileSync(filePath, "utf8") }] };
     }
     const engramMatch = uri.match(/^datacore:\/\/engrams\/(.+)$/);
     if (engramMatch) {
@@ -2549,8 +4251,8 @@ function registerPrompts(server) {
 
 // src/datacortex.ts
 import { execFile } from "child_process";
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs20 from "fs";
+import * as path20 from "path";
 var DatacortexBridge = class {
   pythonPath;
   scriptPath;
@@ -2560,11 +4262,11 @@ var DatacortexBridge = class {
   }
   findBridgeScript(datacorePath) {
     const candidates = [
-      path16.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
-      path16.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
+      path20.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
+      path20.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
     ];
     for (const candidate of candidates) {
-      if (fs17.existsSync(candidate)) return candidate;
+      if (fs20.existsSync(candidate)) return candidate;
     }
     return null;
   }
@@ -2624,6 +4326,14 @@ var discoveredModules = [];
 var isFirstRun = false;
 var serverRef = null;
 var datacortexBridge = null;
+var engagementService = null;
+function getEngagementService() {
+  if (!engagementService || engagementService.basePath !== storage.basePath) {
+    const config = getConfig();
+    engagementService = new EngagementService(storage.basePath, config.engagement);
+  }
+  return engagementService;
+}
 function createServer() {
   const server = new Server(
     { name: "datacore-mcp", version: currentVersion },
@@ -2672,7 +4382,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"]);
+var ENGRAM_MUTATING_TOOLS = /* @__PURE__ */ new Set(["datacore.learn", "datacore.forget", "datacore.feedback", "datacore.session.end", "datacore.promote", "datacore.resolve"]);
 async function routeTool(name, args2) {
   const coreTool = TOOLS.find((t) => t.name === name);
   if (coreTool) {
@@ -2683,10 +4393,10 @@ async function routeTool(name, args2) {
         result = await handleCapture(validated, storage);
         break;
       case "datacore.learn":
-        result = await handleLearn(validated, storage.engramsPath);
+        result = await handleLearn(validated, storage.engramsPath, getEngagementService());
         break;
       case "datacore.inject":
-        result = await handleInject(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath });
+        result = await handleInject(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath, basePath: storage.basePath });
         break;
       case "datacore.search":
         result = await handleSearch(validated, { journalPath: storage.journalPath, knowledgePath: storage.knowledgePath }, datacortexBridge);
@@ -2695,25 +4405,25 @@ async function routeTool(name, args2) {
         result = await handleIngest(validated, { knowledgePath: storage.knowledgePath, engramsPath: storage.engramsPath });
         break;
       case "datacore.status":
-        result = await handleStatus({ ...storage, engramsPath: storage.engramsPath, packsPath: storage.packsPath }, updateAvailable);
+        result = await handleStatus({ ...storage, engramsPath: storage.engramsPath, packsPath: storage.packsPath }, updateAvailable, getEngagementService());
         break;
       case "datacore.forget":
-        result = await handleForget(validated, storage.engramsPath);
+        result = await handleForget(validated, storage.engramsPath, getEngagementService());
         break;
       case "datacore.feedback":
-        result = await handleFeedback(validated, storage.engramsPath, storage.packsPath);
+        result = await handleFeedback(validated, storage.engramsPath, storage.packsPath, getEngagementService());
         break;
       case "datacore.session.start":
-        result = await handleSessionStart(validated, storage, datacortexBridge);
+        result = await handleSessionStart(validated, storage, datacortexBridge, getEngagementService());
         break;
       case "datacore.session.end":
-        result = await handleSessionEnd(validated, storage);
+        result = await handleSessionEnd(validated, storage, getEngagementService());
         break;
       case "datacore.recall":
         result = await handleRecall(validated, { engramsPath: storage.engramsPath, journalPath: storage.journalPath, knowledgePath: storage.knowledgePath }, datacortexBridge);
         break;
       case "datacore.promote":
-        result = await handlePromote(validated, storage.engramsPath);
+        result = await handlePromote(validated, storage.engramsPath, getEngagementService());
         break;
       case "datacore.packs.discover":
         result = handleDiscover(validated, storage.packsPath);
@@ -2722,7 +4432,10 @@ async function routeTool(name, args2) {
         result = await handleInstall(validated, storage.packsPath);
         break;
       case "datacore.packs.export":
-        result = await handleExport(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath });
+        result = await handleExport(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath }, getEngagementService());
+        break;
+      case "datacore.resolve":
+        result = await handleResolve(validated, storage.engramsPath, getEngagementService());
         break;
       case "datacore.modules.list":
         result = await handleModulesList(validated, storage, discoveredModules);