@datacore-one/mcp 1.2.0 → 1.3.0

package/dist/index.js

@@ -218,6 +218,10 @@ 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({})
 });
 var cachedConfig = null;
@@ -242,7 +246,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 +258,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",
@@ -473,6 +478,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")')
+    })
   }
 ];
 
@@ -769,7 +784,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;
@@ -798,6 +813,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,7 +845,7 @@ 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
@@ -1218,6 +1256,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 +1579,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");
@@ -1301,6 +1624,22 @@ async function handleStatus(paths, updateAvailable2) {
   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 +1649,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.",
@@ -1500,7 +1840,7 @@ function resolvePackId(packId, packsDir) {
 import * as fs12 from "fs";
 import * as path10 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");
@@ -1592,6 +1932,12 @@ Exported ${selected.length} engrams.
     path10.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 };
 }
 
@@ -1833,7 +2179,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 +2192,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 +2216,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;
@@ -1892,14 +2254,14 @@ function findEngram(engramId, engramsPath, packsPath) {
   }
   return null;
 }
-async function handleFeedback(args2, engramsPath, packsPath) {
+async function handleFeedback(args2, engramsPath, packsPath, service) {
   const pPath = packsPath ?? path13.join(path13.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 +2287,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 +2302,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 };
@@ -1982,6 +2350,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,9 +2371,856 @@ async function handleBatchFeedback(signals, engramsPath, packsPath) {
 }
 
 // src/tools/session-start.ts
+import * as fs18 from "fs";
+import * as path17 from "path";
+
+// src/engagement/service.ts
+import * as fs17 from "fs";
+import * as path16 from "path";
+
+// src/engagement/profile.ts
 import * as fs15 from "fs";
 import * as path14 from "path";
-async function handleSessionStart(args2, storage2, bridge) {
+import * as yaml7 from "js-yaml";
+var PROFILE_DIR = "engagement";
+var PROFILE_FILE = "profile.yaml";
+function engagementDir(basePath) {
+  return path14.join(basePath, ".datacore", PROFILE_DIR);
+}
+function profilePath(basePath) {
+  return path14.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 = path14.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 path15 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 = path15.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 = path15.join(basePath, ".datacore", "engagement");
+  const actionsPath = path15.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 = path16.join(this.basePath, ".datacore", "engagement", "profile.yaml");
+    const engramsPath = path16.join(this.basePath, ".datacore", "learning", "engrams.yaml");
+    const coreEngramsPath = path16.join(this.basePath, "engrams.yaml");
+    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) {
   let engrams = null;
   if (args2.task) {
     const injectResult = await handleInject(
@@ -2008,8 +3232,8 @@ async function handleSessionStart(args2, storage2, bridge) {
     }
   }
   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 = path17.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 +3252,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 { engrams, journal_today, pending_candidates, recommendations, guide, engagement, _hints: hints };
 }
 var SESSION_GUIDE_FULL = `## Datacore Quick Start
 
@@ -2057,7 +3353,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 +3363,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 +3474,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 +3513,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 +3533,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 path18 from "path";
 function registerResources(server, storage2) {
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
@@ -2299,11 +3776,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 = path18.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 +4026,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 path19 from "path";
 var DatacortexBridge = class {
   pythonPath;
   scriptPath;
@@ -2560,11 +4037,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")
+      path19.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
+      path19.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 +4101,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 +4157,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,7 +4168,7 @@ 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 });
@@ -2695,25 +4180,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 +4207,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);