@datacore-one/mcp 1.1.1 → 1.2.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([])
@@ -237,7 +242,7 @@ function getConfig() {
 // package.json
 var package_default = {
   name: "@datacore-one/mcp",
-  version: "1.1.1",
+  version: "1.2.0",
   description: "Datacore MCP server \u2014 The Software of You",
   type: "module",
   bin: {
@@ -307,7 +312,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 +322,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 +334,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 +391,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 +426,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"),
@@ -1338,6 +1343,11 @@ function countDirs(dir) {
 import * as fs10 from "fs";
 import * as path8 from "path";
 function handleDiscover(args2, packsDir) {
+  const bundledDir = path8.join(
+    path8.dirname(new URL(import.meta.url).pathname),
+    "..",
+    "packs"
+  );
   let packs = packs_default.packs.map((p) => {
     const localDir = path8.join(packsDir, p.id);
     const installed = fs10.existsSync(path8.join(localDir, "SKILL.md"));
@@ -1350,12 +1360,13 @@ function handleDiscover(args2, packsDir) {
       } catch {
       }
     }
+    const bundled = fs10.existsSync(path8.join(bundledDir, p.id, "SKILL.md"));
     return {
       ...p,
       installed,
       installed_version: installedVersion,
       upgradeable: installed && installedVersion !== p.version,
-      can_install: !!p.download_url
+      can_install: !!p.download_url || bundled
     };
   });
   if (args2.query) {
@@ -2023,22 +2034,25 @@ 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.`;
 
@@ -2311,6 +2325,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
@@ -2318,11 +2340,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 |
@@ -2330,7 +2352,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 |
@@ -2342,6 +2363,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 {
@@ -2422,6 +2444,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.
@@ -2451,8 +2481,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 |
@@ -2464,6 +2493,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 |
@@ -2475,12 +2505,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.
@@ -2489,6 +2517,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`
@@ -2598,7 +2627,10 @@ var datacortexBridge = null;
 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;
@@ -2796,6 +2828,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);