neo4j-agent-memory 0.3.17

package/dist/index.js

@@ -0,0 +1,738 @@
+// src/neo4j/client.ts
+import neo4j from "neo4j-driver";
+var Neo4jClient = class {
+  driver;
+  database;
+  constructor(cfg) {
+    this.driver = neo4j.driver(cfg.uri, neo4j.auth.basic(cfg.username, cfg.password));
+    this.database = cfg.database;
+  }
+  session(mode = "READ") {
+    return this.driver.session({
+      database: this.database,
+      defaultAccessMode: mode === "READ" ? neo4j.session.READ : neo4j.session.WRITE
+    });
+  }
+  async close() {
+    await this.driver.close();
+  }
+};
+
+// src/cypher/index.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+var resolvedDir = typeof __dirname === "string" ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+var baseDir = path.basename(resolvedDir) === "cypher" ? resolvedDir : path.resolve(resolvedDir, "cypher");
+function loadCypher(rel) {
+  return readFileSync(path.resolve(baseDir, rel), "utf8");
+}
+var cypher = {
+  schema: loadCypher("schema.cypher"),
+  upsertMemory: loadCypher("upsert_memory.cypher"),
+  upsertCase: loadCypher("upsert_case.cypher"),
+  retrieveContextBundle: loadCypher("retrieve_context_bundle.cypher"),
+  feedbackBatch: loadCypher("feedback_batch.cypher"),
+  feedbackCoUsed: loadCypher("feedback_co_used_with_batch.cypher"),
+  listMemories: loadCypher("list_memories.cypher"),
+  relateConcepts: loadCypher("relate_concepts.cypher")
+};
+
+// src/neo4j/schema.ts
+var schemaVersion = 1;
+async function ensureSchema(client) {
+  const session = client.session("WRITE");
+  try {
+    const statements = cypher.schema.split(/;\s*\n/).map((s) => s.trim()).filter(Boolean);
+    for (const stmt of statements) {
+      await session.run(stmt);
+    }
+  } finally {
+    await session.close();
+  }
+}
+async function migrate(client, targetVersion = schemaVersion) {
+  if (targetVersion !== schemaVersion) {
+    throw new Error(`Unsupported schema version ${targetVersion}; current is ${schemaVersion}`);
+  }
+  await ensureSchema(client);
+}
+
+// src/utils/hash.ts
+import { createHash, randomUUID } from "crypto";
+function sha256Hex(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex");
+}
+var norm = (s) => s.trim().toLowerCase().replace(/\s+/g, " ");
+function canonicaliseForHash(title, content, tags) {
+  const tagNorm = [...new Set(tags.map(norm))].sort().join(",");
+  return `${norm(title)}
+${norm(content)}
+${tagNorm}`;
+}
+function newId(prefix) {
+  return `${prefix}_${randomUUID()}`;
+}
+function normaliseSymptom(s) {
+  return norm(s);
+}
+function envHash(env) {
+  const payload = {
+    os: env.os ?? null,
+    distro: env.distro ?? null,
+    ci: env.ci ?? null,
+    container: env.container ?? null,
+    filesystem: env.filesystem ?? null,
+    workspaceMount: env.workspaceMount ?? null,
+    nodeVersion: env.nodeVersion ?? null,
+    packageManager: env.packageManager ?? null,
+    pmVersion: env.pmVersion ?? null
+  };
+  return sha256Hex(JSON.stringify(payload));
+}
+
+// src/memory_service.ts
+function clamp01(x) {
+  return Math.max(0, Math.min(1, x));
+}
+function toBetaEdge(raw) {
+  const aMin = 1e-3;
+  const bMin = 1e-3;
+  const strength = typeof raw?.strength === "number" ? raw.strength : 0.5;
+  const a = typeof raw?.a === "number" ? raw.a : Math.max(aMin, strength * 2);
+  const b = typeof raw?.b === "number" ? raw.b : Math.max(bMin, (1 - strength) * 2);
+  const ev = typeof raw?.evidence === "number" ? raw.evidence : a + b;
+  return {
+    a,
+    b,
+    strength: typeof raw?.strength === "number" ? raw.strength : a / (a + b),
+    evidence: ev,
+    updatedAt: raw?.updatedAt ?? null
+  };
+}
+function defaultPolicy(req) {
+  return {
+    minConfidence: req?.minConfidence ?? 0.65,
+    requireVerificationSteps: req?.requireVerificationSteps ?? true,
+    maxItems: req?.maxItems ?? 5
+  };
+}
+function detectSecrets(text) {
+  const suspicious = /(AKIA[0-9A-Z]{16}|-----BEGIN (RSA|EC|OPENSSH) PRIVATE KEY-----|xox[baprs]-|ghp_[A-Za-z0-9]{36,})/;
+  return suspicious.test(text);
+}
+function validateLearning(l, pol) {
+  if (!l.title || l.title.trim().length < 4) return "title too short";
+  if (!l.content || l.content.trim().length < 20) return "content too short";
+  if ((l.tags ?? []).length < 1) return "missing tags";
+  if (!(l.confidence >= 0 && l.confidence <= 1)) return "confidence must be 0..1";
+  if (l.confidence < pol.minConfidence) return `confidence < ${pol.minConfidence}`;
+  if (detectSecrets(l.content)) return "possible secret detected";
+  if (l.kind === "procedural" && pol.requireVerificationSteps) {
+    const v = l.triage?.verificationSteps?.length ?? 0;
+    const f = l.triage?.fixSteps?.length ?? 0;
+    if (v < 1) return "procedural requires triage.verificationSteps";
+    if (f < 1) return "procedural requires triage.fixSteps";
+  }
+  const polarity = l.polarity ?? "positive";
+  if (polarity === "negative") {
+    if (!l.antiPattern?.action || !l.antiPattern?.whyBad) {
+      return "negative memories require antiPattern.action + antiPattern.whyBad";
+    }
+  }
+  return null;
+}
+function formatEpisodeContent(args, title) {
+  const lines = [
+    `Title: ${title}`,
+    `Run: ${args.runId}`,
+    `Workflow: ${args.workflowName}`,
+    `Outcome: ${args.outcome ?? "unknown"}`,
+    "",
+    "Prompt:",
+    args.prompt.trim(),
+    "",
+    "Response:",
+    args.response.trim()
+  ];
+  return lines.join("\n");
+}
+function buildEpisodeLearning(args, title) {
+  return {
+    kind: "episodic",
+    title,
+    content: formatEpisodeContent(args, title),
+    tags: args.tags ?? [],
+    confidence: 0.7
+  };
+}
+var MemoryService = class {
+  client;
+  vectorIndex;
+  fulltextIndex;
+  halfLifeSeconds;
+  onMemoryEvent;
+  cyUpsertMemory = cypher.upsertMemory;
+  cyUpsertCase = cypher.upsertCase;
+  cyRetrieveBundle = cypher.retrieveContextBundle;
+  cyFeedbackBatch = cypher.feedbackBatch;
+  cyFeedbackCoUsed = cypher.feedbackCoUsed;
+  cyListMemories = cypher.listMemories;
+  cyRelateConcepts = cypher.relateConcepts;
+  cyGetRecallEdges = `
+    UNWIND $ids AS id
+    MATCH (m:Memory {id:id})
+    OPTIONAL MATCH (a:Agent {id:$agentId})-[r:RECALLS]->(m)
+    RETURN id AS id,
+           r.a AS a,
+           r.b AS b,
+           r.strength AS strength,
+           r.evidence AS evidence,
+           toString(r.updatedAt) AS updatedAt
+  `;
+  constructor(cfg) {
+    this.client = new Neo4jClient(cfg.neo4j);
+    this.vectorIndex = cfg.vectorIndex ?? "memoryEmbedding";
+    this.fulltextIndex = cfg.fulltextIndex ?? "memoryText";
+    this.halfLifeSeconds = cfg.halfLifeSeconds ?? 30 * 24 * 3600;
+    this.onMemoryEvent = cfg.onMemoryEvent;
+  }
+  async init() {
+    await ensureSchema(this.client);
+  }
+  async close() {
+    await this.client.close();
+  }
+  ensureEnvHash(env) {
+    const e = env ?? {};
+    if (!e.hash) e.hash = envHash(e);
+    return e;
+  }
+  emit(event) {
+    if (!this.onMemoryEvent) return;
+    try {
+      this.onMemoryEvent({ ...event, at: (/* @__PURE__ */ new Date()).toISOString() });
+    } catch {
+    }
+  }
+  /**
+   * Save a distilled memory (semantic/procedural/episodic) with exact dedupe by contentHash.
+   * NOTE: This package intentionally does not store "full answers" as semantic/procedural.
+   */
+  async upsertMemory(l) {
+    const id = l.id ?? newId("mem");
+    const polarity = l.polarity ?? "positive";
+    const tags = [...new Set((l.tags ?? []).map((t) => t.trim()).filter(Boolean))];
+    const canonical = canonicaliseForHash(l.title, l.content, tags);
+    const contentHash = sha256Hex(canonical);
+    const read = this.client.session("READ");
+    try {
+      const existing = await read.run(
+        "MATCH (m:Memory {contentHash: $h}) RETURN m.id AS id LIMIT 1",
+        { h: contentHash }
+      );
+      if (existing.records.length > 0) {
+        const existingId = existing.records[0].get("id");
+        this.emit({ type: "write", action: "upsertMemory.dedupe", meta: { id: existingId } });
+        return { id: existingId, deduped: true };
+      }
+    } finally {
+      await read.close();
+    }
+    const write = this.client.session("WRITE");
+    try {
+      await write.run(this.cyUpsertMemory, {
+        id,
+        kind: l.kind,
+        polarity,
+        title: l.title,
+        content: l.content,
+        contentHash,
+        tags,
+        confidence: clamp01(l.confidence),
+        utility: 0.2,
+        // start modest; reinforce via feedback
+        triage: l.triage ? JSON.stringify(l.triage) : null,
+        antiPattern: l.antiPattern ? JSON.stringify(l.antiPattern) : null
+      });
+      if (l.env) {
+        const env = this.ensureEnvHash(l.env);
+        await write.run(
+          `MERGE (e:EnvironmentFingerprint {hash:$hash})
+           ON CREATE SET e.os=$os, e.distro=$distro, e.ci=$ci, e.container=$container,
+                         e.filesystem=$filesystem, e.workspaceMount=$workspaceMount,
+                         e.nodeVersion=$nodeVersion, e.packageManager=$packageManager, e.pmVersion=$pmVersion
+           WITH e
+           MATCH (m:Memory {id:$id})
+           MERGE (m)-[:APPLIES_IN]->(e)`,
+          {
+            id,
+            hash: env.hash,
+            os: env.os ?? null,
+            distro: env.distro ?? null,
+            ci: env.ci ?? null,
+            container: env.container ?? null,
+            filesystem: env.filesystem ?? null,
+            workspaceMount: env.workspaceMount ?? null,
+            nodeVersion: env.nodeVersion ?? null,
+            packageManager: env.packageManager ?? null,
+            pmVersion: env.pmVersion ?? null
+          }
+        );
+      }
+      this.emit({ type: "write", action: "upsertMemory", meta: { id } });
+      return { id, deduped: false };
+    } finally {
+      await write.close();
+    }
+  }
+  /**
+   * Upsert an episodic Case (case-based reasoning) that links symptoms + env + resolved_by + negative memories.
+   */
+  async upsertCase(c) {
+    const env = this.ensureEnvHash(c.env);
+    const symptoms = [...new Set((c.symptoms ?? []).map(normaliseSymptom).filter(Boolean))];
+    const session = this.client.session("WRITE");
+    try {
+      const res = await session.run(this.cyUpsertCase, {
+        caseId: c.id,
+        title: c.title,
+        summary: c.summary,
+        outcome: c.outcome,
+        symptoms,
+        env,
+        resolvedByMemoryIds: c.resolvedByMemoryIds ?? [],
+        negativeMemoryIds: c.negativeMemoryIds ?? [],
+        resolvedAtIso: c.resolvedAtIso ?? null
+      });
+      const caseId = res.records[0].get("caseId");
+      this.emit({ type: "write", action: "upsertCase", meta: { caseId } });
+      return caseId;
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Retrieve a ContextBundle with separate Fix and Do-not-do sections, using case-based reasoning.
+   * The key idea: match cases by symptoms + env similarity, then pull linked memories.
+   */
+  async retrieveContextBundle(args) {
+    const nowIso = args.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+    const symptoms = [...new Set((args.symptoms ?? []).map(normaliseSymptom).filter(Boolean))];
+    const env = this.ensureEnvHash(args.env ?? {});
+    const caseLimit = args.caseLimit ?? 5;
+    const fixLimit = args.fixLimit ?? 8;
+    const dontLimit = args.dontLimit ?? 6;
+    const session = this.client.session("READ");
+    try {
+      const r = await session.run(this.cyRetrieveBundle, {
+        agentId: args.agentId,
+        symptoms,
+        tags: args.tags ?? [],
+        env,
+        caseLimit,
+        fixLimit,
+        dontLimit,
+        nowIso,
+        halfLifeSeconds: this.halfLifeSeconds
+      });
+      const sections = r.records[0].get("sections");
+      const fixes = (sections.fixes ?? []).map((m) => ({
+        id: m.id,
+        kind: m.kind,
+        polarity: m.polarity ?? "positive",
+        title: m.title,
+        content: m.content,
+        tags: m.tags ?? [],
+        confidence: m.confidence ?? 0.7,
+        utility: m.utility ?? 0.2,
+        updatedAt: m.updatedAt?.toString?.() ?? null
+      }));
+      const doNot = (sections.doNot ?? []).map((m) => ({
+        id: m.id,
+        kind: m.kind,
+        polarity: m.polarity ?? "negative",
+        title: m.title,
+        content: m.content,
+        tags: m.tags ?? [],
+        confidence: m.confidence ?? 0.7,
+        utility: m.utility ?? 0.2,
+        updatedAt: m.updatedAt?.toString?.() ?? null
+      }));
+      const allIds = [.../* @__PURE__ */ new Set([...fixes.map((x) => x.id), ...doNot.map((x) => x.id)])];
+      const edgeAfter = /* @__PURE__ */ new Map();
+      if (allIds.length > 0) {
+        const edgeRes = await session.run(this.cyGetRecallEdges, { agentId: args.agentId, ids: allIds });
+        for (const rec of edgeRes.records) {
+          const id = rec.get("id");
+          edgeAfter.set(id, {
+            a: rec.get("a"),
+            b: rec.get("b"),
+            strength: rec.get("strength"),
+            evidence: rec.get("evidence"),
+            updatedAt: rec.get("updatedAt")
+          });
+        }
+      }
+      const fixesWithEdges = fixes.map((m) => ({
+        ...m,
+        edgeBefore: toBetaEdge(edgeAfter.get(m.id)),
+        edgeAfter: void 0
+      }));
+      const doNotWithEdges = doNot.map((m) => ({
+        ...m,
+        edgeBefore: toBetaEdge(edgeAfter.get(m.id)),
+        edgeAfter: void 0
+      }));
+      const sessionId = newId("session");
+      const fixBlock = "## Recommended fixes\n" + fixesWithEdges.map((m) => `
+
+### [MEM:${m.id}] ${m.title}
+${m.content}`).join("");
+      const doNotDoBlock = "## Do not do\n" + doNotWithEdges.map((m) => `
+
+### [MEM:${m.id}] ${m.title}
+${m.content}`).join("");
+      this.emit({
+        type: "read",
+        action: "retrieveContextBundle",
+        meta: { sessionId, fixCount: fixesWithEdges.length, doNotCount: doNotWithEdges.length }
+      });
+      return {
+        sessionId,
+        sections: { fix: fixesWithEdges, doNotDo: doNotWithEdges },
+        injection: { fixBlock, doNotDoBlock }
+      };
+    } finally {
+      await session.close();
+    }
+  }
+  async listMemories(args = {}) {
+    const session = this.client.session("READ");
+    try {
+      const res = await session.run(this.cyListMemories, {
+        kind: args.kind ?? null,
+        limit: args.limit ?? 25,
+        agentId: args.agentId ?? null
+      });
+      const memories = res.records[0]?.get("memories") ?? [];
+      const summaries = memories.map((m) => ({
+        id: m.id,
+        kind: m.kind,
+        polarity: m.polarity ?? "positive",
+        title: m.title,
+        tags: m.tags ?? [],
+        confidence: m.confidence ?? 0.7,
+        utility: m.utility ?? 0.2,
+        createdAt: m.createdAt?.toString?.() ?? null,
+        updatedAt: m.updatedAt?.toString?.() ?? null
+      }));
+      this.emit({ type: "read", action: "listMemories", meta: { count: summaries.length, kind: args.kind } });
+      return summaries;
+    } finally {
+      await session.close();
+    }
+  }
+  async listEpisodes(args = {}) {
+    return this.listMemories({ ...args, kind: "episodic" });
+  }
+  async listSkills(args = {}) {
+    return this.listMemories({ ...args, kind: "procedural" });
+  }
+  async listConcepts(args = {}) {
+    return this.listMemories({ ...args, kind: "semantic" });
+  }
+  async relateConcepts(args) {
+    const weight = typeof args.weight === "number" ? args.weight : 0.5;
+    const session = this.client.session("WRITE");
+    try {
+      await session.run(this.cyRelateConcepts, { a: args.sourceId, b: args.targetId, weight });
+      this.emit({ type: "write", action: "relateConcepts", meta: { sourceId: args.sourceId, targetId: args.targetId } });
+    } finally {
+      await session.close();
+    }
+  }
+  async captureEpisode(args) {
+    const title = `Episode ${args.workflowName} (${args.runId})`;
+    const learning = buildEpisodeLearning(args, title);
+    const result = await this.saveLearnings({
+      agentId: args.agentId,
+      sessionId: args.runId,
+      learnings: [learning]
+    });
+    this.emit({ type: "write", action: "captureEpisode", meta: { runId: args.runId, title } });
+    return result;
+  }
+  async captureStepEpisode(args) {
+    const title = `Episode ${args.workflowName} - ${args.stepName}`;
+    const base = {
+      agentId: args.agentId,
+      runId: args.runId,
+      workflowName: args.workflowName,
+      prompt: args.prompt,
+      response: args.response,
+      outcome: args.outcome,
+      tags: args.tags
+    };
+    const learning = buildEpisodeLearning(base, title);
+    const result = await this.saveLearnings({
+      agentId: args.agentId,
+      sessionId: args.runId,
+      learnings: [learning]
+    });
+    this.emit({ type: "write", action: "captureStepEpisode", meta: { runId: args.runId, stepName: args.stepName } });
+    return result;
+  }
+  /**
+   * Reinforce/degrade agent->memory association weights using a single batched Cypher query.
+   * This supports mid-run retrieval by making feedback cheap and frequent.
+   */
+  async feedback(fb) {
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const used = new Set(fb.usedIds ?? []);
+    const useful = new Set(fb.usefulIds ?? []);
+    const notUseful = new Set(fb.notUsefulIds ?? []);
+    const prevented = new Set(fb.preventedErrorIds ?? []);
+    for (const id of prevented) useful.add(id);
+    for (const id of useful) notUseful.delete(id);
+    for (const id of useful) used.add(id);
+    for (const id of notUseful) used.add(id);
+    const quality = clamp01(fb.metrics?.quality ?? 0.7);
+    const hallucRisk = clamp01(fb.metrics?.hallucinationRisk ?? 0.2);
+    const baseY = clamp01(quality - 0.7 * hallucRisk);
+    const w = 0.5 + 1.5 * quality;
+    const yById = /* @__PURE__ */ new Map();
+    for (const id of used) {
+      yById.set(id, useful.has(id) ? baseY : 0);
+    }
+    const items = [...used].map((memoryId) => ({
+      memoryId,
+      y: yById.get(memoryId) ?? 0,
+      w
+    }));
+    if (items.length === 0) return;
+    const session = this.client.session("WRITE");
+    try {
+      await session.run("MERGE (a:Agent {id:$id}) RETURN a", { id: fb.agentId });
+      await session.run(this.cyFeedbackBatch, {
+        agentId: fb.agentId,
+        nowIso,
+        items,
+        halfLifeSeconds: this.halfLifeSeconds,
+        aMin: 1e-3,
+        bMin: 1e-3
+      });
+      const ids = [...used];
+      const pairs = [];
+      for (let i = 0; i < ids.length; i++) {
+        for (let j = i + 1; j < ids.length; j++) {
+          const a = ids[i] < ids[j] ? ids[i] : ids[j];
+          const b = ids[i] < ids[j] ? ids[j] : ids[i];
+          const yA = yById.get(a) ?? 0;
+          const yB = yById.get(b) ?? 0;
+          pairs.push({ a, b, y: Math.min(yA, yB), w });
+        }
+      }
+      if (pairs.length > 0) {
+        await session.run(this.cyFeedbackCoUsed, {
+          nowIso,
+          pairs,
+          halfLifeSeconds: this.halfLifeSeconds,
+          aMin: 1e-3,
+          bMin: 1e-3
+        });
+      }
+      this.emit({ type: "write", action: "feedback", meta: { agentId: fb.agentId, usedCount: used.size } });
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Save distilled learnings discovered during a task.
+   * Enforces quality gates and stores negative memories explicitly.
+   * Automatically creates a Case if learnings have triage.symptoms.
+   */
+  async saveLearnings(req) {
+    const pol = defaultPolicy(req.policy);
+    const limited = (req.learnings ?? []).slice(0, pol.maxItems);
+    const saved = [];
+    const rejected = [];
+    const positiveMemoryIds = [];
+    const negativeMemoryIds = [];
+    let firstEnv;
+    let allSymptoms = [];
+    for (const l of limited) {
+      const reason = validateLearning(l, pol);
+      if (reason) {
+        rejected.push({ title: l.title, reason });
+        continue;
+      }
+      const res = await this.upsertMemory(l);
+      saved.push({ id: res.id, kind: l.kind, title: l.title, deduped: res.deduped });
+      const polarity = l.polarity ?? "positive";
+      if (polarity === "positive") {
+        positiveMemoryIds.push(res.id);
+      } else {
+        negativeMemoryIds.push(res.id);
+      }
+      if (l.triage?.symptoms) {
+        allSymptoms.push(...l.triage.symptoms);
+      }
+      if (l.env && !firstEnv) {
+        firstEnv = l.env;
+      }
+    }
+    if (allSymptoms.length > 0 && (positiveMemoryIds.length > 0 || negativeMemoryIds.length > 0)) {
+      const uniqueSymptoms = [...new Set(allSymptoms)];
+      const caseId = req.sessionId ? `case_${req.sessionId}` : newId("case");
+      await this.upsertCase({
+        id: caseId,
+        title: req.learnings[0]?.title ?? "Auto-generated case",
+        summary: `Case auto-created from ${saved.length} learnings`,
+        outcome: "resolved",
+        symptoms: uniqueSymptoms,
+        env: firstEnv ?? {},
+        resolvedByMemoryIds: positiveMemoryIds,
+        negativeMemoryIds,
+        resolvedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log(`\u2705 Auto-created Case ${caseId} linking ${positiveMemoryIds.length} positive and ${negativeMemoryIds.length} negative memories to symptoms: [${uniqueSymptoms.join(", ")}]`);
+    }
+    this.emit({
+      type: "write",
+      action: "saveLearnings",
+      meta: { savedCount: saved.length, rejectedCount: rejected.length }
+    });
+    return { saved, rejected };
+  }
+};
+async function createMemoryService(cfg) {
+  const svc = new MemoryService(cfg);
+  await svc.init();
+  return svc;
+}
+
+// src/tools.ts
+import { z } from "zod";
+var storeInputSchema = z.object({
+  agentId: z.string(),
+  title: z.string().min(4),
+  content: z.string().min(20),
+  tags: z.array(z.string()).min(1),
+  confidence: z.number().min(0).max(1).optional(),
+  env: z.record(z.string(), z.any()).optional(),
+  triage: z.object({
+    symptoms: z.array(z.string()).min(1),
+    likelyCauses: z.array(z.string()).min(1),
+    verificationSteps: z.array(z.string()).optional(),
+    fixSteps: z.array(z.string()).optional(),
+    gotchas: z.array(z.string()).optional()
+  }).optional(),
+  antiPattern: z.object({
+    action: z.string(),
+    whyBad: z.string(),
+    saferAlternative: z.string().optional()
+  }).optional()
+});
+var recallInputSchema = z.object({
+  agentId: z.string().optional(),
+  limit: z.number().int().min(1).max(100).optional()
+});
+var relateInputSchema = z.object({
+  sourceId: z.string(),
+  targetId: z.string(),
+  weight: z.number().min(0).max(1).optional()
+});
+function toLearning(kind, input, extraTags = []) {
+  return {
+    kind,
+    title: input.title,
+    content: input.content,
+    tags: [.../* @__PURE__ */ new Set([...input.tags ?? [], ...extraTags])],
+    confidence: input.confidence ?? 0.7,
+    env: input.env,
+    triage: input.triage,
+    antiPattern: input.antiPattern
+  };
+}
+function createMemoryTools(service) {
+  const storeBase = (kind, extraTags = []) => ({
+    name: "store_concept",
+    description: "Store a memory item.",
+    inputSchema: storeInputSchema,
+    execute: async (input) => {
+      const learning = toLearning(kind, input, extraTags);
+      return service.saveLearnings({ agentId: input.agentId, learnings: [learning] });
+    }
+  });
+  const recallBase = async (kind, input) => {
+    if (kind === "skills") return service.listSkills({ agentId: input.agentId, limit: input.limit });
+    if (kind === "concepts") return service.listConcepts({ agentId: input.agentId, limit: input.limit });
+    const memories = await service.listConcepts({ agentId: input.agentId, limit: input.limit });
+    return memories.filter((m) => m.tags.includes("pattern"));
+  };
+  return {
+    store_skill: {
+      ...storeBase("procedural"),
+      name: "store_skill",
+      description: "Store a procedural memory (skill)."
+    },
+    store_pattern: {
+      ...storeBase("semantic", ["pattern"]),
+      name: "store_pattern",
+      description: "Store a semantic memory tagged as a pattern."
+    },
+    store_concept: {
+      ...storeBase("semantic"),
+      name: "store_concept",
+      description: "Store a semantic memory (concept)."
+    },
+    relate_concepts: {
+      name: "relate_concepts",
+      description: "Relate two concept memories with a weighted edge.",
+      inputSchema: relateInputSchema,
+      execute: async (input) => {
+        await service.relateConcepts({
+          sourceId: input.sourceId,
+          targetId: input.targetId,
+          weight: input.weight
+        });
+        return { ok: true };
+      }
+    },
+    recall_skills: {
+      name: "recall_skills",
+      description: "List stored skills (procedural memories).",
+      inputSchema: recallInputSchema,
+      execute: (input) => recallBase("skills", input)
+    },
+    recall_concepts: {
+      name: "recall_concepts",
+      description: "List stored concepts (semantic memories).",
+      inputSchema: recallInputSchema,
+      execute: (input) => recallBase("concepts", input)
+    },
+    recall_patterns: {
+      name: "recall_patterns",
+      description: "List stored patterns (semantic memories tagged 'pattern').",
+      inputSchema: recallInputSchema,
+      execute: (input) => recallBase("patterns", input)
+    }
+  };
+}
+export {
+  MemoryService,
+  Neo4jClient,
+  canonicaliseForHash,
+  createMemoryService,
+  createMemoryTools,
+  cypher,
+  ensureSchema,
+  envHash,
+  loadCypher,
+  migrate,
+  newId,
+  normaliseSymptom,
+  schemaVersion,
+  sha256Hex
+};