@datacore-one/mcp 1.1.2 → 1.3.0

package/dist/index.js

@@ -68,7 +68,7 @@ function initCore(basePath) {
   }
   const configPath = path.join(basePath, "config.yaml");
   if (!fs.existsSync(configPath)) {
-    fs.writeFileSync(configPath, "# Datacore MCP configuration\nversion: 2\n# engrams:\n#   auto_promote: false\n# packs:\n#   trusted_publishers: []\n# search:\n#   max_results: 20\n#   snippet_length: 500\n# hints:\n#   enabled: true\n");
+    fs.writeFileSync(configPath, "# Datacore MCP configuration\nversion: 2\n# engrams:\n#   auto_promote: true  # engrams are active immediately (set false for manual review)\n# packs:\n#   trusted_publishers: []\n# search:\n#   max_results: 20\n#   snippet_length: 500\n# hints:\n#   enabled: true\n");
   }
   generateContextFiles(basePath);
   copyStarterPacks(basePath);
@@ -90,7 +90,15 @@ function generateContextFiles(basePath) {
   }
 }
 var DATACORE_GUIDE = `Datacore gives AI assistants persistent memory through **engrams** \u2014 typed knowledge units
-that get injected into context when relevant.
+that get injected into context when relevant. Use it proactively in every conversation.
+
+## Proactive Behavior
+
+Use Datacore tools automatically \u2014 do not wait to be asked:
+- **session.start**: Call at the beginning of every conversation
+- **learn**: Call when you discover patterns, preferences, insights, or corrections
+- **feedback**: Call after engrams are injected to rate usefulness
+- **session.end**: Call before the conversation ends
 
 ## Session Workflow
 
@@ -105,8 +113,7 @@ that get injected into context when relevant.
 |------|---------|
 | session.start | Start here. Begin session with context injection. |
 | session.end | End session, capture journal + new engrams. |
-| learn | Record a reusable insight (creates candidate engram). |
-| promote | Activate candidate engrams. |
+| learn | Record a reusable pattern, preference, or insight. |
 | inject | Get relevant engrams for a specific task. |
 | recall | Search all sources (engrams + journal + knowledge). |
 | capture | Write a journal entry or knowledge note. |
@@ -121,13 +128,11 @@ that get injected into context when relevant.
 
 ## Engram Lifecycle
 
-learn \u2192 candidate \u2192 promote \u2192 active \u2192 inject \u2192 feedback \u2192 stronger/weaker \u2192 forget (retire)
+learn \u2192 active \u2192 inject \u2192 feedback \u2192 stronger/weaker \u2192 forget (retire)
 
-- **candidate**: Created but not yet active. Won't appear in inject results.
 - **active**: Appears in inject results when relevant to the task.
 - **retired**: Permanently removed from injection.
-
-Positive feedback strengthens retrieval. Unused engrams naturally decay over time.
+- Positive feedback strengthens retrieval. Unused engrams naturally decay over time.
 
 ## Data Storage
 
@@ -202,7 +207,7 @@ import { z } from "zod";
 var ConfigSchema = z.object({
   version: z.number().default(2),
   engrams: z.object({
-    auto_promote: z.boolean().default(false)
+    auto_promote: z.boolean().default(true)
   }).default({}),
   packs: z.object({
     trusted_publishers: z.array(z.string()).default([])
@@ -213,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;
@@ -237,7 +246,7 @@ function getConfig() {
 // package.json
 var package_default = {
   name: "@datacore-one/mcp",
-  version: "1.1.2",
+  version: "1.3.0",
   description: "Datacore MCP server \u2014 The Software of You",
   type: "module",
   bin: {
@@ -249,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",
@@ -307,7 +317,7 @@ import { z as z2 } from "zod";
 var TOOLS = [
   {
     name: "datacore.capture",
-    description: "Capture a journal entry or knowledge note",
+    description: "Capture a journal entry or knowledge note. Call proactively to record important decisions, meeting outcomes, and significant events.",
     inputSchema: z2.object({
       type: z2.enum(["journal", "knowledge"]),
       content: z2.string().describe("Content to capture"),
@@ -317,7 +327,7 @@ var TOOLS = [
   },
   {
     name: "datacore.learn",
-    description: "Create an engram from a statement \u2014 record a reusable learning",
+    description: "Create an engram from a statement \u2014 record a reusable learning. Call proactively when you discover patterns, user preferences, project conventions, debugging insights, or corrections worth remembering across sessions.",
     inputSchema: z2.object({
       statement: z2.string().describe("The knowledge assertion"),
       type: z2.enum(["behavioral", "terminological", "procedural", "architectural"]).optional(),
@@ -329,7 +339,7 @@ var TOOLS = [
   },
   {
     name: "datacore.inject",
-    description: "Get relevant engrams for a task \u2014 returns directives and considerations",
+    description: "Get relevant engrams for a task \u2014 returns directives and considerations. Called automatically by session.start; call directly for mid-session context on a new topic.",
     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"),
@@ -386,7 +396,7 @@ var TOOLS = [
   },
   {
     name: "datacore.feedback",
-    description: "Signal whether an injected engram was helpful (positive), unhelpful (negative), or seen but not acted on (neutral). Supports single or batch mode.",
+    description: "Signal whether an injected engram was helpful (positive), unhelpful (negative), or seen but not acted on (neutral). Always call after session.start injects engrams \u2014 this trains the system. Supports single or batch mode.",
     inputSchema: z2.object({
       engram_id: z2.string().optional().describe("The engram ID to provide feedback on (single mode)"),
       signal: z2.enum(["positive", "negative", "neutral"]).optional().describe("Feedback signal (single mode)"),
@@ -421,7 +431,7 @@ var TOOLS = [
   },
   {
     name: "datacore.session.end",
-    description: "End a session \u2014 captures journal summary and creates engrams from suggestions",
+    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"),
       tags: z2.array(z2.string()).optional().describe("Tags for the journal entry"),
@@ -468,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")')
+    })
   }
 ];
 
@@ -764,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;
@@ -793,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.",
@@ -802,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
@@ -1213,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,
@@ -1251,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");
@@ -1296,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,
@@ -1305,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.",
@@ -1495,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");
@@ -1587,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 };
 }
 
@@ -1828,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);
@@ -1841,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) {
@@ -1857,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;
@@ -1887,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 {
@@ -1920,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,
@@ -1929,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 };
@@ -1977,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,
@@ -1989,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(
@@ -2003,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 = [];
@@ -2023,33 +3252,108 @@ 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
 
 Datacore gives you persistent memory through **engrams** \u2014 knowledge that gets injected into context when relevant.
 
+### Use Proactively
+- **learn** \u2014 call when you discover patterns, preferences, or insights
+- **feedback** \u2014 rate injected engrams after session.start
+- **session.end** \u2014 call before conversation ends to capture what was learned
+
 ### Session Workflow
 1. **session.start** (you just called this) \u2014 get context
 2. Work on your task. Use **recall** to search everything, **search** for files.
 3. **feedback** \u2014 rate which injected engrams helped (strengthens useful ones)
 4. **session.end** \u2014 capture summary + suggest new engrams
 
-### Key Tools
-- **learn** \u2014 record a reusable insight (creates candidate engram)
-- **promote** \u2014 activate candidate engrams so they appear in future sessions
+### Other Tools
 - **capture** \u2014 write a journal entry or knowledge note
 - **ingest** \u2014 import text and extract engram suggestions
 - **status** \u2014 system health and actionable recommendations
 - **forget** \u2014 retire an engram you no longer need
 
 ### How Engrams Work
-learn \u2192 candidate \u2192 promote \u2192 active \u2192 inject \u2192 feedback \u2192 stronger/weaker
+learn \u2192 active \u2192 inject \u2192 feedback \u2192 stronger/weaker
 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
@@ -2059,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"]
@@ -2152,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 {
@@ -2191,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,
@@ -2203,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: [
@@ -2291,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) {
@@ -2317,6 +3802,14 @@ function registerResources(server, storage2) {
 }
 var AGENT_GUIDE = `# Datacore Agent Guide
 
+## Use Proactively
+
+Use Datacore tools automatically \u2014 do not wait to be asked:
+- **session.start**: Call at the beginning of every conversation
+- **learn**: Call when you discover patterns, preferences, insights, or corrections
+- **feedback**: Call after engrams are injected to rate usefulness
+- **session.end**: Call before the conversation ends
+
 ## Session Lifecycle
 1. datacore.session.start \u2014 Get relevant engrams + today's context
 2. Work on task, use datacore.recall or datacore.search as needed
@@ -2324,11 +3817,11 @@ var AGENT_GUIDE = `# Datacore Agent Guide
 4. datacore.session.end \u2014 Capture summary + engram suggestions
 
 ## Engram Lifecycle
-- datacore.learn creates candidate engrams (or active if auto_promote enabled)
-- datacore.promote activates candidates so they appear in inject results
+- datacore.learn creates active engrams (immediately available for injection)
 - datacore.feedback with positive signals strengthens injection priority
 - datacore.forget retires engrams permanently
 - Unused engrams naturally decay over time
+- datacore.promote activates candidate engrams (when auto_promote is disabled)
 
 ## Quick Reference
 | Tool | Purpose |
@@ -2336,7 +3829,6 @@ var AGENT_GUIDE = `# Datacore Agent Guide
 | session.start | Begin session with context injection |
 | session.end | End session with journal + engrams |
 | learn | Create engram from knowledge statement |
-| promote | Activate candidate engrams |
 | inject | Get relevant engrams for specific task |
 | recall | Search all sources (engrams + journal + knowledge) |
 | capture | Write journal entry or knowledge note |
@@ -2348,6 +3840,7 @@ var AGENT_GUIDE = `# Datacore Agent Guide
 | packs.discover | Browse available engram packs |
 | packs.install | Install or upgrade a pack |
 | packs.export | Export engrams as shareable pack |
+| promote | Activate candidate engrams (when auto_promote disabled) |
 `;
 function notifyEngramsChanged(server) {
   try {
@@ -2428,6 +3921,14 @@ Engrams that prove useful get reinforced over time. Unused ones naturally decay.
 
 Datacore gives you persistent memory through **engrams** \u2014 typed knowledge units that get injected into context when relevant. You learn patterns, remember preferences, and build on previous work across sessions.
 
+## Use Proactively
+
+Use Datacore tools automatically \u2014 do not wait to be asked:
+- **session.start**: Call at the beginning of every conversation
+- **learn**: Call when you discover patterns, preferences, insights, or corrections
+- **feedback**: Call after engrams are injected to rate usefulness
+- **session.end**: Call before the conversation ends
+
 ## Core Concepts
 
 **Engrams** are reusable knowledge: "Always validate input at API boundaries", "User prefers tabs over spaces". They have activation dynamics \u2014 frequently useful ones get stronger, unused ones decay.
@@ -2457,8 +3958,7 @@ Every session follows this pattern:
 | Tool | What it does |
 |------|-------------|
 | **capture** | Write a journal entry or knowledge note |
-| **learn** | Create an engram (starts as candidate) |
-| **promote** | Activate candidate engrams |
+| **learn** | Create an engram (immediately active) |
 | **inject** | Get relevant engrams for a specific task |
 | **recall** | Search everything (engrams + journal + knowledge) |
 | **search** | Search journal and knowledge files |
@@ -2470,6 +3970,7 @@ Every session follows this pattern:
 |------|-------------|
 | **feedback** | Rate engrams: positive/negative/neutral (single or batch) |
 | **forget** | Retire an engram permanently |
+| **promote** | Activate candidate engrams (when auto_promote disabled) |
 
 ### Packs (Shareable Knowledge)
 | Tool | What it does |
@@ -2481,12 +3982,10 @@ Every session follows this pattern:
 ## Engram Lifecycle
 
 \`\`\`
-learn \u2192 candidate \u2192 promote \u2192 active \u2192 inject \u2192 feedback \u2192 stronger/weaker
-                                                          \u2192 forget (retire)
+learn \u2192 active \u2192 inject \u2192 feedback \u2192 stronger/weaker \u2192 forget (retire)
 \`\`\`
 
-- **candidate**: Created but not yet active. Won't appear in inject results.
-- **active**: Appears in inject results when relevant.
+- **active**: Appears in inject results when relevant. Created directly by learn.
 - **retired**: Permanently removed from injection.
 
 Feedback matters: positive signals increase retrieval strength, negative signals decrease it. Engrams that are never accessed naturally decay over time.
@@ -2495,6 +3994,7 @@ Feedback matters: positive signals increase retrieval strength, negative signals
 
 - Start every session with **session.start** \u2014 it gives you relevant context
 - End every session with **session.end** \u2014 it captures what you learned
+- Call **learn** proactively when you discover patterns or preferences
 - Use **feedback** after getting injected engrams \u2014 this is how Datacore learns what's useful
 - Use **recall** for broad searches across all sources, **search** for targeted file searches
 - Check **status** periodically \u2014 it shows actionable recommendations`
@@ -2526,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;
@@ -2537,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;
   }
@@ -2601,10 +4101,21 @@ 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 },
-    { capabilities: { tools: {}, logging: {}, resources: { subscribe: true }, prompts: {} } }
+    {
+      capabilities: { tools: {}, logging: {}, resources: { subscribe: true }, prompts: {} },
+      instructions: SERVER_INSTRUCTIONS
+    }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     const coreTools = storage.mode === "core" ? TOOLS.filter((t) => !t.name.startsWith("datacore.modules.")) : TOOLS;
@@ -2646,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) {
@@ -2657,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 });
@@ -2669,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);
@@ -2696,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);
@@ -2802,6 +4316,22 @@ async function runHttp() {
     console.log(`Datacore MCP server listening on http://${host}:${port}/mcp`);
   });
 }
+var SERVER_INSTRUCTIONS = `You have persistent memory through Datacore. Use it proactively in every conversation:
+
+1. **Start**: Call datacore.session.start with a brief task description. This loads relevant knowledge from previous sessions.
+2. **Learn**: When you discover reusable patterns, user preferences, project conventions, debugging insights, or corrections \u2014 call datacore.learn to remember them.
+3. **Feedback**: After session.start injects engrams, rate them with datacore.feedback. This trains the system on what's useful.
+4. **End**: Before the conversation ends, call datacore.session.end with a summary and engram_suggestions for new learnings.
+
+What to learn (call datacore.learn):
+- User preferences: "User prefers TypeScript over JavaScript", "Use tabs not spaces"
+- Project patterns: "This codebase uses repository pattern for data access"
+- Debugging insights: "Error X is usually caused by Y"
+- Corrections: "The API actually returns snake_case, not camelCase"
+- Architectural decisions: "We chose PostgreSQL for ACID compliance"
+- Workflow patterns: "Always run lint before committing in this project"
+
+Do not ask permission to use Datacore tools \u2014 they are your memory system. Use them naturally as part of your workflow.`;
 
 // src/index.ts
 var args = process.argv.slice(2);