@datacore-one/mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,2009 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/storage.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function detectStorage() {
+  const dcPath = process.env.DATACORE_PATH;
+  if (dcPath && fs.existsSync(path.join(dcPath, ".datacore"))) {
+    return fullConfig(dcPath);
+  }
+  const corePath = process.env.DATACORE_CORE_PATH;
+  if (corePath && fs.existsSync(corePath)) {
+    return coreConfig(corePath);
+  }
+  const defaultFull = path.join(os.homedir(), "Data");
+  if (fs.existsSync(path.join(defaultFull, ".datacore"))) {
+    return fullConfig(defaultFull);
+  }
+  return coreConfig(path.join(os.homedir(), "Datacore"));
+}
+function fullConfig(basePath) {
+  return {
+    mode: "full",
+    basePath,
+    engramsPath: path.join(basePath, ".datacore", "learning", "engrams.yaml"),
+    journalPath: path.join(basePath, "0-personal", "journal"),
+    knowledgePath: path.join(basePath, "0-personal", "3-knowledge"),
+    packsPath: path.join(basePath, ".datacore", "learning", "packs")
+  };
+}
+function coreConfig(basePath) {
+  return {
+    mode: "core",
+    basePath,
+    engramsPath: path.join(basePath, "engrams.yaml"),
+    journalPath: path.join(basePath, "journal"),
+    knowledgePath: path.join(basePath, "knowledge"),
+    packsPath: path.join(basePath, "packs")
+  };
+}
+function initCore(basePath) {
+  const isFirstRun2 = !fs.existsSync(path.join(basePath, "engrams.yaml"));
+  for (const dir of ["journal", "knowledge", "packs"]) {
+    const dirPath = path.join(basePath, dir);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+  const engramsPath = path.join(basePath, "engrams.yaml");
+  if (!fs.existsSync(engramsPath)) {
+    fs.writeFileSync(engramsPath, "engrams: []\n");
+  }
+  const configPath = path.join(basePath, "config.yaml");
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, "# Datacore MCP configuration\nversion: 1\n");
+  }
+  copyStarterPacks(basePath);
+  return { isFirstRun: isFirstRun2 };
+}
+function copyStarterPacks(basePath) {
+  const packsDir = path.join(basePath, "packs");
+  const bundledPacksDir = path.join(
+    path.dirname(new URL(import.meta.url).pathname),
+    "..",
+    "packs"
+  );
+  if (!fs.existsSync(bundledPacksDir)) return;
+  for (const entry of fs.readdirSync(bundledPacksDir)) {
+    const src = path.join(bundledPacksDir, entry);
+    const dest = path.join(packsDir, entry);
+    if (!fs.existsSync(dest) && fs.statSync(src).isDirectory()) {
+      fs.cpSync(src, dest, { recursive: true });
+    }
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@datacore-one/mcp",
+  version: "1.0.0",
+  description: "Datacore MCP server \u2014 The Software of You",
+  type: "module",
+  bin: {
+    "datacore-mcp": "./dist/index.js"
+  },
+  main: "./dist/index.js",
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    "test:watch": "vitest",
+    start: "node dist/index.js"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "js-yaml": "^4.1.0",
+    zod: "^3.23.0",
+    "zod-to-json-schema": "^3.25.1"
+  },
+  devDependencies: {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    tsup: "^8.0.0",
+    typescript: "^5.5.0",
+    vitest: "^2.0.0"
+  },
+  files: [
+    "dist",
+    "packs"
+  ],
+  keywords: [
+    "mcp",
+    "datacore",
+    "knowledge",
+    "learning",
+    "engrams"
+  ],
+  license: "MIT",
+  author: "Fair Data Society",
+  repository: {
+    type: "git",
+    url: "https://github.com/datacore-one/mcp"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/version.ts
+var currentVersion = package_default.version;
+async function checkForUpdate() {
+  try {
+    const res = await fetch("https://registry.npmjs.org/@datacore-one/mcp/latest", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (data.version !== currentVersion) return data.version;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/tools/index.ts
+import { z } from "zod";
+var TOOLS = [
+  {
+    name: "datacore.capture",
+    description: "Capture a journal entry or knowledge note",
+    inputSchema: z.object({
+      type: z.enum(["journal", "knowledge"]),
+      content: z.string().describe("Content to capture"),
+      title: z.string().optional().describe("Title for knowledge notes"),
+      tags: z.array(z.string()).optional().describe("Tags to attach")
+    })
+  },
+  {
+    name: "datacore.learn",
+    description: "Create an engram from a statement \u2014 record a reusable learning",
+    inputSchema: z.object({
+      statement: z.string().describe("The knowledge assertion"),
+      type: z.enum(["behavioral", "terminological", "procedural", "architectural"]).optional(),
+      scope: z.string().optional().describe("Scope: global | agent:X | command:X"),
+      tags: z.array(z.string()).optional(),
+      domain: z.string().optional().describe("Dot-notation domain: software.architecture"),
+      visibility: z.enum(["private", "public", "template"]).optional()
+    })
+  },
+  {
+    name: "datacore.inject",
+    description: "Get relevant engrams for a task \u2014 returns directives and considerations",
+    inputSchema: z.object({
+      prompt: z.string().describe("The task or question to match against"),
+      scope: z.string().optional().describe("Filter by scope: global | agent:X | module:X | command:X"),
+      max_tokens: z.number().optional().describe("Token budget (default: 8000)"),
+      min_relevance: z.number().optional().describe("Minimum score threshold (default: 0.3)")
+    })
+  },
+  {
+    name: "datacore.search",
+    description: "Search journal entries and knowledge notes by keyword",
+    inputSchema: z.object({
+      query: z.string().describe("Search query"),
+      scope: z.enum(["journal", "knowledge", "all"]).optional(),
+      method: z.enum(["keyword", "semantic"]).optional().describe("Search method (default: keyword)"),
+      limit: z.number().optional().describe("Max results (default: 20)")
+    })
+  },
+  {
+    name: "datacore.ingest",
+    description: "Ingest text content as a knowledge note, optionally extract engram suggestions",
+    inputSchema: z.object({
+      content: z.string().describe("Content to ingest"),
+      title: z.string().optional(),
+      tags: z.array(z.string()).optional()
+    })
+  },
+  {
+    name: "datacore.status",
+    description: "Show Datacore status: engram/pack/note counts, scaling hints, update info",
+    inputSchema: z.object({})
+  },
+  {
+    name: "datacore.packs.discover",
+    description: "Browse available engram packs from the registry",
+    inputSchema: z.object({
+      query: z.string().optional().describe("Filter by name/description"),
+      tags: z.array(z.string()).optional().describe("Filter by tags")
+    })
+  },
+  {
+    name: "datacore.packs.install",
+    description: "Install or upgrade an engram pack",
+    inputSchema: z.object({
+      source: z.string().describe("Pack source: local path or pack ID from registry")
+    })
+  },
+  {
+    name: "datacore.forget",
+    description: "Retire an engram by ID or search term \u2014 marks it as retired so it is no longer injected",
+    inputSchema: z.object({
+      id: z.string().optional().describe("Exact engram ID to retire (e.g., ENG-2026-0219-001)"),
+      search: z.string().optional().describe("Search term to find engram by statement, tag, or ID fragment")
+    })
+  },
+  {
+    name: "datacore.feedback",
+    description: "Signal whether an injected engram was helpful (positive), unhelpful (negative), or seen but not acted on (neutral)",
+    inputSchema: z.object({
+      engram_id: z.string().describe("The engram ID to provide feedback on"),
+      signal: z.enum(["positive", "negative", "neutral"]).describe("Feedback signal"),
+      comment: z.string().optional().describe("Optional comment about why")
+    })
+  },
+  {
+    name: "datacore.packs.export",
+    description: "Export personal engrams as a shareable pack. Preview by default, set confirm=true to write.",
+    inputSchema: z.object({
+      name: z.string().describe("Pack name"),
+      description: z.string().describe("Pack description"),
+      engram_ids: z.array(z.string()).optional().describe("Specific engram IDs to export"),
+      filter_tags: z.array(z.string()).optional().describe("Filter by tags"),
+      filter_domain: z.string().optional().describe("Filter by domain prefix"),
+      confirm: z.boolean().optional().describe("Set true to write pack (default: preview only)")
+    })
+  },
+  {
+    name: "datacore.modules.list",
+    description: "List installed modules with scope, version, and capability counts",
+    inputSchema: z.object({})
+  },
+  {
+    name: "datacore.modules.info",
+    description: "Get detailed info about a specific module: manifest, tools, skills, agents, engrams",
+    inputSchema: z.object({
+      module: z.string().describe('Module name (e.g., "gtd", "slides", "crm")')
+    })
+  },
+  {
+    name: "datacore.modules.health",
+    description: "Check module health: missing files, env vars, data separation issues",
+    inputSchema: z.object({
+      module: z.string().optional().describe("Module name (omit for all modules)")
+    })
+  }
+];
+
+// src/tools/capture.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/limits.ts
+var MAX_CONTENT_SIZE = 1e6;
+var MAX_TITLE_LENGTH = 200;
+function validateContent(content) {
+  if (content.length > MAX_CONTENT_SIZE) {
+    return `Content too large: ${content.length} characters (max: ${MAX_CONTENT_SIZE})`;
+  }
+  return null;
+}
+function validateTitle(title) {
+  if (title.length > MAX_TITLE_LENGTH) {
+    return `Title too long: ${title.length} characters (max: ${MAX_TITLE_LENGTH})`;
+  }
+  return null;
+}
+
+// src/tools/capture.ts
+async function handleCapture(args2, storage2) {
+  const contentError = validateContent(args2.content);
+  if (contentError) return { success: false, error: contentError };
+  if (args2.title) {
+    const titleError = validateTitle(args2.title);
+    if (titleError) return { success: false, error: titleError };
+  }
+  if (args2.type === "journal") {
+    return captureJournal(args2.content, storage2.journalPath);
+  }
+  return captureKnowledge(args2.content, args2.title, args2.tags, storage2.knowledgePath);
+}
+function localDate(tz) {
+  const timezone = tz || process.env.DATACORE_TIMEZONE || void 0;
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toLocaleDateString("en-CA", { timeZone: timezone });
+  const timeStr = now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false, timeZone: timezone });
+  return { date: dateStr, time: timeStr };
+}
+function captureJournal(content, journalDir) {
+  const { date: today, time } = localDate();
+  const filePath = path2.join(journalDir, `${today}.md`);
+  fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+  if (fs2.existsSync(filePath)) {
+    const existing = fs2.readFileSync(filePath, "utf8");
+    fs2.writeFileSync(filePath, `${existing}
+## ${time}
+
+${content}
+`);
+  } else {
+    fs2.writeFileSync(filePath, `# ${today}
+
+## ${time}
+
+${content}
+`);
+  }
+  return { success: true, path: filePath };
+}
+function captureKnowledge(content, title, tags, knowledgeDir) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const slug = (title ?? "note").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
+  const fileName = `${timestamp}-${slug}.md`;
+  const filePath = path2.join(knowledgeDir, fileName);
+  fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+  const frontmatter = `---
+title: "${title ?? "Untitled"}"
+created: "${(/* @__PURE__ */ new Date()).toISOString()}"
+---
+
+`;
+  const tagLine = tags?.length ? `
+${tags.map((t) => `#${t}`).join(" ")}
+` : "";
+  fs2.writeFileSync(filePath, `${frontmatter}${content}
+${tagLine}`);
+  return { success: true, path: filePath };
+}
+
+// src/engrams.ts
+import * as fs3 from "fs";
+import * as yaml from "js-yaml";
+
+// src/schemas/engram.ts
+import { z as z2 } from "zod";
+var ActivationSchema = z2.object({
+  retrieval_strength: z2.number().min(0).max(1),
+  storage_strength: z2.number().min(0).max(1),
+  frequency: z2.number().int().min(0),
+  last_accessed: z2.string()
+});
+var KnowledgeTypeSchema = z2.object({
+  memory_class: z2.enum(["semantic", "episodic", "procedural", "metacognitive"]),
+  cognitive_level: z2.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
+});
+var RelationsSchema = z2.object({
+  broader: z2.array(z2.string()).default([]),
+  narrower: z2.array(z2.string()).default([]),
+  related: z2.array(z2.string()).default([]),
+  conflicts: z2.array(z2.string()).default([])
+});
+var ProvenanceSchema = z2.object({
+  origin: z2.string(),
+  chain: z2.array(z2.string()).default([]),
+  signature: z2.string().nullable().default(null),
+  license: z2.string().default("cc-by-sa-4.0")
+});
+var FeedbackSignalsSchema = z2.object({
+  positive: z2.number().int().default(0),
+  negative: z2.number().int().default(0),
+  neutral: z2.number().int().default(0)
+});
+var EngramSchema = z2.object({
+  id: z2.string().regex(/^ENG-[A-Za-z0-9-]+$/),
+  version: z2.number().int().min(1),
+  status: z2.enum(["active", "dormant", "retired", "candidate"]),
+  consolidated: z2.boolean().default(false),
+  type: z2.enum(["behavioral", "terminological", "procedural", "architectural"]),
+  scope: z2.string(),
+  visibility: z2.enum(["private", "public", "template"]).default("private"),
+  statement: z2.string().min(1),
+  rationale: z2.string().optional(),
+  contraindications: z2.array(z2.string()).optional(),
+  source_patterns: z2.array(z2.string()).optional(),
+  derivation_count: z2.number().int().min(0).default(1),
+  knowledge_type: KnowledgeTypeSchema.optional(),
+  domain: z2.string().optional(),
+  relations: RelationsSchema.optional(),
+  activation: ActivationSchema,
+  provenance: ProvenanceSchema.optional(),
+  feedback_signals: FeedbackSignalsSchema.optional(),
+  tags: z2.array(z2.string()).default([]),
+  pack: z2.string().nullable().default(null),
+  abstract: z2.string().nullable().default(null),
+  derived_from: z2.string().nullable().default(null)
+});
+var DatacoreExtensionSchema = z2.object({
+  id: z2.string(),
+  injection_policy: z2.enum(["on_match", "on_request"]),
+  match_terms: z2.array(z2.string()).default([]),
+  domain: z2.string().optional(),
+  engram_count: z2.number().int().min(0)
+});
+var PackManifestSchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  version: z2.string(),
+  creator: z2.string().optional(),
+  license: z2.string().optional(),
+  tags: z2.array(z2.string()).default([]),
+  "x-datacore": DatacoreExtensionSchema
+});
+
+// src/logger.ts
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warning: 2,
+  error: 3
+};
+var MAX_MESSAGE_LENGTH = 4096;
+var Logger = class {
+  server = null;
+  minLevel;
+  constructor() {
+    const envLevel = process.env.DATACORE_LOG_LEVEL?.toLowerCase();
+    this.minLevel = envLevel && envLevel in LEVEL_ORDER ? envLevel : "warning";
+  }
+  setServer(server) {
+    this.server = server;
+  }
+  shouldLog(level) {
+    return LEVEL_ORDER[level] >= LEVEL_ORDER[this.minLevel];
+  }
+  truncate(msg) {
+    if (msg.length <= MAX_MESSAGE_LENGTH) return msg;
+    return msg.slice(0, MAX_MESSAGE_LENGTH - 3) + "...";
+  }
+  emit(level, message) {
+    if (!this.shouldLog(level)) return;
+    const truncated = this.truncate(message);
+    process.stderr.write(`[datacore:${level}] ${truncated}
+`);
+    if (this.server && LEVEL_ORDER[level] >= LEVEL_ORDER["warning"]) {
+      try {
+        this.server.sendLoggingMessage({ level, data: truncated });
+      } catch {
+      }
+    }
+  }
+  debug(message) {
+    this.emit("debug", message);
+  }
+  info(message) {
+    this.emit("info", message);
+  }
+  warning(message) {
+    this.emit("warning", message);
+  }
+  error(message) {
+    this.emit("error", message);
+  }
+};
+var logger = new Logger();
+
+// src/engrams.ts
+function loadEngrams(filePath) {
+  if (!fs3.existsSync(filePath)) return [];
+  try {
+    const raw = yaml.load(fs3.readFileSync(filePath, "utf8"));
+    if (!raw?.engrams || !Array.isArray(raw.engrams)) return [];
+    const valid = [];
+    let skipped = 0;
+    for (const entry of raw.engrams) {
+      const result = EngramSchema.safeParse(entry);
+      if (result.success) {
+        valid.push(result.data);
+      } else {
+        skipped++;
+      }
+    }
+    if (skipped > 0) {
+      logger.warning(`Skipped ${skipped} invalid engram(s) in ${filePath}`);
+    }
+    return valid;
+  } catch (err) {
+    logger.error(`Failed to parse engrams file ${filePath}: ${err}`);
+    return [];
+  }
+}
+function saveEngrams(filePath, engrams) {
+  const content = yaml.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  fs3.writeFileSync(filePath, content);
+}
+function parseSkillMdFrontmatter(filePath) {
+  const content = fs3.readFileSync(filePath, "utf8");
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) throw new Error(`No frontmatter found in ${filePath}`);
+  try {
+    return yaml.load(match[1]);
+  } catch (err) {
+    throw new Error(`Failed to parse YAML frontmatter in ${filePath}: ${err}`);
+  }
+}
+function loadPack(packDir) {
+  const skillMdPath = `${packDir}/SKILL.md`;
+  const engramsPath = `${packDir}/engrams.yaml`;
+  const rawManifest = parseSkillMdFrontmatter(skillMdPath);
+  const manifest = PackManifestSchema.parse(rawManifest);
+  const engrams = loadEngrams(engramsPath);
+  return { manifest, engrams };
+}
+function loadAllPacks(packsDir) {
+  if (!fs3.existsSync(packsDir)) return [];
+  const packs = [];
+  for (const entry of fs3.readdirSync(packsDir)) {
+    const packDir = `${packsDir}/${entry}`;
+    if (!fs3.statSync(packDir).isDirectory()) continue;
+    if (!fs3.existsSync(`${packDir}/SKILL.md`)) continue;
+    try {
+      packs.push(loadPack(packDir));
+    } catch (err) {
+      logger.warning(`Failed to load pack ${entry}: ${err}`);
+    }
+  }
+  return packs;
+}
+
+// src/tools/learn.ts
+function generateEngramId(existingEngrams) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().split("T")[0].replace(/-/g, "").slice(0, 8);
+  const prefix = `ENG-${date.slice(0, 4)}-${date.slice(4)}-`;
+  let maxSeq = 0;
+  for (const e of existingEngrams) {
+    if (e.id.startsWith(prefix)) {
+      const seq = parseInt(e.id.slice(prefix.length), 10);
+      if (seq > maxSeq) maxSeq = seq;
+    }
+  }
+  const nextSeq = maxSeq + 1;
+  const padWidth = nextSeq > 999 ? String(nextSeq).length : 3;
+  return `${prefix}${String(nextSeq).padStart(padWidth, "0")}`;
+}
+async function handleLearn(args2, engramsPath) {
+  const engrams = loadEngrams(engramsPath);
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const engram = {
+    id: generateEngramId(engrams),
+    version: 2,
+    status: "candidate",
+    consolidated: false,
+    type: args2.type ?? "behavioral",
+    scope: args2.scope ?? "global",
+    visibility: args2.visibility ?? "private",
+    statement: args2.statement,
+    rationale: args2.rationale,
+    derivation_count: 1,
+    domain: args2.domain,
+    tags: args2.tags ?? [],
+    activation: {
+      retrieval_strength: 0.5,
+      storage_strength: 0.3,
+      frequency: 0,
+      last_accessed: today
+    },
+    pack: null,
+    abstract: null,
+    derived_from: null
+  };
+  engrams.push(engram);
+  saveEngrams(engramsPath, engrams);
+  return { success: true, engram };
+}
+
+// src/tools/inject-tool.ts
+import * as fs4 from "fs";
+import * as yaml2 from "js-yaml";
+
+// src/decay.ts
+var DECAY_RATE = 0.05;
+var FLOOR = 0.05;
+var MS_PER_DAY = 864e5;
+function decayedStrength(retrievalStrength, lastAccessed, now) {
+  const last = new Date(lastAccessed);
+  const current = now ?? /* @__PURE__ */ new Date();
+  const days = Math.max(0, (current.getTime() - last.getTime()) / MS_PER_DAY);
+  return Math.max(retrievalStrength * Math.exp(-DECAY_RATE * days), FLOOR);
+}
+function engramState(retrievalStrength) {
+  if (retrievalStrength >= 0.5) return "active";
+  if (retrievalStrength >= 0.3) return "fading";
+  if (retrievalStrength >= 0.1) return "dormant";
+  return "retirement_candidate";
+}
+
+// src/inject.ts
+var DEFAULT_MAX_TOKENS = 8e3;
+var DEFAULT_MIN_RELEVANCE = 0.3;
+var TOKENS_PER_ENGRAM = 40;
+var MAX_PER_PACK = 5;
+var MAX_PER_DOMAIN = 10;
+function selectEngrams(ctx, personalEngrams, packs) {
+  const promptLower = ctx.prompt.toLowerCase();
+  const promptWords = new Set(promptLower.split(/\W+/).filter((w) => w.length > 2));
+  const scored = [];
+  for (const engram of personalEngrams) {
+    if (engram.status !== "active") continue;
+    const score = scoreEngram(engram, promptLower, promptWords, [], ctx.scope, false);
+    if (score > 0) scored.push({ engram, score });
+  }
+  for (const pack of packs) {
+    if (pack.manifest["x-datacore"].injection_policy === "on_request") continue;
+    const matchTerms = pack.manifest["x-datacore"].match_terms;
+    for (const engram of pack.engrams) {
+      if (engram.status !== "active") continue;
+      const score = scoreEngram(engram, promptLower, promptWords, matchTerms, ctx.scope, true);
+      if (score > 0) scored.push({ engram, score });
+    }
+  }
+  const maxTokens = ctx.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const minRelevance = ctx.minRelevance ?? DEFAULT_MIN_RELEVANCE;
+  const passing = scored.filter((s) => s.score >= minRelevance);
+  passing.sort((a, b) => b.score - a.score);
+  const selected = fillTokenBudget(passing, maxTokens);
+  const splitPoint = Math.ceil(selected.length * 2 / 3);
+  return {
+    directives: selected.slice(0, splitPoint),
+    consider: selected.slice(splitPoint),
+    tokens_used: selected.length * TOKENS_PER_ENGRAM
+  };
+}
+function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilter, isPack) {
+  if (scopeFilter) {
+    if (scopeFilter === "global") {
+      if (engram.scope !== "global") return 0;
+    } else if (!engram.scope.startsWith(scopeFilter) && engram.scope !== "global") {
+      return 0;
+    }
+  }
+  let termHits = 0;
+  for (const term of packMatchTerms) {
+    if (promptLower.includes(term.toLowerCase())) termHits++;
+  }
+  for (const tag of engram.tags) {
+    if (promptWords.has(tag.toLowerCase())) termHits++;
+  }
+  if (engram.domain) {
+    for (const part of engram.domain.split(/[./]/)) {
+      if (promptWords.has(part.toLowerCase())) termHits++;
+    }
+  }
+  const statementWords = new Set(engram.statement.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+  for (const word of promptWords) {
+    if (statementWords.has(word)) termHits += 0.5;
+  }
+  if (termHits === 0) return 0;
+  const rs = isPack ? engram.activation.retrieval_strength : decayedStrength(engram.activation.retrieval_strength, engram.activation.last_accessed);
+  let score = termHits * rs;
+  const feedback = engram.feedback_signals;
+  if (feedback) {
+    const netFeedback = feedback.positive - feedback.negative;
+    if (netFeedback > 0) score *= 1 + Math.min(netFeedback * 0.05, 0.3);
+    else if (netFeedback < 0) score *= Math.max(1 + netFeedback * 0.1, 0.5);
+  }
+  if (engram.consolidated) score *= 1.1;
+  return score;
+}
+function fillTokenBudget(scored, maxTokens) {
+  const result = [];
+  const packCounts = /* @__PURE__ */ new Map();
+  const domainCounts = /* @__PURE__ */ new Map();
+  let tokensUsed = 0;
+  for (const { engram } of scored) {
+    if (tokensUsed + TOKENS_PER_ENGRAM > maxTokens) break;
+    const pack = engram.pack ?? "__personal__";
+    const packCount = packCounts.get(pack) ?? 0;
+    if (packCount >= MAX_PER_PACK && pack !== "__personal__") continue;
+    const domain = engram.domain ?? "__none__";
+    const topDomain = domain.split(".")[0];
+    const domainCount = domainCounts.get(topDomain) ?? 0;
+    if (domainCount >= MAX_PER_DOMAIN) continue;
+    result.push(engram);
+    tokensUsed += TOKENS_PER_ENGRAM;
+    packCounts.set(pack, packCount + 1);
+    domainCounts.set(topDomain, domainCount + 1);
+  }
+  return result;
+}
+
+// src/tools/inject-tool.ts
+async function handleInject(args2, paths) {
+  const personalEngrams = loadEngrams(paths.engramsPath);
+  const packs = loadAllPacks(paths.packsPath);
+  const ctx = {
+    prompt: args2.prompt,
+    scope: args2.scope,
+    maxTokens: args2.max_tokens,
+    minRelevance: args2.min_relevance
+  };
+  const result = selectEngrams(ctx, personalEngrams, packs);
+  const totalCount = result.directives.length + result.consider.length;
+  if (totalCount === 0) {
+    return { text: "", count: 0, tokens_used: 0 };
+  }
+  const lines = [];
+  if (result.directives.length > 0) {
+    lines.push("## DIRECTIVES\n");
+    for (const e of result.directives) {
+      lines.push(formatEngram(e, totalCount));
+    }
+  }
+  if (result.consider.length > 0) {
+    lines.push("\n## ALSO CONSIDER\n");
+    for (const e of result.consider) {
+      lines.push(formatEngram(e, totalCount));
+    }
+  }
+  updateUsageTracking(
+    paths.engramsPath,
+    personalEngrams,
+    [...result.directives, ...result.consider]
+  );
+  return { text: lines.join("\n"), count: totalCount, tokens_used: result.tokens_used };
+}
+function updateUsageTracking(engramsPath, allPersonal, selected) {
+  const selectedPersonalIds = new Set(
+    selected.filter((e) => !e.pack).map((e) => e.id)
+  );
+  if (selectedPersonalIds.size === 0) return;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  let changed = false;
+  for (const engram of allPersonal) {
+    if (selectedPersonalIds.has(engram.id)) {
+      engram.activation.last_accessed = today;
+      engram.activation.frequency += 1;
+      changed = true;
+    }
+  }
+  if (changed) {
+    atomicWriteYaml(engramsPath, { engrams: allPersonal });
+  }
+}
+function atomicWriteYaml(filePath, data) {
+  const content = yaml2.dump(data, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  const tmpPath = filePath + ".tmp." + process.pid;
+  fs4.writeFileSync(tmpPath, content);
+  fs4.renameSync(tmpPath, filePath);
+}
+function formatEngram(engram, totalCount) {
+  if (totalCount < 10) {
+    let text = `- **${engram.statement}**`;
+    if (engram.rationale) text += `
+  _${engram.rationale}_`;
+    if (engram.contraindications?.length) {
+      text += `
+  Except: ${engram.contraindications.join(", ")}`;
+    }
+    return text;
+  }
+  if (totalCount < 30) {
+    const source = engram.pack ? ` [${engram.pack}]` : "";
+    return `- ${engram.statement}${source}`;
+  }
+  return `- ${engram.statement}`;
+}
+
+// src/tools/search.ts
+import * as fs5 from "fs";
+import * as path3 from "path";
+var CONTENT_CACHE_MAX = 500;
+var contentCache = /* @__PURE__ */ new Map();
+function getCachedContent(filePath) {
+  const entry = contentCache.get(filePath);
+  if (!entry) return null;
+  try {
+    const stat = fs5.statSync(filePath);
+    if (stat.mtimeMs === entry.mtime) return entry.content;
+  } catch {
+  }
+  contentCache.delete(filePath);
+  return null;
+}
+function setCachedContent(filePath, content) {
+  try {
+    const mtime = fs5.statSync(filePath).mtimeMs;
+    if (contentCache.size >= CONTENT_CACHE_MAX) {
+      const firstKey = contentCache.keys().next().value;
+      if (firstKey) contentCache.delete(firstKey);
+    }
+    contentCache.set(filePath, { mtime, content });
+  } catch {
+  }
+}
+async function handleSearch(args2, paths, bridge) {
+  if (args2.method === "semantic" && bridge) {
+    const availability = bridge.isAvailable();
+    if (availability.available) {
+      const result = await bridge.search(args2.query, args2.limit ?? 20);
+      if (!result.fallback) {
+        return { results: result.results, method: "semantic" };
+      }
+    }
+    const keywordResults = await keywordSearch(args2, paths);
+    return { ...keywordResults, method: "keyword", fallback_warning: "Semantic search unavailable, using keyword fallback" };
+  }
+  return keywordSearch(args2, paths);
+}
+async function keywordSearch(args2, paths) {
+  const scope = args2.scope ?? "all";
+  const limit = args2.limit ?? 20;
+  const results = [];
+  if (scope === "journal" || scope === "all") {
+    results.push(...searchDir(paths.journalPath, args2.query));
+  }
+  if (scope === "knowledge" || scope === "all") {
+    results.push(...searchDir(paths.knowledgePath, args2.query));
+  }
+  results.sort((a, b) => b.score - a.score);
+  return { results: results.slice(0, limit), method: "keyword" };
+}
+function searchDir(dirPath, query) {
+  if (!fs5.existsSync(dirPath)) return [];
+  const results = [];
+  const queryLower = query.toLowerCase();
+  for (const file of walkDir(dirPath)) {
+    if (!file.endsWith(".md")) continue;
+    const content = getCachedContent(file) ?? (() => {
+      const c = fs5.readFileSync(file, "utf8");
+      setCachedContent(file, c);
+      return c;
+    })();
+    const contentLower = content.toLowerCase();
+    const occurrences = countOccurrences(contentLower, queryLower);
+    if (occurrences === 0) continue;
+    const snippet = extractSnippet(content, query);
+    results.push({ path: file, snippet, score: occurrences });
+  }
+  return results;
+}
+function walkDir(dir) {
+  const files = [];
+  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...walkDir(fullPath));
+    else files.push(fullPath);
+  }
+  return files;
+}
+function countOccurrences(text, query) {
+  let count = 0;
+  let pos = 0;
+  while ((pos = text.indexOf(query, pos)) !== -1) {
+    count++;
+    pos += query.length;
+  }
+  return count;
+}
+function extractSnippet(content, query) {
+  const idx = content.toLowerCase().indexOf(query.toLowerCase());
+  if (idx === -1) return content.slice(0, 100);
+  const start2 = Math.max(0, idx - 50);
+  const end = Math.min(content.length, idx + query.length + 50);
+  return (start2 > 0 ? "..." : "") + content.slice(start2, end) + (end < content.length ? "..." : "");
+}
+
+// src/tools/ingest.ts
+import * as fs6 from "fs";
+import * as path4 from "path";
+async function handleIngest(args2, paths) {
+  const contentError = validateContent(args2.content);
+  if (contentError) return { success: false, error: contentError };
+  if (args2.title) {
+    const titleError = validateTitle(args2.title);
+    if (titleError) return { success: false, error: titleError };
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const slug = (args2.title ?? "ingested").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
+  const fileName = `${timestamp}-${slug}.md`;
+  const filePath = path4.join(paths.knowledgePath, fileName);
+  fs6.mkdirSync(path4.dirname(filePath), { recursive: true });
+  const frontmatter = `---
+title: "${args2.title ?? "Ingested Note"}"
+created: "${(/* @__PURE__ */ new Date()).toISOString()}"
+type: ingested
+---
+
+`;
+  const tagLine = args2.tags?.length ? `
+${args2.tags.map((t) => `#${t}`).join(" ")}
+` : "";
+  fs6.writeFileSync(filePath, `${frontmatter}${args2.content}
+${tagLine}`);
+  const suggestions = extractEngramSuggestions(args2.content);
+  return {
+    success: true,
+    note_path: filePath,
+    engram_suggestions: suggestions.length > 0 ? suggestions : void 0
+  };
+}
+function extractEngramSuggestions(content) {
+  const patterns = [
+    /(?:^|[.!?]\s+)(always\s+\w[\w\s]*?)(?:\.|$)/gim,
+    /(?:^|[.!?]\s+)(never\s+\w[\w\s]*?)(?:\.|$)/gim,
+    /(?:^|[.!?]\s+)(prefer\s+\w[\w\s]*?)(?:\.|$)/gim,
+    /(?:^|[.!?]\s+)(avoid\s+\w[\w\s]*?)(?:\.|$)/gim,
+    /(?:^|[.!?]\s+)(ensure\s+\w[\w\s]*?)(?:\.|$)/gim
+  ];
+  const suggestions = [];
+  for (const pattern of patterns) {
+    for (const match of content.matchAll(pattern)) {
+      const suggestion = match[1].trim();
+      if (suggestion.length >= 8 && suggestion.length <= 180) {
+        suggestions.push(suggestion);
+      }
+    }
+  }
+  return suggestions;
+}
+
+// src/tools/status.ts
+import * as fs8 from "fs";
+import * as path6 from "path";
+
+// src/trust.ts
+import * as fs7 from "fs";
+import * as path5 from "path";
+import * as crypto from "crypto";
+function computePackChecksum(packDir) {
+  const files = ["SKILL.md", "engrams.yaml"];
+  const hash = crypto.createHash("sha256");
+  let hasContent = false;
+  for (const file of files) {
+    const filePath = path5.join(packDir, file);
+    if (fs7.existsSync(filePath)) {
+      hash.update(fs7.readFileSync(filePath));
+      hasContent = true;
+    }
+  }
+  return hasContent ? hash.digest("hex") : null;
+}
+function verifyPackChecksum(packDir, expected) {
+  const actual = computePackChecksum(packDir);
+  return { valid: actual === expected, actual };
+}
+
+// registry/packs.json
+var packs_default = {
+  version: 1,
+  packs: [
+    {
+      id: "datacore-starter-v1",
+      name: "Datacore Methodology",
+      description: "Core knowledge management principles \u2014 capture, journal, learn, compound",
+      version: "1.0.0",
+      author: "Datacore",
+      tags: ["methodology", "gtd", "knowledge-management"],
+      download_url: "",
+      engram_count: 5,
+      free: true,
+      checksum: "4fb30b260c6ba5fd36e7cf9240f0a651ca484c777ab4a7be0b3438627138f1a3"
+    },
+    {
+      id: "fds-principles-v1",
+      name: "FDS Principles",
+      description: "Fair Data Society's 10 principles for ethical data handling",
+      version: "1.0.0",
+      author: "Fair Data Society",
+      tags: ["ethics", "data-sovereignty", "privacy", "consent"],
+      download_url: "",
+      engram_count: 10,
+      free: true,
+      checksum: "8cc7bbb7e259486b16370511fefe937532ee7dcba60ce87c2cd6b8647b5b9847"
+    },
+    {
+      id: "dips-v1",
+      name: "Datacore DIPs",
+      description: "Comprehensive knowledge from all 20 Datacore Improvement Proposals",
+      version: "1.0.0",
+      author: "Datacore",
+      tags: ["architecture", "patterns", "gtd", "modules", "knowledge-management"],
+      download_url: "",
+      engram_count: 747,
+      free: true,
+      checksum: "08185777c38e3a91fbb0f92e7ef388c5940e97e69be6dcce8ce119bd2b33968c"
+    }
+  ]
+};
+
+// src/tools/status.ts
+async function handleStatus(paths, updateAvailable2) {
+  const engrams = loadEngrams(paths.engramsPath);
+  const journalCount = countFiles(paths.journalPath, ".md");
+  const knowledgeCount = countFiles(paths.knowledgePath, ".md");
+  const packsCount = countDirs(paths.packsPath);
+  const healthCounts = { active: 0, fading: 0, dormant: 0, retirement_candidate: 0 };
+  for (const e of engrams) {
+    if (e.status !== "active") continue;
+    const rs = decayedStrength(e.activation.retrieval_strength, e.activation.last_accessed);
+    const state = engramState(rs);
+    healthCounts[state]++;
+  }
+  const packIntegrity = [];
+  for (const regPack of packs_default.packs) {
+    if (!regPack.checksum) continue;
+    const packDir = path6.join(paths.packsPath, regPack.id);
+    if (!fs8.existsSync(packDir)) continue;
+    const result2 = verifyPackChecksum(packDir, regPack.checksum);
+    packIntegrity.push({ name: regPack.id, valid: result2.valid });
+  }
+  const result = {
+    version: currentVersion,
+    mode: paths.mode,
+    engrams: engrams.length,
+    engram_health: healthCounts,
+    packs: packsCount,
+    pack_integrity: packIntegrity.length > 0 ? packIntegrity : void 0,
+    journal_entries: journalCount,
+    knowledge_notes: knowledgeCount
+  };
+  if (engrams.length >= 500) {
+    result.scaling_hint = `You have ${engrams.length} engrams. Consider migrating to full Datacore for SQLite-backed search.`;
+  }
+  if (updateAvailable2) {
+    result.update_available = updateAvailable2;
+  }
+  return result;
+}
+function countFiles(dir, ext) {
+  if (!fs8.existsSync(dir)) return 0;
+  let count = 0;
+  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory()) count += countFiles(fullPath, ext);
+    else if (entry.name.endsWith(ext)) count++;
+  }
+  return count;
+}
+function countDirs(dir) {
+  if (!fs8.existsSync(dir)) return 0;
+  return fs8.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).length;
+}
+
+// src/tools/discover.ts
+import * as fs9 from "fs";
+import * as path7 from "path";
+function handleDiscover(args2, packsDir) {
+  let packs = packs_default.packs.map((p) => {
+    const localDir = path7.join(packsDir, p.id);
+    const installed = fs9.existsSync(path7.join(localDir, "SKILL.md"));
+    let installedVersion;
+    if (installed) {
+      try {
+        const content = fs9.readFileSync(path7.join(localDir, "SKILL.md"), "utf8");
+        const match = content.match(/version:\s*["']?([^"'\n]+)/);
+        installedVersion = match?.[1];
+      } catch {
+      }
+    }
+    return {
+      ...p,
+      installed,
+      installed_version: installedVersion,
+      upgradeable: installed && installedVersion !== p.version,
+      can_install: !!p.download_url
+    };
+  });
+  if (args2.query) {
+    const q = args2.query.toLowerCase();
+    packs = packs.filter(
+      (p) => p.name.toLowerCase().includes(q) || p.description.toLowerCase().includes(q) || p.tags.some((t) => t.toLowerCase().includes(q))
+    );
+  }
+  if (args2.tags?.length) {
+    const filterTags = new Set(args2.tags.map((t) => t.toLowerCase()));
+    packs = packs.filter((p) => p.tags.some((t) => filterTags.has(t.toLowerCase())));
+  }
+  return { packs };
+}
+
+// src/tools/install.ts
+import * as fs10 from "fs";
+import * as path8 from "path";
+import * as yaml3 from "js-yaml";
+import * as os2 from "os";
+import { execSync } from "child_process";
+async function handleInstall(args2, packsDir) {
+  let srcDir = args2.source;
+  if (srcDir.startsWith("http://") || srcDir.startsWith("https://")) {
+    const downloaded = await downloadPack(srcDir);
+    if (downloaded.error) return { success: false, error: downloaded.error };
+    srcDir = downloaded.path;
+  }
+  const skillPath = path8.join(srcDir, "SKILL.md");
+  if (!fs10.existsSync(skillPath)) {
+    return { success: false, error: "No SKILL.md found in source directory" };
+  }
+  const skillContent = fs10.readFileSync(skillPath, "utf8");
+  const frontmatterMatch = skillContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return { success: false, error: "No YAML frontmatter in SKILL.md" };
+  }
+  const manifest = yaml3.load(frontmatterMatch[1]);
+  const packId = manifest?.["x-datacore"]?.id;
+  const newVersion = manifest?.version;
+  if (!packId) {
+    return { success: false, error: "Missing x-datacore.id in SKILL.md frontmatter" };
+  }
+  const destDir = path8.join(packsDir, packId);
+  if (fs10.existsSync(path8.join(destDir, "SKILL.md"))) {
+    const existingContent = fs10.readFileSync(path8.join(destDir, "SKILL.md"), "utf8");
+    const existingMatch = existingContent.match(/version:\s*["']?([^"'\n]+)/);
+    const existingVersion = existingMatch?.[1];
+    if (existingVersion === newVersion) {
+      return { success: true, pack_id: packId, already_current: true };
+    }
+    fs10.rmSync(destDir, { recursive: true, force: true });
+    fs10.cpSync(srcDir, destDir, { recursive: true });
+    return { success: true, pack_id: packId, upgraded: true };
+  }
+  fs10.cpSync(srcDir, destDir, { recursive: true });
+  const checksumVerified = verifyInstalledChecksum(packId, destDir);
+  return { success: true, pack_id: packId, checksum_verified: checksumVerified ?? void 0 };
+}
+function verifyInstalledChecksum(packId, destDir) {
+  const registryPack = packs_default.packs.find((p) => p.id === packId);
+  if (!registryPack?.checksum) return null;
+  const result = verifyPackChecksum(destDir, registryPack.checksum);
+  return result.valid;
+}
+async function downloadPack(url) {
+  const tmpDir = fs10.mkdtempSync(path8.join(os2.tmpdir(), "datacore-pack-"));
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+    if (!res.ok) return { error: `Download failed: HTTP ${res.status}` };
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const archivePath = path8.join(tmpDir, "pack.tar.gz");
+    fs10.writeFileSync(archivePath, buffer);
+    const extractDir = path8.join(tmpDir, "extracted");
+    fs10.mkdirSync(extractDir);
+    execSync(`tar xzf ${JSON.stringify(archivePath)} -C ${JSON.stringify(extractDir)}`, { timeout: 1e4 });
+    const packRoot = findPackRoot(extractDir);
+    if (!packRoot) return { error: "Downloaded archive does not contain SKILL.md" };
+    return { path: packRoot };
+  } catch (err) {
+    return { error: `Download failed: ${err instanceof Error ? err.message : err}` };
+  }
+}
+function findPackRoot(dir) {
+  if (fs10.existsSync(path8.join(dir, "SKILL.md"))) return dir;
+  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const found = findPackRoot(path8.join(dir, entry.name));
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+// src/tools/export.ts
+import * as fs11 from "fs";
+import * as path9 from "path";
+import * as yaml4 from "js-yaml";
+async function handleExport(args2, paths) {
+  const allEngrams = loadEngrams(paths.engramsPath);
+  let selected = allEngrams.filter((e) => e.status === "active");
+  selected = selected.filter((e) => e.visibility === "public" || e.visibility === "template");
+  if (selected.length === 0 && !args2.engram_ids?.length) {
+    return { success: false, error: "No exportable engrams found (only public/template engrams can be exported)" };
+  }
+  if (args2.engram_ids?.length) {
+    const idSet = new Set(args2.engram_ids);
+    selected = allEngrams.filter(
+      (e) => idSet.has(e.id) && e.status === "active" && (e.visibility === "public" || e.visibility === "template")
+    );
+    const privateSkipped = args2.engram_ids.filter((id) => {
+      const e = allEngrams.find((eng) => eng.id === id);
+      return e && e.visibility === "private";
+    });
+    if (privateSkipped.length > 0) {
+      return { success: false, error: `Cannot export private engrams: ${privateSkipped.join(", ")}. Set visibility to public or template first.` };
+    }
+  }
+  if (args2.filter_tags?.length) {
+    const tagSet = new Set(args2.filter_tags.map((t) => t.toLowerCase()));
+    selected = selected.filter((e) => e.tags.some((t) => tagSet.has(t.toLowerCase())));
+  }
+  if (args2.filter_domain) {
+    selected = selected.filter((e) => e.domain?.startsWith(args2.filter_domain));
+  }
+  if (selected.length === 0) {
+    return { success: false, error: "No engrams match the filter criteria" };
+  }
+  const packId = args2.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
+  const packDir = path9.join(paths.packsPath, packId);
+  if (!args2.confirm) {
+    return {
+      success: true,
+      preview: {
+        count: selected.length,
+        statements: selected.map((e) => e.statement).slice(0, 10),
+        pack_path: packDir
+      }
+    };
+  }
+  fs11.mkdirSync(packDir, { recursive: true });
+  const skillContent = `---
+name: "${args2.name}"
+description: "${args2.description}"
+version: "1.0.0"
+schema_version: 2
+x-datacore:
+  id: "${packId}"
+  injection_policy: on_match
+  match_terms: []
+  engram_count: ${selected.length}
+---
+
+# ${args2.name}
+
+${args2.description}
+
+Exported ${selected.length} engrams.
+`;
+  fs11.writeFileSync(path9.join(packDir, "SKILL.md"), skillContent);
+  const exportEngrams = selected.map((e) => ({
+    id: e.id,
+    version: e.version,
+    type: e.type,
+    scope: e.scope,
+    visibility: e.visibility,
+    statement: e.statement,
+    rationale: e.rationale,
+    tags: e.tags,
+    domain: e.domain,
+    status: "active",
+    activation: {
+      retrieval_strength: 0.7,
+      storage_strength: 1,
+      frequency: 0,
+      last_accessed: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+    },
+    feedback_signals: { positive: 0, negative: 0 }
+  }));
+  fs11.writeFileSync(
+    path9.join(packDir, "engrams.yaml"),
+    yaml4.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' })
+  );
+  return { success: true, pack_path: packDir };
+}
+
+// src/modules.ts
+import * as fs12 from "fs";
+import * as path10 from "path";
+import * as yaml5 from "js-yaml";
+function discoverModules(storage2) {
+  const modules = [];
+  if (storage2.mode !== "full") return modules;
+  const globalModulesDir = path10.join(storage2.basePath, ".datacore", "modules");
+  modules.push(...scanModulesDir(globalModulesDir, "global"));
+  try {
+    const entries = fs12.readdirSync(storage2.basePath);
+    for (const entry of entries) {
+      if (/^\d+-/.test(entry)) {
+        const spaceModulesDir = path10.join(storage2.basePath, entry, ".datacore", "modules");
+        modules.push(...scanModulesDir(spaceModulesDir, "space", entry));
+      }
+    }
+  } catch {
+  }
+  return modules;
+}
+function scanModulesDir(modulesDir, scope, spaceName) {
+  const modules = [];
+  if (!fs12.existsSync(modulesDir)) return modules;
+  try {
+    const entries = fs12.readdirSync(modulesDir);
+    for (const entry of entries) {
+      const modulePath = path10.join(modulesDir, entry);
+      const manifestPath = path10.join(modulePath, "module.yaml");
+      if (!fs12.existsSync(manifestPath)) continue;
+      try {
+        const raw = fs12.readFileSync(manifestPath, "utf-8");
+        const manifest = yaml5.load(raw);
+        if (!manifest || !manifest.name) continue;
+        modules.push({
+          name: manifest.name,
+          manifest,
+          modulePath,
+          scope,
+          spaceName
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return modules;
+}
+async function loadModuleTools(modules, storage2) {
+  const tools = [];
+  for (const mod of modules) {
+    const declaredTools = mod.manifest.provides?.tools;
+    if (!declaredTools || declaredTools.length === 0) continue;
+    const toolsIndexPath = path10.join(mod.modulePath, "tools", "index.js");
+    if (!fs12.existsSync(toolsIndexPath)) continue;
+    try {
+      const toolsModule = await import(toolsIndexPath);
+      const moduleTools2 = toolsModule.tools || toolsModule.default?.tools || [];
+      const dataPath = mod.scope === "space" && mod.spaceName ? path10.join(storage2.basePath, mod.spaceName, ".datacore", "modules", mod.name, "data") : path10.join(storage2.basePath, "0-personal", ".datacore", "modules", mod.name, "data");
+      const context = {
+        storage: storage2,
+        modulePath: mod.modulePath,
+        dataPath,
+        spaceName: mod.spaceName
+      };
+      for (const toolDef of moduleTools2) {
+        const declared = declaredTools.find((d) => d.name === toolDef.name);
+        if (!declared) continue;
+        tools.push({
+          fullName: `datacore.${mod.name}.${toolDef.name}`,
+          moduleName: mod.name,
+          definition: toolDef,
+          context
+        });
+      }
+    } catch {
+    }
+  }
+  return tools;
+}
+function getModuleInfo(mod) {
+  const m = mod.manifest;
+  return {
+    name: m.name,
+    version: m.version || "0.0.0",
+    description: m.description || "",
+    scope: mod.scope,
+    space: mod.spaceName,
+    builtin: m.builtin || false,
+    manifest_version: m.manifest_version || 1,
+    provides: {
+      tools: m.provides?.tools?.length || 0,
+      skills: m.provides?.skills?.length || 0,
+      agents: m.provides?.agents?.length || 0,
+      commands: m.provides?.commands?.length || 0,
+      workflows: m.provides?.workflows?.length || 0
+    },
+    context_priority: m.context?.priority || "minimal",
+    engrams: m.engrams ? {
+      namespace: m.engrams.namespace,
+      injection_policy: m.engrams.injection_policy,
+      has_starter_pack: !!m.engrams.starter_pack
+    } : null,
+    requires: m.requires?.env_vars ? {
+      env_required: m.requires.env_vars.required || [],
+      env_optional: m.requires.env_vars.optional || []
+    } : null,
+    path: mod.modulePath
+  };
+}
+
+// src/tools/modules-list.ts
+async function handleModulesList(_args, storage2, cachedModules) {
+  const modules = cachedModules ?? discoverModules(storage2);
+  if (modules.length === 0) {
+    return {
+      count: 0,
+      modules: [],
+      message: storage2.mode === "core" ? "Module discovery requires a full Datacore installation" : "No modules found"
+    };
+  }
+  return {
+    count: modules.length,
+    modules: modules.map((m) => ({
+      name: m.manifest.name,
+      version: m.manifest.version || "0.0.0",
+      description: m.manifest.description || "",
+      scope: m.scope,
+      space: m.spaceName || null,
+      builtin: m.manifest.builtin || false,
+      manifest_version: m.manifest.manifest_version || 1,
+      provides: {
+        tools: m.manifest.provides?.tools?.length || 0,
+        skills: m.manifest.provides?.skills?.length || 0,
+        agents: m.manifest.provides?.agents?.length || 0,
+        commands: m.manifest.provides?.commands?.length || 0,
+        workflows: m.manifest.provides?.workflows?.length || 0
+      },
+      context_priority: m.manifest.context?.priority || "minimal"
+    }))
+  };
+}
+
+// src/tools/modules-info.ts
+async function handleModulesInfo(args2, storage2, cachedModules) {
+  const modules = cachedModules ?? discoverModules(storage2);
+  const found = modules.find((m) => m.manifest.name === args2.module);
+  if (!found) {
+    return { error: `Module '${args2.module}' not found`, installed_modules: modules.map((m) => m.name) };
+  }
+  return getModuleInfo(found);
+}
+
+// src/tools/modules-health.ts
+import * as fs13 from "fs";
+import * as path11 from "path";
+async function handleModulesHealth(args2, storage2, cachedModules) {
+  const modules = cachedModules ?? discoverModules(storage2);
+  if (args2.module) {
+    const found = modules.find((m) => m.manifest.name === args2.module);
+    if (!found) {
+      return { error: `Module '${args2.module}' not found` };
+    }
+    return await checkModule(found, storage2);
+  }
+  const checks = await Promise.all(modules.map((m) => checkModule(m, storage2)));
+  const ok = checks.filter((c) => c.status === "ok").length;
+  const warnings = checks.filter((c) => c.status === "warning").length;
+  const errors = checks.filter((c) => c.status === "error").length;
+  return {
+    summary: { total: checks.length, ok, warnings, errors },
+    modules: checks
+  };
+}
+async function checkModule(mod, storage2) {
+  const issues = [];
+  const manifest = mod.manifest;
+  if (!fs13.existsSync(path11.join(mod.modulePath, "SKILL.md"))) {
+    issues.push("Missing SKILL.md (ecosystem entry point)");
+  }
+  if (!fs13.existsSync(path11.join(mod.modulePath, "CLAUDE.base.md"))) {
+    issues.push("Missing CLAUDE.base.md (AI context)");
+  }
+  if (!manifest.manifest_version || manifest.manifest_version < 2) {
+    issues.push("module.yaml uses v1 format (missing manifest_version: 2)");
+  }
+  const requires = manifest.requires;
+  const requiredEnv = requires?.env_vars?.required || [];
+  for (const envVar of requiredEnv) {
+    if (!process.env[envVar]) {
+      issues.push(`Missing required env var: ${envVar}`);
+    }
+  }
+  const provides = manifest.provides;
+  const declaredTools = provides?.tools || [];
+  if (declaredTools.length > 0) {
+    const toolsIndex = path11.join(mod.modulePath, "tools", "index.js");
+    if (!fs13.existsSync(toolsIndex)) {
+      issues.push(`Declares ${declaredTools.length} tools but tools/index.js not found`);
+    } else {
+      try {
+        const toolModule = await import(toolsIndex);
+        for (const tool of declaredTools) {
+          const handlerName = tool.handler || tool.name;
+          if (typeof toolModule[handlerName] !== "function") {
+            issues.push(`Tool '${tool.name}' declares handler '${handlerName}' but export not found`);
+          }
+        }
+      } catch (err) {
+        issues.push(`tools/index.js failed to load: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  }
+  const suspectExts = [".db", ".sqlite", ".json"];
+  const suspectDirs = ["output", "data", "state"];
+  for (const dir of suspectDirs) {
+    const fullPath = path11.join(mod.modulePath, dir);
+    if (fs13.existsSync(fullPath) && fs13.statSync(fullPath).isDirectory()) {
+      issues.push(`Data dir '${dir}/' found in module code (should be in space data path)`);
+    }
+  }
+  try {
+    const entries = fs13.readdirSync(mod.modulePath);
+    for (const entry of entries) {
+      if (suspectExts.some((ext) => entry.endsWith(ext))) {
+        issues.push(`Data file '${entry}' found in module code dir`);
+      }
+    }
+  } catch {
+  }
+  return {
+    name: mod.name,
+    status: issues.length === 0 ? "ok" : issues.some((i) => i.startsWith("Missing required")) ? "error" : "warning",
+    issues
+  };
+}
+
+// src/tools/forget.ts
+async function handleForget(args2, engramsPath) {
+  const engrams = loadEngrams(engramsPath);
+  if (args2.id) {
+    const idx = engrams.findIndex((e) => e.id === args2.id);
+    if (idx === -1) {
+      return { success: false, error: `Engram ${args2.id} not found` };
+    }
+    const engram = engrams[idx];
+    if (engram.status === "retired") {
+      return { success: false, error: `Engram ${args2.id} is already retired` };
+    }
+    engrams[idx] = { ...engram, status: "retired" };
+    saveEngrams(engramsPath, engrams);
+    return { success: true, retired: { id: engram.id, statement: engram.statement } };
+  }
+  if (args2.search) {
+    const searchLower = args2.search.toLowerCase();
+    const matches = engrams.filter((e) => e.status !== "retired").filter(
+      (e) => e.statement.toLowerCase().includes(searchLower) || e.id.toLowerCase().includes(searchLower) || e.tags.some((t) => t.toLowerCase().includes(searchLower))
+    ).slice(0, 10);
+    if (matches.length === 0) {
+      return { success: false, error: `No active engrams matching "${args2.search}"` };
+    }
+    if (matches.length === 1) {
+      const engram = matches[0];
+      const idx = engrams.findIndex((e) => e.id === engram.id);
+      engrams[idx] = { ...engram, status: "retired" };
+      saveEngrams(engramsPath, engrams);
+      return { success: true, retired: { id: engram.id, statement: engram.statement } };
+    }
+    return {
+      success: false,
+      matches: matches.map((e) => ({ id: e.id, statement: e.statement })),
+      error: `Multiple matches found. Specify an exact ID to retire.`
+    };
+  }
+  return { success: false, error: "Provide either id or search parameter" };
+}
+
+// src/tools/feedback.ts
+async function handleFeedback(args2, engramsPath) {
+  const engrams = loadEngrams(engramsPath);
+  const engram = engrams.find((e) => e.id === args2.engram_id);
+  if (!engram) {
+    return { success: false, engram_id: args2.engram_id, signal: args2.signal, error: `Engram ${args2.engram_id} not found` };
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  if (engram.activation.last_accessed === today) {
+  }
+  if (!engram.feedback_signals) {
+    engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+  }
+  engram.feedback_signals[args2.signal] += 1;
+  engram.activation.last_accessed = today;
+  atomicWriteYaml(engramsPath, { engrams });
+  return {
+    success: true,
+    engram_id: args2.engram_id,
+    signal: args2.signal,
+    feedback_signals: { ...engram.feedback_signals }
+  };
+}
+
+// src/resources.ts
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListResourceTemplatesRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs14 from "fs";
+import * as path12 from "path";
+function registerResources(server, storage2) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+      {
+        uri: "datacore://status",
+        name: "Datacore Status",
+        description: "Current system status summary",
+        mimeType: "application/json"
+      },
+      {
+        uri: "datacore://engrams/active",
+        name: "Active Engrams",
+        description: "All active engrams with their metadata",
+        mimeType: "application/json"
+      },
+      {
+        uri: "datacore://journal/today",
+        name: "Today's Journal",
+        description: "Today's journal entry",
+        mimeType: "text/markdown"
+      }
+    ]
+  }));
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+    resourceTemplates: [
+      {
+        uriTemplate: "datacore://journal/{date}",
+        name: "Journal Entry",
+        description: "Journal entry for a specific date (YYYY-MM-DD)",
+        mimeType: "text/markdown"
+      },
+      {
+        uriTemplate: "datacore://engrams/{id}",
+        name: "Engram",
+        description: "A specific engram by ID",
+        mimeType: "application/json"
+      }
+    ]
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    if (uri === "datacore://status") {
+      const engrams = loadEngrams(storage2.engramsPath);
+      const active = engrams.filter((e) => e.status === "active").length;
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify({ version: currentVersion, mode: storage2.mode, engrams: engrams.length, active })
+        }]
+      };
+    }
+    if (uri === "datacore://engrams/active") {
+      const engrams = loadEngrams(storage2.engramsPath).filter((e) => e.status === "active");
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(engrams, null, 2)
+        }]
+      };
+    }
+    const journalMatch = uri.match(/^datacore:\/\/journal\/(.+)$/);
+    if (journalMatch) {
+      const dateStr = journalMatch[1] === "today" ? localDate().date : journalMatch[1];
+      const filePath = path12.join(storage2.journalPath, `${dateStr}.md`);
+      if (!fs14.existsSync(filePath)) {
+        return { contents: [{ uri, mimeType: "text/markdown", text: `No journal entry for ${dateStr}` }] };
+      }
+      return { contents: [{ uri, mimeType: "text/markdown", text: fs14.readFileSync(filePath, "utf8") }] };
+    }
+    const engramMatch = uri.match(/^datacore:\/\/engrams\/(.+)$/);
+    if (engramMatch) {
+      const engrams = loadEngrams(storage2.engramsPath);
+      const engram = engrams.find((e) => e.id === engramMatch[1]);
+      if (!engram) {
+        throw new Error(`Engram not found: ${engramMatch[1]}`);
+      }
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(engram, null, 2)
+        }]
+      };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  });
+}
+function notifyEngramsChanged(server) {
+  try {
+    server.sendResourceUpdated?.({ uri: "datacore://engrams/active" });
+  } catch {
+  }
+}
+
+// src/datacortex.ts
+import { execFile } from "child_process";
+import * as fs15 from "fs";
+import * as path13 from "path";
+var DatacortexBridge = class {
+  pythonPath;
+  scriptPath;
+  constructor(datacorePath) {
+    this.pythonPath = process.env.DATACORE_PYTHON ?? "python3";
+    this.scriptPath = this.findBridgeScript(datacorePath);
+  }
+  findBridgeScript(datacorePath) {
+    const candidates = [
+      path13.join(datacorePath, ".datacore", "modules", "datacortex", "lib", "bridge.py"),
+      path13.join(datacorePath, ".datacore", "modules", "datacortex", "bridge.py")
+    ];
+    for (const candidate of candidates) {
+      if (fs15.existsSync(candidate)) return candidate;
+    }
+    return null;
+  }
+  isAvailable() {
+    if (!this.scriptPath) {
+      return { available: false, reason: "Datacortex bridge script not found" };
+    }
+    try {
+      const { execSync: execSync2 } = __require("child_process");
+      execSync2(`${this.pythonPath} --version`, { timeout: 5e3, stdio: "pipe" });
+      return { available: true };
+    } catch {
+      return { available: false, reason: `Python not found at ${this.pythonPath}` };
+    }
+  }
+  async search(query, limit = 20) {
+    if (!this.scriptPath) {
+      return { results: [], fallback: true };
+    }
+    const request = JSON.stringify({ action: "search", query, limit });
+    return new Promise((resolve) => {
+      const proc = execFile(
+        this.pythonPath,
+        [this.scriptPath],
+        { timeout: 3e4 },
+        (error, stdout, stderr) => {
+          if (error) {
+            logger.warning(`Datacortex bridge error: ${error.message}`);
+            resolve({ results: [], fallback: true });
+            return;
+          }
+          try {
+            const response = JSON.parse(stdout.trim());
+            if (response.error) {
+              logger.warning(`Datacortex bridge: ${response.error}`);
+              resolve({ results: [], fallback: true });
+              return;
+            }
+            resolve({ results: response.results ?? [] });
+          } catch {
+            logger.warning(`Datacortex bridge: invalid response`);
+            resolve({ results: [], fallback: true });
+          }
+        }
+      );
+      proc.stdin?.write(request + "\n");
+      proc.stdin?.end();
+    });
+  }
+};
+
+// src/server.ts
+var storage;
+var updateAvailable = null;
+var moduleTools = [];
+var discoveredModules = [];
+var isFirstRun = false;
+var serverRef = null;
+var datacortexBridge = null;
+function createServer() {
+  const server = new Server(
+    { name: "datacore-mcp", version: currentVersion },
+    { capabilities: { tools: {}, logging: {}, resources: { subscribe: true } } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      ...TOOLS.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: zodToJsonSchema(t.inputSchema)
+      })),
+      ...moduleTools.map((t) => ({
+        name: t.fullName,
+        description: t.definition.description,
+        inputSchema: zodToJsonSchema(t.definition.inputSchema)
+      }))
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args2 } = request.params;
+    try {
+      const result = await routeTool(name, args2 ?? {});
+      const response = [];
+      if (isFirstRun) {
+        isFirstRun = false;
+        response.push({ type: "text", text: JSON.stringify({
+          _welcome: `Welcome to Datacore MCP! Your data is stored at ${storage.basePath}. Try: datacore.learn to create your first engram, datacore.capture to write a journal entry, or datacore.status to see system info.`
+        }) });
+      }
+      response.push({ type: "text", text: JSON.stringify(result, null, 2) });
+      return { content: response };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error}` }], isError: true };
+    }
+  });
+  logger.setServer(server);
+  registerResources(server, storage);
+  serverRef = server;
+  return server;
+}
+var ENGRAM_MUTATING_TOOLS = /* @__PURE__ */ new Set(["datacore.learn", "datacore.forget", "datacore.feedback"]);
+async function routeTool(name, args2) {
+  const coreTool = TOOLS.find((t) => t.name === name);
+  if (coreTool) {
+    const validated = coreTool.inputSchema.parse(args2);
+    let result;
+    switch (name) {
+      case "datacore.capture":
+        result = await handleCapture(validated, storage);
+        break;
+      case "datacore.learn":
+        result = await handleLearn(validated, storage.engramsPath);
+        break;
+      case "datacore.inject":
+        result = await handleInject(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath });
+        break;
+      case "datacore.search":
+        result = await handleSearch(validated, { journalPath: storage.journalPath, knowledgePath: storage.knowledgePath }, datacortexBridge);
+        break;
+      case "datacore.ingest":
+        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);
+        break;
+      case "datacore.forget":
+        result = await handleForget(validated, storage.engramsPath);
+        break;
+      case "datacore.feedback":
+        result = await handleFeedback(validated, storage.engramsPath);
+        break;
+      case "datacore.packs.discover":
+        result = handleDiscover(validated, storage.packsPath);
+        break;
+      case "datacore.packs.install":
+        result = await handleInstall(validated, storage.packsPath);
+        break;
+      case "datacore.packs.export":
+        result = await handleExport(validated, { engramsPath: storage.engramsPath, packsPath: storage.packsPath });
+        break;
+      case "datacore.modules.list":
+        result = await handleModulesList(validated, storage, discoveredModules);
+        break;
+      case "datacore.modules.info":
+        result = await handleModulesInfo(validated, storage, discoveredModules);
+        break;
+      case "datacore.modules.health":
+        result = await handleModulesHealth(validated, storage, discoveredModules);
+        break;
+      default:
+        throw new Error(`Unknown core tool: ${name}`);
+    }
+    if (ENGRAM_MUTATING_TOOLS.has(name) && serverRef) {
+      notifyEngramsChanged(serverRef);
+    }
+    return result;
+  }
+  const modTool = moduleTools.find((t) => t.fullName === name);
+  if (modTool) {
+    const validated = modTool.definition.inputSchema.parse(args2);
+    return modTool.definition.handler(validated, modTool.context);
+  }
+  const allNames = [...TOOLS.map((t) => t.name), ...moduleTools.map((t) => t.fullName)];
+  const suggestions = findClosestTools(name, allNames);
+  const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+  throw new Error(`Unknown tool: ${name}.${hint}`);
+}
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: n + 1 }, (_, i) => i);
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const tmp = dp[j];
+      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = tmp;
+    }
+  }
+  return dp[n];
+}
+function findClosestTools(name, allNames) {
+  const threshold = Math.max(3, Math.floor(name.length * 0.35));
+  const scored = allNames.map((t) => ({ name: t, dist: levenshtein(name.toLowerCase(), t.toLowerCase()) })).filter((s) => s.dist <= threshold).sort((a, b) => a.dist - b.dist);
+  return scored.slice(0, 2).map((s) => s.name);
+}
+async function initStorage() {
+  storage = detectStorage();
+  if (storage.mode === "core") {
+    const result = initCore(storage.basePath);
+    isFirstRun = result.isFirstRun;
+  }
+  if (storage.mode === "full") {
+    discoveredModules = discoverModules(storage);
+    moduleTools = await loadModuleTools(discoveredModules, storage);
+    datacortexBridge = new DatacortexBridge(storage.basePath);
+  }
+}
+async function runStdio() {
+  await initStorage();
+  checkForUpdate().then((v) => {
+    updateAvailable = v;
+  });
+  const updateInterval = setInterval(() => {
+    checkForUpdate().then((v) => {
+      updateAvailable = v;
+    });
+  }, 36e5);
+  updateInterval.unref();
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  server.onclose = () => {
+    clearInterval(updateInterval);
+  };
+}
+async function runHttp() {
+  const { createServer: createHttpServer } = await import("http");
+  const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+  await initStorage();
+  checkForUpdate().then((v) => {
+    updateAvailable = v;
+  });
+  const port = parseInt(process.env.DATACORE_HTTP_PORT ?? "3100", 10);
+  const host = process.env.DATACORE_HTTP_HOST ?? "127.0.0.1";
+  const server = createServer();
+  const httpServer = createHttpServer(async (req, res) => {
+    if (req.method === "POST" && req.url === "/mcp") {
+      const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+      await server.connect(transport);
+      await transport.handleRequest(req, res);
+    } else if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", version: currentVersion }));
+    } else {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+  httpServer.listen(port, host, () => {
+    console.log(`Datacore MCP server listening on http://${host}:${port}/mcp`);
+  });
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(currentVersion);
+  process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`Datacore MCP Server v${currentVersion}
+An MCP server that gives AI assistants persistent memory through engrams.
+
+Usage:
+  npx @datacore-one/mcp           Start MCP server (stdio transport)
+  npx @datacore-one/mcp --http    Start MCP server (HTTP transport)
+  npx @datacore-one/mcp --help    Show this help
+  npx @datacore-one/mcp --version Show version
+
+Tools:
+  Core
+    datacore.capture     Capture a journal entry or knowledge note
+    datacore.learn       Create an engram from a statement
+    datacore.inject      Get relevant engrams for a task
+    datacore.search      Search journal and knowledge by keyword
+    datacore.ingest      Ingest text as knowledge note with engram extraction
+    datacore.status      System status, counts, update info
+
+  Lifecycle
+    datacore.feedback    Signal whether an injected engram was helpful
+    datacore.forget      Retire an engram by ID or search
+
+  Packs
+    datacore.packs.discover    Browse available engram packs
+    datacore.packs.install     Install or upgrade an engram pack
+    datacore.packs.export      Export personal engrams as a shareable pack
+
+  Modules (full mode)
+    datacore.modules.list    List installed modules
+    datacore.modules.info    Detailed info about a module
+    datacore.modules.health  Health check for modules
+
+Configuration:
+  DATACORE_PATH             Full installation path (default: ~/Data)
+  DATACORE_CORE_PATH        Core mode storage path (default: ~/Datacore)
+  DATACORE_TIMEZONE         IANA timezone (e.g., Europe/Ljubljana)
+  DATACORE_LOG_LEVEL        Log level: debug|info|warning|error (default: warning)
+  DATACORE_CACHE_TTL        File cache TTL in seconds (default: 60)
+  DATACORE_TRANSPORT        Transport: stdio or http (default: stdio)
+  DATACORE_HTTP_PORT        HTTP transport port (default: 3100)
+  DATACORE_HTTP_HOST        HTTP transport bind address (default: 127.0.0.1)
+
+Examples:
+  # Add to Claude Desktop config
+  { "mcpServers": { "datacore": { "command": "npx", "args": ["@datacore-one/mcp"] } } }
+
+  # Run with HTTP transport on custom port
+  DATACORE_HTTP_PORT=8080 npx @datacore-one/mcp --http
+`);
+  process.exit(0);
+}
+var useHttp = args.includes("--http") || process.env.DATACORE_TRANSPORT === "http";
+var start = useHttp ? runHttp : runStdio;
+start().catch((error) => {
+  console.error("Failed to start Datacore MCP server:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map