@gethmy/mcp 2.3.0 → 2.3.2

package/dist/lib/active-learning.js

@@ -1,822 +1,974 @@
-/**
- * Active Learning Loop
- *
- * Auto-extracts memories from agent work sessions.
- * Triggered on harmony_end_agent_session and harmony_update_agent_progress.
- */
-import { getActiveProjectId, getActiveWorkspaceId } from "./config.js";
-import { autoExpandGraph, findSimilarEntities, linkCrossTypeNeighbors, } from "./graph-expansion.js";
-// Entity types that can participate in `contradicts` relations (per schema.ts)
-const CONTRADICTION_TYPES = new Set([
-    "decision",
-    "pattern",
-    "preference",
-    "lesson",
-]);
-// --- Mid-Session Learning ---
-/** Track previous task per session for change detection */
-const sessionTaskHistory = new Map();
-/** Rate limit: max 1 extraction per 2 minutes per session */
-const MID_SESSION_RATE_LIMIT_MS = 120_000;
-/**
- * Simple Levenshtein similarity (0-1 range, 1 = identical).
- */
-function levenshteinSimilarity(a, b) {
-    if (a === b)
-        return 1;
-    if (a.length === 0 || b.length === 0)
-        return 0;
-    // Use shorter strings for performance (truncate to 200 chars)
-    const sa = a.slice(0, 200).toLowerCase();
-    const sb = b.slice(0, 200).toLowerCase();
-    const matrix = [];
-    for (let i = 0; i <= sa.length; i++) {
-        matrix[i] = [i];
-    }
-    for (let j = 0; j <= sb.length; j++) {
-        matrix[0][j] = j;
-    }
-    for (let i = 1; i <= sa.length; i++) {
-        for (let j = 1; j <= sb.length; j++) {
-            const cost = sa[i - 1] === sb[j - 1] ? 0 : 1;
-            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
-        }
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_API_URL = "https://app.gethmy.com/api";
+var LOCAL_CONFIG_FILENAME = ".harmony-mcp.json";
+function getConfigDir() {
+  return join(homedir(), ".harmony-mcp");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function getLocalConfigPath(cwd) {
+  return join(cwd || process.cwd(), LOCAL_CONFIG_FILENAME);
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return {
+      apiKey: null,
+      apiUrl: DEFAULT_API_URL,
+      activeWorkspaceId: null,
+      activeProjectId: null,
+      userEmail: null,
+      memoryDir: null
+    };
+  }
+  try {
+    const data = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(data);
+    return {
+      apiKey: config.apiKey || null,
+      apiUrl: config.apiUrl || DEFAULT_API_URL,
+      activeWorkspaceId: config.activeWorkspaceId || null,
+      activeProjectId: config.activeProjectId || null,
+      userEmail: config.userEmail || null,
+      memoryDir: config.memoryDir || null
+    };
+  } catch {
+    return {
+      apiKey: null,
+      apiUrl: DEFAULT_API_URL,
+      activeWorkspaceId: null,
+      activeProjectId: null,
+      userEmail: null,
+      memoryDir: null
+    };
+  }
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 448 });
+  }
+  const existingConfig = loadConfig();
+  const newConfig = { ...existingConfig, ...config };
+  writeFileSync(configPath, JSON.stringify(newConfig, null, 2), {
+    mode: 384
+  });
+}
+function loadLocalConfig(cwd) {
+  const localConfigPath = getLocalConfigPath(cwd);
+  if (!existsSync(localConfigPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(localConfigPath, "utf-8");
+    const config = JSON.parse(data);
+    return {
+      workspaceId: config.workspaceId || null,
+      projectId: config.projectId || null
+    };
+  } catch {
+    return null;
+  }
+}
+function saveLocalConfig(config, cwd) {
+  const localConfigPath = getLocalConfigPath(cwd);
+  const existingConfig = loadLocalConfig(cwd) || {
+    workspaceId: null,
+    projectId: null
+  };
+  const newConfig = { ...existingConfig, ...config };
+  const cleanConfig = {};
+  if (newConfig.workspaceId)
+    cleanConfig.workspaceId = newConfig.workspaceId;
+  if (newConfig.projectId)
+    cleanConfig.projectId = newConfig.projectId;
+  writeFileSync(localConfigPath, JSON.stringify(cleanConfig, null, 2));
+}
+function hasLocalConfig(cwd) {
+  return existsSync(getLocalConfigPath(cwd));
+}
+function getApiKey() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    throw new Error(`Not configured. Run "npx @gethmy/mcp setup" to set your API key.
+` + "You can generate an API key at https://gethmy.com → Settings → API Keys.");
+  }
+  return config.apiKey;
+}
+function getApiUrl() {
+  const config = loadConfig();
+  return config.apiUrl;
+}
+function getUserEmail() {
+  const config = loadConfig();
+  return config.userEmail;
+}
+function setUserEmail(email) {
+  saveConfig({ userEmail: email });
+}
+function setActiveWorkspace(workspaceId, options) {
+  if (options?.local) {
+    saveLocalConfig({ workspaceId }, options.cwd);
+  } else {
+    saveConfig({ activeWorkspaceId: workspaceId });
+  }
+}
+function setActiveProject(projectId, options) {
+  if (options?.local) {
+    saveLocalConfig({ projectId }, options.cwd);
+  } else {
+    saveConfig({ activeProjectId: projectId });
+  }
+}
+function getActiveWorkspaceId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.workspaceId) {
+    return localConfig.workspaceId;
+  }
+  return loadConfig().activeWorkspaceId;
+}
+function getActiveProjectId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.projectId) {
+    return localConfig.projectId;
+  }
+  return loadConfig().activeProjectId;
+}
+function isConfigured() {
+  const config = loadConfig();
+  return !!config.apiKey;
+}
+function areSkillsInstalled(cwd) {
+  const home = homedir();
+  const workingDir = cwd || process.cwd();
+  const foundPaths = [];
+  const globalSkillsDir = join(home, ".agents", "skills");
+  const globalSkillPath = join(globalSkillsDir, "hmy", "SKILL.md");
+  if (existsSync(globalSkillPath)) {
+    foundPaths.push(globalSkillPath);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const claudeGlobalSkill = join(home, ".claude", "skills", "hmy.md");
+  if (existsSync(claudeGlobalSkill)) {
+    foundPaths.push(claudeGlobalSkill);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const claudeGlobalSkillAlt = join(home, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(claudeGlobalSkillAlt)) {
+    foundPaths.push(claudeGlobalSkillAlt);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const localSkillPath = join(workingDir, ".claude", "skills", "hmy.md");
+  if (existsSync(localSkillPath)) {
+    foundPaths.push(localSkillPath);
+    return { installed: true, location: "local", paths: foundPaths };
+  }
+  const localSkillPathAlt = join(workingDir, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(localSkillPathAlt)) {
+    foundPaths.push(localSkillPathAlt);
+    return { installed: true, location: "local", paths: foundPaths };
+  }
+  return { installed: false, location: null, paths: [] };
+}
+function hasProjectContext(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  return !!(localConfig?.workspaceId || localConfig?.projectId);
+}
+function getMemoryDir() {
+  const config = loadConfig();
+  if (config.memoryDir)
+    return config.memoryDir;
+  return join(homedir(), ".harmony", "memory");
+}
+
+// src/graph-expansion.ts
+async function autoExpandGraph(client, entityId, title, content, _tags, workspaceId, projectId, maxRelations = 5) {
+  try {
+    const contentSnippet = content.slice(0, 200).trim();
+    const query = [title, contentSnippet].filter(Boolean).join(" ");
+    let candidates = [];
+    const { entities } = await client.searchMemoryEntities(workspaceId, query, {
+      project_id: projectId,
+      limit: 20
+    });
+    candidates = entities.filter((e) => e.id !== entityId).slice(0, maxRelations);
+    if (candidates.length === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      const retry = await client.searchMemoryEntities(workspaceId, query, {
+        project_id: projectId,
+        limit: 20
+      });
+      candidates = retry.entities.filter((e) => e.id !== entityId).slice(0, maxRelations);
     }
-    const maxLen = Math.max(sa.length, sb.length);
-    return 1 - matrix[sa.length][sb.length] / maxLen;
-}
-/**
- * Extract learnings from mid-session progress updates.
- * Called from harmony_update_agent_progress.
- */
-export async function extractMidSessionLearnings(_client, ctx) {
-    const workspaceId = getActiveWorkspaceId();
-    if (!workspaceId)
-        return { count: 0, entityIds: [] };
-    const _projectId = getActiveProjectId() || undefined;
-    const now = Date.now();
-    const _entityIds = [];
-    const history = sessionTaskHistory.get(ctx.cardId);
-    // Always track step history regardless of rate limit
-    if (ctx.currentTask) {
-        const previousTask = history?.lastTask || "";
-        const similarity = levenshteinSimilarity(previousTask, ctx.currentTask);
-        const existingSteps = history?.steps || [];
-        if (existingSteps.length === 0 ||
-            (similarity < 0.6 && previousTask.length > 0)) {
-            const newStep = {
-                task: ctx.currentTask,
-                progress: ctx.progressPercent ?? 0,
-                timestamp: now,
-            };
-            if (existingSteps.length === 0 && previousTask.length > 0) {
-                existingSteps.push({
-                    task: previousTask,
-                    progress: 0,
-                    timestamp: history?.lastExtractionAt ?? now,
-                });
-            }
-            existingSteps.push(newStep);
-            sessionTaskHistory.set(ctx.cardId, {
-                lastTask: ctx.currentTask,
-                lastExtractionAt: history?.lastExtractionAt ?? 0,
-                steps: existingSteps,
-            });
-        }
+    let relationsCreated = 0;
+    for (const candidate of candidates) {
+      try {
+        await client.createMemoryRelation({
+          source_id: entityId,
+          target_id: candidate.id,
+          relation_type: "relates_to",
+          confidence: 0.6
+        });
+        relationsCreated++;
+      } catch (err) {
+        const status = err?.status;
+        if (status !== 409) {}
+      }
     }
-    // Rate limit check (only gates memory entity creation, not step tracking)
-    if (history && now - history.lastExtractionAt < MID_SESSION_RATE_LIMIT_MS) {
-        // Still within rate limit, but always extract blockers immediately
-        if (ctx.status !== "blocked" || !ctx.blockers?.length) {
-            return { count: 0, entityIds: [] };
-        }
+    return { relationsCreated };
+  } catch {
+    return { relationsCreated: 0 };
+  }
+}
+async function findSimilarEntities(client, title, content, workspaceId, options) {
+  const contentSnippet = content.slice(0, 200).trim();
+  const query = [title, contentSnippet].filter(Boolean).join(" ");
+  try {
+    const { entities } = await client.searchMemoryEntities(workspaceId, query, {
+      project_id: options?.projectId,
+      limit: options?.limit ?? 20,
+      type: options?.type
+    });
+    const minScore = options?.minRrfScore ?? 0;
+    const excludeSet = new Set(options?.excludeIds || []);
+    return entities.filter((e) => {
+      if (excludeSet.has(e.id))
+        return false;
+      if (minScore > 0 && (e.rrf_score ?? 0) < minScore)
+        return false;
+      return true;
+    });
+  } catch {
+    return [];
+  }
+}
+var CAUSAL_LOOKUP = [
+  {
+    sourceType: "error",
+    targetType: "solution",
+    relation: "resolved_by",
+    direction: "forward"
+  },
+  {
+    sourceType: "solution",
+    targetType: "error",
+    relation: "resolved_by",
+    direction: "reverse"
+  },
+  {
+    sourceType: "lesson",
+    targetType: "error",
+    relation: "learned_from",
+    direction: "forward"
+  }
+];
+async function linkCrossTypeNeighbors(client, entityId, entityType, title, content, workspaceId, projectId) {
+  const rules = CAUSAL_LOOKUP.filter((r) => r.sourceType === entityType);
+  if (rules.length === 0)
+    return { relationsCreated: 0 };
+  let relationsCreated = 0;
+  for (const rule of rules) {
+    try {
+      const matches = await findSimilarEntities(client, title, content, workspaceId, {
+        projectId,
+        limit: 10,
+        minRrfScore: 0.04,
+        excludeIds: [entityId],
+        type: rule.targetType
+      });
+      for (const match of matches.slice(0, 3)) {
+        const sourceId = rule.direction === "forward" ? entityId : match.id;
+        const targetId = rule.direction === "forward" ? match.id : entityId;
+        try {
+          await client.createMemoryRelation({
+            source_id: sourceId,
+            target_id: targetId,
+            relation_type: rule.relation,
+            confidence: 0.65
+          });
+          relationsCreated++;
+        } catch {}
+      }
+    } catch {}
+  }
+  return { relationsCreated };
+}
+
+// src/active-learning.ts
+var CONTRADICTION_TYPES = new Set([
+  "decision",
+  "pattern",
+  "preference",
+  "lesson"
+]);
+var sessionTaskHistory = new Map;
+var MID_SESSION_RATE_LIMIT_MS = 120000;
+function levenshteinSimilarity(a, b) {
+  if (a === b)
+    return 1;
+  if (a.length === 0 || b.length === 0)
+    return 0;
+  const sa = a.slice(0, 200).toLowerCase();
+  const sb = b.slice(0, 200).toLowerCase();
+  const matrix = [];
+  for (let i = 0;i <= sa.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0;j <= sb.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1;i <= sa.length; i++) {
+    for (let j = 1;j <= sb.length; j++) {
+      const cost = sa[i - 1] === sb[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
     }
-    // Rule 1: Status transitions to "blocked" → track but DON'T create mid-session entities.
-    // Blockers are captured at session end with full context — mid-session entities are
-    // low-confidence duplicates that add noise to the knowledge graph.
-    if (ctx.status === "blocked" && ctx.blockers?.length) {
-        sessionTaskHistory.set(ctx.cardId, {
-            lastTask: ctx.currentTask || "",
-            lastExtractionAt: now,
-            steps: history?.steps || [],
+  }
+  const maxLen = Math.max(sa.length, sb.length);
+  return 1 - matrix[sa.length][sb.length] / maxLen;
+}
+async function extractMidSessionLearnings(_client, ctx) {
+  const workspaceId = getActiveWorkspaceId();
+  if (!workspaceId)
+    return { count: 0, entityIds: [] };
+  const _projectId = getActiveProjectId() || undefined;
+  const now = Date.now();
+  const _entityIds = [];
+  const history = sessionTaskHistory.get(ctx.cardId);
+  if (ctx.currentTask) {
+    const previousTask = history?.lastTask || "";
+    const similarity = levenshteinSimilarity(previousTask, ctx.currentTask);
+    const existingSteps = history?.steps || [];
+    if (existingSteps.length === 0 || similarity < 0.6 && previousTask.length > 0) {
+      const newStep = {
+        task: ctx.currentTask,
+        progress: ctx.progressPercent ?? 0,
+        timestamp: now
+      };
+      if (existingSteps.length === 0 && previousTask.length > 0) {
+        existingSteps.push({
+          task: previousTask,
+          progress: 0,
+          timestamp: history?.lastExtractionAt ?? now
         });
-        return { count: 0, entityIds: [] };
+      }
+      existingSteps.push(newStep);
+      sessionTaskHistory.set(ctx.cardId, {
+        lastTask: ctx.currentTask,
+        lastExtractionAt: history?.lastExtractionAt ?? 0,
+        steps: existingSteps
+      });
     }
-    // Rule 2: Task transitions are tracked in step history (above) but no longer
-    // create separate context entities. The step history feeds procedure extraction
-    // at session end, which is more valuable than individual transition snapshots.
-    if (ctx.currentTask) {
-        const currentHistory = sessionTaskHistory.get(ctx.cardId);
-        sessionTaskHistory.set(ctx.cardId, {
-            lastTask: ctx.currentTask,
-            lastExtractionAt: currentHistory?.lastExtractionAt ?? 0,
-            steps: currentHistory?.steps || [],
-        });
+  }
+  if (history && now - history.lastExtractionAt < MID_SESSION_RATE_LIMIT_MS) {
+    if (ctx.status !== "blocked" || !ctx.blockers?.length) {
+      return { count: 0, entityIds: [] };
     }
+  }
+  if (ctx.status === "blocked" && ctx.blockers?.length) {
+    sessionTaskHistory.set(ctx.cardId, {
+      lastTask: ctx.currentTask || "",
+      lastExtractionAt: now,
+      steps: history?.steps || []
+    });
     return { count: 0, entityIds: [] };
+  }
+  if (ctx.currentTask) {
+    const currentHistory = sessionTaskHistory.get(ctx.cardId);
+    sessionTaskHistory.set(ctx.cardId, {
+      lastTask: ctx.currentTask,
+      lastExtractionAt: currentHistory?.lastExtractionAt ?? 0,
+      steps: currentHistory?.steps || []
+    });
+  }
+  return { count: 0, entityIds: [] };
 }
-/**
- * Clean up mid-session tracking for a card (call on session end).
- */
-export function clearMidSessionTracking(cardId) {
-    sessionTaskHistory.delete(cardId);
+function clearMidSessionTracking(cardId) {
+  sessionTaskHistory.delete(cardId);
 }
-/**
- * Enrich raw steps with progress deltas and key decision detection.
- * A step is a "key decision" if it represents a >20% progress jump.
- */
 function enrichSteps(steps) {
-    return steps.map((step, i) => {
-        const prevProgress = i > 0 ? steps[i - 1].progress : 0;
-        const prevTimestamp = i > 0 ? steps[i - 1].timestamp : step.timestamp;
-        const progressDelta = step.progress - prevProgress;
-        return {
-            task: step.task,
-            progress: step.progress,
-            progressDelta,
-            durationMs: step.timestamp - prevTimestamp,
-            isKeyDecision: progressDelta >= 20,
-        };
-    });
+  return steps.map((step, i) => {
+    const prevProgress = i > 0 ? steps[i - 1].progress : 0;
+    const prevTimestamp = i > 0 ? steps[i - 1].timestamp : step.timestamp;
+    const progressDelta = step.progress - prevProgress;
+    return {
+      task: step.task,
+      progress: step.progress,
+      progressDelta,
+      durationMs: step.timestamp - prevTimestamp,
+      isKeyDecision: progressDelta >= 20
+    };
+  });
 }
-/**
- * Build structured procedure content from session data and enriched steps.
- */
 function buildProcedureContent(session, enrichedSteps, wikiLinksLine) {
-    const triggerLabels = session.cardLabels.length > 0
-        ? `Labels: ${session.cardLabels.join(", ")}`
-        : "";
-    const stepsMarkdown = enrichedSteps
-        .map((s, i) => {
-        const marker = s.isKeyDecision ? " **[key step]**" : "";
-        const duration = s.durationMs > 0 ? ` (~${Math.round(s.durationMs / 60000)}min)` : "";
-        return `${i + 1}. ${s.task} (${s.progress}%, +${s.progressDelta}%)${marker}${duration}`;
-    })
-        .join("\n");
-    const subtaskSection = session.cardSubtasks && session.cardSubtasks.length > 0
-        ? [
-            "",
-            "## Subtasks Completed",
-            ...session.cardSubtasks.map((s) => `- [${s.done ? "x" : " "}] ${s.title}`),
-        ].join("\n")
-        : "";
-    const durationInfo = session.sessionDurationMs
-        ? `\nDuration: ${Math.round(session.sessionDurationMs / 60000)} minutes`
-        : "";
-    return [
-        "## Trigger",
-        `When working on: "${session.cardTitle}"`,
-        triggerLabels,
-        "",
-        "## Steps",
-        stepsMarkdown,
-        subtaskSection,
-        "",
-        "## Outcome",
-        `Completed at ${session.progressPercent ?? "unknown"}%`,
-        session.currentTask ? `Final state: ${session.currentTask}` : "",
-        `Agent: ${session.agentName}`,
-        durationInfo,
-        wikiLinksLine,
-    ]
-        .filter((line) => line !== undefined)
-        .join("\n");
-}
-/**
- * Extract a new procedure or reinforce an existing similar one.
- *
- * Deduplication: searches for existing procedure entities with similar titles.
- * If found, merges new steps and bumps confidence. Otherwise creates a new one.
- */
+  const triggerLabels = session.cardLabels.length > 0 ? `Labels: ${session.cardLabels.join(", ")}` : "";
+  const stepsMarkdown = enrichedSteps.map((s, i) => {
+    const marker = s.isKeyDecision ? " **[key step]**" : "";
+    const duration = s.durationMs > 0 ? ` (~${Math.round(s.durationMs / 60000)}min)` : "";
+    return `${i + 1}. ${s.task} (${s.progress}%, +${s.progressDelta}%)${marker}${duration}`;
+  }).join(`
+`);
+  const subtaskSection = session.cardSubtasks && session.cardSubtasks.length > 0 ? [
+    "",
+    "## Subtasks Completed",
+    ...session.cardSubtasks.map((s) => `- [${s.done ? "x" : " "}] ${s.title}`)
+  ].join(`
+`) : "";
+  const durationInfo = session.sessionDurationMs ? `
+Duration: ${Math.round(session.sessionDurationMs / 60000)} minutes` : "";
+  return [
+    "## Trigger",
+    `When working on: "${session.cardTitle}"`,
+    triggerLabels,
+    "",
+    "## Steps",
+    stepsMarkdown,
+    subtaskSection,
+    "",
+    "## Outcome",
+    `Completed at ${session.progressPercent ?? "unknown"}%`,
+    session.currentTask ? `Final state: ${session.currentTask}` : "",
+    `Agent: ${session.agentName}`,
+    durationInfo,
+    wikiLinksLine
+  ].filter((line) => line !== undefined).join(`
+`);
+}
 async function extractOrReinforceProcedure(client, session, steps, workspaceId, projectId, wikiLinksLine = "") {
-    const enrichedSteps = enrichSteps(steps);
-    const newContent = buildProcedureContent(session, enrichedSteps, wikiLinksLine);
-    const tags = [
-        "auto-extracted",
-        "procedure",
-        ...session.cardLabels.slice(0, 3),
-    ];
-    // Try to find an existing similar procedure to reinforce
-    try {
-        const similar = await findSimilarEntities(client, `Procedure: ${session.cardTitle}`, newContent, workspaceId, { projectId, limit: 5, minRrfScore: 0.03 });
-        const matchingProcedure = similar.find((e) => e.type === "procedure" && (e.rrf_score ?? 0) >= 0.05);
-        if (matchingProcedure) {
-            // Fetch the full entity to get metadata and memory_tier
-            const { entity: rawEntity } = await client.getMemoryEntity(matchingProcedure.id);
-            const fullEntity = rawEntity;
-            const currentMeta = fullEntity.metadata || {};
-            const sourceCards = (currentMeta.source_cards || []).slice();
-            if (!sourceCards.includes(session.cardId)) {
-                sourceCards.push(session.cardId);
-            }
-            const reuseCount = (currentMeta.reuse_count || 0) + 1;
-            const currentConfidence = fullEntity.confidence ?? 0.7;
-            // Bump confidence by 0.05 per reinforcement, max 0.95
-            const newConfidence = Math.min(0.95, currentConfidence + 0.05);
-            // Append new steps as an additional execution record
-            const stepsAppendix = enrichedSteps
-                .map((s, i) => `${i + 1}. ${s.task} (${s.progress}%)`)
-                .join("\n");
-            const appendix = `\n\n---\n### Execution ${reuseCount + 1}: ${session.cardTitle}\n${stepsAppendix}\nAgent: ${session.agentName} | ${new Date().toISOString().split("T")[0]}`;
-            const updatedMeta = {
-                ...currentMeta,
-                reuse_count: reuseCount,
-                source_cards: sourceCards,
-                last_reinforced_at: new Date().toISOString(),
-                step_count: Math.max(currentMeta.step_count || 0, steps.length),
-            };
-            // Auto-promote to reference tier if reinforced enough (≥3 executions)
-            const shouldPromote = reuseCount >= 2 && fullEntity.memory_tier !== "reference";
-            await client.updateMemoryEntity(fullEntity.id, {
-                content: (fullEntity.content || "") + appendix,
-                confidence: newConfidence,
-                metadata: {
-                    ...updatedMeta,
-                    ...(shouldPromote
-                        ? {
-                            promoted_reason: `Reinforced by ${reuseCount + 1} successful sessions`,
-                            promoted_at: new Date().toISOString(),
-                        }
-                        : {}),
-                },
-                ...(shouldPromote ? { memory_tier: "reference" } : {}),
-            });
-            return { mode: "reinforced", entityId: fullEntity.id };
-        }
+  const enrichedSteps = enrichSteps(steps);
+  const newContent = buildProcedureContent(session, enrichedSteps, wikiLinksLine);
+  const tags = [
+    "auto-extracted",
+    "procedure",
+    ...session.cardLabels.slice(0, 3)
+  ];
+  try {
+    const similar = await findSimilarEntities(client, `Procedure: ${session.cardTitle}`, newContent, workspaceId, { projectId, limit: 5, minRrfScore: 0.03 });
+    const matchingProcedure = similar.find((e) => e.type === "procedure" && (e.rrf_score ?? 0) >= 0.05);
+    if (matchingProcedure) {
+      const { entity: rawEntity } = await client.getMemoryEntity(matchingProcedure.id);
+      const fullEntity = rawEntity;
+      const currentMeta = fullEntity.metadata || {};
+      const sourceCards = (currentMeta.source_cards || []).slice();
+      if (!sourceCards.includes(session.cardId)) {
+        sourceCards.push(session.cardId);
+      }
+      const reuseCount = (currentMeta.reuse_count || 0) + 1;
+      const currentConfidence = fullEntity.confidence ?? 0.7;
+      const newConfidence = Math.min(0.95, currentConfidence + 0.05);
+      const stepsAppendix = enrichedSteps.map((s, i) => `${i + 1}. ${s.task} (${s.progress}%)`).join(`
+`);
+      const appendix = `
+
+---
+### Execution ${reuseCount + 1}: ${session.cardTitle}
+${stepsAppendix}
+Agent: ${session.agentName} | ${new Date().toISOString().split("T")[0]}`;
+      const updatedMeta = {
+        ...currentMeta,
+        reuse_count: reuseCount,
+        source_cards: sourceCards,
+        last_reinforced_at: new Date().toISOString(),
+        step_count: Math.max(currentMeta.step_count || 0, steps.length)
+      };
+      const shouldPromote = reuseCount >= 2 && fullEntity.memory_tier !== "reference";
+      await client.updateMemoryEntity(fullEntity.id, {
+        content: (fullEntity.content || "") + appendix,
+        confidence: newConfidence,
+        metadata: {
+          ...updatedMeta,
+          ...shouldPromote ? {
+            promoted_reason: `Reinforced by ${reuseCount + 1} successful sessions`,
+            promoted_at: new Date().toISOString()
+          } : {}
+        },
+        ...shouldPromote ? { memory_tier: "reference" } : {}
+      });
+      return { mode: "reinforced", entityId: fullEntity.id };
     }
-    catch {
-        // Similarity search failed, fall through to create new
+  } catch {}
+  return {
+    mode: "created",
+    learning: {
+      title: `Procedure: ${session.cardTitle}`,
+      content: newContent,
+      type: "procedure",
+      tier: "episode",
+      confidence: 0.7,
+      tags,
+      metadata: {
+        source: "active_learning",
+        card_id: session.cardId,
+        source_cards: [session.cardId],
+        step_count: steps.length,
+        key_step_count: enrichedSteps.filter((s) => s.isKeyDecision).length,
+        reuse_count: 0
+      }
     }
-    // No existing procedure found — create a new one
-    return {
-        mode: "created",
-        learning: {
-            title: `Procedure: ${session.cardTitle}`,
-            content: newContent,
-            type: "procedure",
-            tier: "episode",
-            confidence: 0.7,
-            tags,
-            metadata: {
-                source: "active_learning",
-                card_id: session.cardId,
-                source_cards: [session.cardId],
-                step_count: steps.length,
-                key_step_count: enrichedSteps.filter((s) => s.isKeyDecision).length,
-                reuse_count: 0,
-            },
-        },
-    };
+  };
 }
-// --- Same-Session Causal Linking ---
-/** Causal pairing rules for entities created within the same session */
-const SESSION_CAUSAL_RULES = [
-    {
-        sourceType: "error",
-        targetType: "solution",
-        relation: "resolved_by",
-        confidence: 0.8,
-    },
-    {
-        sourceType: "lesson",
-        targetType: "error",
-        relation: "learned_from",
-        confidence: 0.75,
-    },
+var SESSION_CAUSAL_RULES = [
+  {
+    sourceType: "error",
+    targetType: "solution",
+    relation: "resolved_by",
+    confidence: 0.8
+  },
+  {
+    sourceType: "lesson",
+    targetType: "error",
+    relation: "learned_from",
+    confidence: 0.75
+  }
 ];
-/**
- * Link entities created within the same session using causal relations.
- *
- * For example, if a session produces both an `error` and a `solution`,
- * creates an `error -[resolved_by]-> solution` relation.
- *
- * Non-fatal: all errors are caught silently.
- */
-export async function linkSessionEntities(client, createdPairs, _workspaceId, _projectId) {
-    let relationsCreated = 0;
-    for (const rule of SESSION_CAUSAL_RULES) {
-        const sources = createdPairs.filter((p) => p.learning.type === rule.sourceType);
-        const targets = createdPairs.filter((p) => p.learning.type === rule.targetType);
-        for (const source of sources) {
-            for (const target of targets) {
-                try {
-                    await client.createMemoryRelation({
-                        source_id: source.id,
-                        target_id: target.id,
-                        relation_type: rule.relation,
-                        confidence: rule.confidence,
-                    });
-                    relationsCreated++;
-                }
-                catch {
-                    // Skip duplicate/failed relations silently
-                }
-            }
-        }
-    }
-    return { relationsCreated };
-}
-// --- Session-End Learning ---
-/**
- * Extract learnings from a completed agent session.
- * Returns the number of memories created.
- */
-export async function extractLearnings(client, session) {
-    const workspaceId = getActiveWorkspaceId();
-    if (!workspaceId) {
-        return { count: 0, entityIds: [] };
-    }
-    const projectId = getActiveProjectId() || undefined;
-    const learnings = [];
-    // Search for related entities to enrich summaries with wiki-links
-    let relatedEntityTitles = [];
-    if (workspaceId) {
+async function linkSessionEntities(client, createdPairs, _workspaceId, _projectId) {
+  let relationsCreated = 0;
+  for (const rule of SESSION_CAUSAL_RULES) {
+    const sources = createdPairs.filter((p) => p.learning.type === rule.sourceType);
+    const targets = createdPairs.filter((p) => p.learning.type === rule.targetType);
+    for (const source of sources) {
+      for (const target of targets) {
         try {
-            const searchQuery = [
-                session.cardTitle,
-                session.currentTask || "",
-                ...session.cardLabels,
-            ]
-                .filter(Boolean)
-                .join(" ");
-            const similar = await findSimilarEntities(client, searchQuery, session.currentTask || session.cardTitle, workspaceId, { projectId, limit: 5, minRrfScore: 0.01 });
-            relatedEntityTitles = similar.slice(0, 3).map((e) => e.title);
-        }
-        catch {
-            /* non-fatal */
-        }
-    }
-    const wikiLinksLine = relatedEntityTitles.length > 0
-        ? `\nRelated: ${relatedEntityTitles.map((t) => `[[${t}]]`).join(", ")}`
-        : "";
-    // Rule 1: Session had blockers → create error entity (only for substantial blockers)
-    // Skip trivial blocker strings — only store if the blocker text contains
-    // enough detail to be useful to a future agent (>80 chars).
-    if (session.blockers && session.blockers.length > 0) {
-        for (const blocker of session.blockers) {
-            if (blocker.length < 80)
-                continue; // Skip trivial blockers like "stuck" or "waiting on API"
-            // Dedup: check if a similar error entity already exists
-            let isDuplicate = false;
-            try {
-                const similar = await findSimilarEntities(client, blocker.slice(0, 200), blocker, workspaceId, { projectId, limit: 3, minRrfScore: 0.05 });
-                isDuplicate = similar.some((e) => e.type === "error" && (e.rrf_score ?? 0) >= 0.06);
-            }
-            catch {
-                /* non-fatal */
-            }
-            if (!isDuplicate) {
-                learnings.push({
-                    title: `Blocker: ${blocker.slice(0, 100)}`,
-                    content: `Encountered while working on "${session.cardTitle}":\n\n${blocker}\n\nAgent: ${session.agentName}\nSession status: ${session.status}`,
-                    type: "error",
-                    tier: "episode",
-                    confidence: 0.6,
-                    tags: [
-                        "auto-extracted",
-                        "blocker",
-                        ...session.cardLabels.slice(0, 3),
-                    ],
-                    metadata: {
-                        source: "active_learning",
-                        card_id: session.cardId,
-                    },
-                });
-            }
-        }
+          await client.createMemoryRelation({
+            source_id: source.id,
+            target_id: target.id,
+            relation_type: rule.relation,
+            confidence: rule.confidence
+          });
+          relationsCreated++;
+        } catch {}
+      }
     }
-    // Rule 2: Session paused with blockers → create lesson (paused only, not clean completions).
-    // Clean completions produce no reusable knowledge — the work is in the code/PR.
-    // Only create a lesson when the session was interrupted (paused with blockers),
-    // so a future agent can understand what was left unfinished and why.
-    if (session.status === "paused" && (session.blockers?.length ?? 0) > 0) {
-        const durationInfo = session.sessionDurationMs
-            ? `\nDuration: ${Math.round(session.sessionDurationMs / 60000)} minutes`
-            : "";
+  }
+  return { relationsCreated };
+}
+async function extractLearnings(client, session) {
+  const workspaceId = getActiveWorkspaceId();
+  if (!workspaceId) {
+    return { count: 0, entityIds: [] };
+  }
+  const projectId = getActiveProjectId() || undefined;
+  const learnings = [];
+  let relatedEntityTitles = [];
+  if (workspaceId) {
+    try {
+      const searchQuery = [
+        session.cardTitle,
+        session.currentTask || "",
+        ...session.cardLabels
+      ].filter(Boolean).join(" ");
+      const similar = await findSimilarEntities(client, searchQuery, session.currentTask || session.cardTitle, workspaceId, { projectId, limit: 5, minRrfScore: 0.01 });
+      relatedEntityTitles = similar.slice(0, 3).map((e) => e.title);
+    } catch {}
+  }
+  const wikiLinksLine = relatedEntityTitles.length > 0 ? `
+Related: ${relatedEntityTitles.map((t) => `[[${t}]]`).join(", ")}` : "";
+  if (session.blockers && session.blockers.length > 0) {
+    for (const blocker of session.blockers) {
+      if (blocker.length < 80)
+        continue;
+      let isDuplicate = false;
+      try {
+        const similar = await findSimilarEntities(client, blocker.slice(0, 200), blocker, workspaceId, { projectId, limit: 3, minRrfScore: 0.05 });
+        isDuplicate = similar.some((e) => e.type === "error" && (e.rrf_score ?? 0) >= 0.06);
+      } catch {}
+      if (!isDuplicate) {
         learnings.push({
-            title: `Paused: ${session.cardTitle}`,
-            content: [
-                `Paused work on "${session.cardTitle}".`,
-                session.currentTask ? `Last task: ${session.currentTask}` : "",
-                session.progressPercent !== undefined
-                    ? `Progress: ${session.progressPercent}%`
-                    : "",
-                durationInfo,
-                session.blockers?.length
-                    ? `Blockers: ${session.blockers.join("; ")}`
-                    : "",
-                `\nAgent: ${session.agentName}`,
-                wikiLinksLine,
-            ]
-                .filter(Boolean)
-                .join("\n"),
-            type: "lesson",
-            tier: "draft",
-            confidence: 0.6,
-            tags: [
-                "auto-extracted",
-                "session-paused",
-                ...session.cardLabels.slice(0, 3),
-            ],
-            metadata: {
-                source: "active_learning",
-                card_id: session.cardId,
-            },
+          title: `Blocker: ${blocker.slice(0, 100)}`,
+          content: `Encountered while working on "${session.cardTitle}":
+
+${blocker}
+
+Agent: ${session.agentName}
+Session status: ${session.status}`,
+          type: "error",
+          tier: "episode",
+          confidence: 0.6,
+          tags: [
+            "auto-extracted",
+            "blocker",
+            ...session.cardLabels.slice(0, 3)
+          ],
+          metadata: {
+            source: "active_learning",
+            card_id: session.cardId
+          }
         });
+      }
     }
-    // Rule 3: Bug solution — REMOVED.
-    // Storing "Resolved bug: {card title}" with no detail about the actual fix
-    // adds zero value. The real solution is in the code diff / PR. Agents should
-    // use `harmony_remember` to store non-obvious root cause details manually.
-    // Store learnings, tracking entity ID → learning for graph expansion
-    const entityIds = [];
-    // Rule 4: Successful session with tracked steps → create or reinforce procedure entity
-    // Thresholds raised: require 5+ distinct steps AND 10+ minute duration to avoid
-    // creating "procedures" from trivial tasks (e.g., a 2-step "investigate → fix" session).
-    const stepHistory = sessionTaskHistory.get(session.cardId);
-    const MIN_PROCEDURE_STEPS = 5;
-    const MIN_PROCEDURE_DURATION_MS = 10 * 60 * 1000; // 10 minutes
-    const hasEnoughSteps = stepHistory && stepHistory.steps.length >= MIN_PROCEDURE_STEPS;
-    const hasMinDuration = (session.sessionDurationMs ?? 0) >= MIN_PROCEDURE_DURATION_MS;
-    const isSuccessful = session.status === "completed" &&
-        (session.progressPercent === undefined || session.progressPercent >= 85) &&
-        !session.blockers?.length;
-    if (isSuccessful && hasEnoughSteps && hasMinDuration) {
-        const procedureResult = await extractOrReinforceProcedure(client, session, stepHistory.steps, workspaceId, projectId, wikiLinksLine);
-        if (procedureResult) {
-            if (procedureResult.mode === "created") {
-                learnings.push(procedureResult.learning);
-            }
-            else {
-                // Reinforced existing procedure — already saved via API, just track the ID
-                entityIds.push(procedureResult.entityId);
-            }
-        }
-    }
-    const createdPairs = [];
-    for (const learning of learnings) {
-        try {
-            const metadata = {
-                ...learning.metadata,
-            };
-            const result = await client.createMemoryEntity({
-                workspace_id: workspaceId,
-                project_id: projectId,
-                type: learning.type,
-                scope: "project",
-                memory_tier: learning.tier,
-                title: learning.title,
-                content: learning.content,
-                confidence: learning.confidence,
-                tags: learning.tags,
-                metadata,
-                agent_identifier: session.agentIdentifier,
-            });
-            const entity = result.entity;
-            if (entity?.id) {
-                entityIds.push(entity.id);
-                createdPairs.push({ id: entity.id, learning });
-            }
-        }
-        catch {
-            // Non-fatal: individual learning extraction failure shouldn't block others
-        }
-    }
-    // Auto-expand the knowledge graph and detect contradictions for each newly created entity (fire-and-forget)
-    for (const { id, learning } of createdPairs) {
-        autoExpandGraph(client, id, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => { });
-        detectContradictions(client, id, learning.type, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => { });
-        // Cross-type causal linking (e.g., new error → existing solutions)
-        linkCrossTypeNeighbors(client, id, learning.type, learning.title, learning.content, workspaceId, projectId).catch(() => { });
-    }
-    // Same-session causal linking (e.g., error + solution in same session → resolved_by)
-    if (createdPairs.length >= 2) {
-        linkSessionEntities(client, createdPairs, workspaceId, projectId).catch(() => { });
+  }
+  if (session.status === "paused" && (session.blockers?.length ?? 0) > 0) {
+    const durationInfo = session.sessionDurationMs ? `
+Duration: ${Math.round(session.sessionDurationMs / 60000)} minutes` : "";
+    learnings.push({
+      title: `Paused: ${session.cardTitle}`,
+      content: [
+        `Paused work on "${session.cardTitle}".`,
+        session.currentTask ? `Last task: ${session.currentTask}` : "",
+        session.progressPercent !== undefined ? `Progress: ${session.progressPercent}%` : "",
+        durationInfo,
+        session.blockers?.length ? `Blockers: ${session.blockers.join("; ")}` : "",
+        `
+Agent: ${session.agentName}`,
+        wikiLinksLine
+      ].filter(Boolean).join(`
+`),
+      type: "lesson",
+      tier: "draft",
+      confidence: 0.6,
+      tags: [
+        "auto-extracted",
+        "session-paused",
+        ...session.cardLabels.slice(0, 3)
+      ],
+      metadata: {
+        source: "active_learning",
+        card_id: session.cardId
+      }
+    });
+  }
+  const entityIds = [];
+  const stepHistory = sessionTaskHistory.get(session.cardId);
+  const MIN_PROCEDURE_STEPS = 5;
+  const MIN_PROCEDURE_DURATION_MS = 10 * 60 * 1000;
+  const hasEnoughSteps = stepHistory && stepHistory.steps.length >= MIN_PROCEDURE_STEPS;
+  const hasMinDuration = (session.sessionDurationMs ?? 0) >= MIN_PROCEDURE_DURATION_MS;
+  const isSuccessful = session.status === "completed" && (session.progressPercent === undefined || session.progressPercent >= 85) && !session.blockers?.length;
+  if (isSuccessful && hasEnoughSteps && hasMinDuration) {
+    const procedureResult = await extractOrReinforceProcedure(client, session, stepHistory.steps, workspaceId, projectId, wikiLinksLine);
+    if (procedureResult) {
+      if (procedureResult.mode === "created") {
+        learnings.push(procedureResult.learning);
+      } else {
+        entityIds.push(procedureResult.entityId);
+      }
     }
-    // Pattern detection DISABLED — these create noise entities like
-    // "Pattern: recurring procedure (N instances)" that are just catalogs of
-    // entity titles, eating token budget with zero actionable content.
-    // The consolidation tool (harmony_consolidate_memories) serves a similar
-    // purpose and can be improved separately with LLM synthesis.
-    // See: https://github.com/getharmony/getharmony/issues/memory-quality
-    // Clean up mid-session tracking
-    clearMidSessionTracking(session.cardId);
-    return { count: entityIds.length, entityIds };
-}
-const PATTERN_THRESHOLD = 3;
-/**
- * Detect recurring patterns across sessions.
- *
- * Uses embedding-based similarity (via hybrid search) to find related entities
- * instead of naive tag matching. When ≥3 similar entities cluster, creates or
- * updates a `pattern` entity with `part_of` relations from members.
- */
-export async function detectAndCreatePatterns(client, newEntityIds, session, workspaceId, projectId) {
-    const patternEntityIds = [];
-    for (const newEntityId of newEntityIds) {
-        try {
-            // Fetch the newly created entity to get its type, title, and content
-            const { entity: rawEntity } = await client.getMemoryEntity(newEntityId);
-            const entity = rawEntity;
-            if (!entity?.type)
-                continue;
-            // Use embedding-based search with title + content snippet as query
-            const similar = await findSimilarEntities(client, entity.title, entity.content, workspaceId, { projectId, limit: 30, minRrfScore: 0.01 });
-            // Exclude newly created entities
-            const existing = similar.filter((c) => !newEntityIds.includes(c.id) && c.type === entity.type);
-            if (existing.length < PATTERN_THRESHOLD)
-                continue;
-            // Build a descriptive pattern title from member entity titles
-            const memberTitles = [
-                entity.title,
-                ...existing.slice(0, 4).map((e) => e.title),
-            ];
-            const patternTitle = `Pattern: recurring ${entity.type} (${existing.length + 1} instances)`;
-            // Check if a pattern entity for this type already exists
-            const { entities: existingPatterns } = await client.listMemoryEntities({
-                workspace_id: workspaceId,
-                project_id: projectId,
-                type: "pattern",
-                limit: 10,
-            });
-            // Find a pattern that covers this entity type
-            const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_type === entity.type);
-            let patternId = null;
-            if (matchingPattern) {
-                patternId = matchingPattern.id;
-                await client.updateMemoryEntity(patternId, {
-                    content: `Recurring pattern: ${entity.type} entities appearing ${existing.length + 1} times.\n\nMembers:\n${memberTitles.map((t) => `- ${t}`).join("\n")}\n\nLast updated: ${new Date().toISOString()}`,
-                    metadata: {
-                        pattern_count: existing.length + 1,
-                        pattern_type: entity.type,
-                        last_updated: new Date().toISOString(),
-                    },
-                });
-            }
-            else {
-                const result = await client.createMemoryEntity({
-                    workspace_id: workspaceId,
-                    project_id: projectId,
-                    type: "pattern",
-                    scope: "project",
-                    memory_tier: "reference",
-                    title: patternTitle,
-                    content: `Recurring pattern: ${entity.type} entities detected ${existing.length + 1} times.\n\nMembers:\n${memberTitles.map((t) => `- ${t}`).join("\n")}`,
-                    confidence: 0.75,
-                    tags: ["auto-extracted", "pattern", entity.type],
-                    metadata: {
-                        source: "pattern_detection",
-                        pattern_type: entity.type,
-                        pattern_count: existing.length + 1,
-                    },
-                    agent_identifier: session.agentIdentifier,
-                });
-                const created = result.entity;
-                if (created?.id) {
-                    patternId = created.id;
-                    patternEntityIds.push(patternId);
-                }
-            }
-            if (!patternId)
-                continue;
-            // Link members → pattern using part_of relations
-            const toLink = [newEntityId, ...existing.slice(0, 4).map((e) => e.id)];
-            for (const sourceId of toLink) {
-                try {
-                    await client.createMemoryRelation({
-                        source_id: sourceId,
-                        target_id: patternId,
-                        relation_type: "part_of",
-                        confidence: 0.75,
-                    });
-                }
-                catch {
-                    // Skip duplicate/failed relations silently
-                }
-            }
-        }
-        catch {
-            // Non-fatal: pattern detection failure should not block anything
+  }
+  const createdPairs = [];
+  for (const learning of learnings) {
+    try {
+      const metadata = {
+        ...learning.metadata
+      };
+      const result = await client.createMemoryEntity({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        type: learning.type,
+        scope: "project",
+        memory_tier: learning.tier,
+        title: learning.title,
+        content: learning.content,
+        confidence: learning.confidence,
+        tags: learning.tags,
+        metadata,
+        agent_identifier: session.agentIdentifier
+      });
+      const entity = result.entity;
+      if (entity?.id) {
+        entityIds.push(entity.id);
+        createdPairs.push({ id: entity.id, learning });
+      }
+    } catch {}
+  }
+  for (const { id, learning } of createdPairs) {
+    autoExpandGraph(client, id, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => {});
+    detectContradictions(client, id, learning.type, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => {});
+    linkCrossTypeNeighbors(client, id, learning.type, learning.title, learning.content, workspaceId, projectId).catch(() => {});
+  }
+  if (createdPairs.length >= 2) {
+    linkSessionEntities(client, createdPairs, workspaceId, projectId).catch(() => {});
+  }
+  clearMidSessionTracking(session.cardId);
+  return { count: entityIds.length, entityIds };
+}
+var PATTERN_THRESHOLD = 3;
+async function detectAndCreatePatterns(client, newEntityIds, session, workspaceId, projectId) {
+  const patternEntityIds = [];
+  for (const newEntityId of newEntityIds) {
+    try {
+      const { entity: rawEntity } = await client.getMemoryEntity(newEntityId);
+      const entity = rawEntity;
+      if (!entity?.type)
+        continue;
+      const similar = await findSimilarEntities(client, entity.title, entity.content, workspaceId, { projectId, limit: 30, minRrfScore: 0.01 });
+      const existing = similar.filter((c) => !newEntityIds.includes(c.id) && c.type === entity.type);
+      if (existing.length < PATTERN_THRESHOLD)
+        continue;
+      const memberTitles = [
+        entity.title,
+        ...existing.slice(0, 4).map((e) => e.title)
+      ];
+      const patternTitle = `Pattern: recurring ${entity.type} (${existing.length + 1} instances)`;
+      const { entities: existingPatterns } = await client.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        type: "pattern",
+        limit: 10
+      });
+      const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_type === entity.type);
+      let patternId = null;
+      if (matchingPattern) {
+        patternId = matchingPattern.id;
+        await client.updateMemoryEntity(patternId, {
+          content: `Recurring pattern: ${entity.type} entities appearing ${existing.length + 1} times.
+
+Members:
+${memberTitles.map((t) => `- ${t}`).join(`
+`)}
+
+Last updated: ${new Date().toISOString()}`,
+          metadata: {
+            pattern_count: existing.length + 1,
+            pattern_type: entity.type,
+            last_updated: new Date().toISOString()
+          }
+        });
+      } else {
+        const result = await client.createMemoryEntity({
+          workspace_id: workspaceId,
+          project_id: projectId,
+          type: "pattern",
+          scope: "project",
+          memory_tier: "reference",
+          title: patternTitle,
+          content: `Recurring pattern: ${entity.type} entities detected ${existing.length + 1} times.
+
+Members:
+${memberTitles.map((t) => `- ${t}`).join(`
+`)}`,
+          confidence: 0.75,
+          tags: ["auto-extracted", "pattern", entity.type],
+          metadata: {
+            source: "pattern_detection",
+            pattern_type: entity.type,
+            pattern_count: existing.length + 1
+          },
+          agent_identifier: session.agentIdentifier
+        });
+        const created = result.entity;
+        if (created?.id) {
+          patternId = created.id;
+          patternEntityIds.push(patternId);
         }
-    }
-    return patternEntityIds;
-}
-// --- Cross-Session Causal Pattern Detection ---
-const CAUSAL_PATTERN_THRESHOLD = 3;
-/**
- * Detect recurring error→solution chains across sessions.
- *
- * When a session produces both error and solution entities, searches for
- * similar errors from other sessions that also have `resolved_by` relations.
- * If ≥3 such pairs exist, creates a `pattern` entity to capture the
- * recurring causal chain.
- */
-export async function detectCausalPatterns(client, createdPairs, session, workspaceId, projectId) {
-    const patternIds = [];
-    // Find error+solution pairs from this session
-    const errors = createdPairs.filter((p) => p.learning.type === "error");
-    const solutions = createdPairs.filter((p) => p.learning.type === "solution");
-    if (errors.length === 0 || solutions.length === 0)
-        return patternIds;
-    for (const errorPair of errors) {
+      }
+      if (!patternId)
+        continue;
+      const toLink = [newEntityId, ...existing.slice(0, 4).map((e) => e.id)];
+      for (const sourceId of toLink) {
         try {
-            // Search for similar errors from other sessions
-            const similarErrors = await findSimilarEntities(client, errorPair.learning.title, errorPair.learning.content, workspaceId, {
-                projectId,
-                limit: 20,
-                minRrfScore: 0.03,
-                excludeIds: createdPairs.map((p) => p.id),
-                type: "error",
-            });
-            // Filter to errors that have resolved_by relations
-            const resolvedErrors = [];
-            for (const similar of similarErrors.slice(0, 10)) {
-                try {
-                    const { outgoing } = await client.getRelatedEntities(similar.id);
-                    const resolvedByRel = outgoing.find((r) => r.relation_type === "resolved_by");
-                    if (resolvedByRel) {
-                        resolvedErrors.push({
-                            errorId: similar.id,
-                            errorTitle: similar.title,
-                            solutionTitle: resolvedByRel.target_title ||
-                                "unknown",
-                        });
-                    }
-                }
-                catch {
-                    // Non-fatal: skip entities where relation lookup fails
-                }
-            }
-            // Need at least CAUSAL_PATTERN_THRESHOLD similar resolved errors (including current)
-            if (resolvedErrors.length + 1 < CAUSAL_PATTERN_THRESHOLD)
-                continue;
-            // Check if a causal pattern already exists for this domain
-            const { entities: existingPatterns } = await client.listMemoryEntities({
-                workspace_id: workspaceId,
-                project_id: projectId,
-                type: "pattern",
-                limit: 10,
-            });
-            const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_chain_type === "error_resolved_by_solution");
-            if (matchingPattern) {
-                // Update existing causal pattern
-                await client.updateMemoryEntity(matchingPattern.id, {
-                    content: [
-                        `Recurring error→solution chain detected (${resolvedErrors.length + 1} instances).`,
-                        "",
-                        "## Error→Solution Pairs",
-                        `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
-                        ...resolvedErrors
-                            .slice(0, 5)
-                            .map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`),
-                        "",
-                        `Last updated: ${new Date().toISOString()}`,
-                    ].join("\n"),
-                    metadata: {
-                        pattern_chain_type: "error_resolved_by_solution",
-                        pattern_count: resolvedErrors.length + 1,
-                        last_updated: new Date().toISOString(),
-                    },
-                });
-                // Link current error+solution to the pattern
-                for (const pair of [errorPair, solutions[0]]) {
-                    try {
-                        await client.createMemoryRelation({
-                            source_id: pair.id,
-                            target_id: matchingPattern.id,
-                            relation_type: "part_of",
-                            confidence: 0.75,
-                        });
-                    }
-                    catch {
-                        // Skip duplicate relations
-                    }
-                }
-            }
-            else {
-                // Create new causal pattern
-                const result = await client.createMemoryEntity({
-                    workspace_id: workspaceId,
-                    project_id: projectId,
-                    type: "pattern",
-                    scope: "project",
-                    memory_tier: "reference",
-                    title: `Pattern: recurring error→solution chain (${resolvedErrors.length + 1} instances)`,
-                    content: [
-                        `Recurring error→solution chain detected across ${resolvedErrors.length + 1} sessions.`,
-                        "",
-                        "## Error→Solution Pairs",
-                        `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
-                        ...resolvedErrors
-                            .slice(0, 5)
-                            .map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`),
-                    ].join("\n"),
-                    confidence: 0.8,
-                    tags: ["auto-extracted", "pattern", "causal-chain"],
-                    metadata: {
-                        source: "causal_pattern_detection",
-                        pattern_chain_type: "error_resolved_by_solution",
-                        pattern_count: resolvedErrors.length + 1,
-                    },
-                    agent_identifier: session.agentIdentifier,
-                });
-                const created = result.entity;
-                if (created?.id) {
-                    patternIds.push(created.id);
-                    // Link members to the pattern
-                    const memberIds = [
-                        errorPair.id,
-                        solutions[0].id,
-                        ...resolvedErrors.slice(0, 4).map((r) => r.errorId),
-                    ];
-                    for (const memberId of memberIds) {
-                        try {
-                            await client.createMemoryRelation({
-                                source_id: memberId,
-                                target_id: created.id,
-                                relation_type: "part_of",
-                                confidence: 0.75,
-                            });
-                        }
-                        catch {
-                            // Skip duplicate relations
-                        }
-                    }
-                }
-            }
-        }
-        catch {
-            // Non-fatal: causal pattern detection failure should not block anything
-        }
-    }
-    return patternIds;
+          await client.createMemoryRelation({
+            source_id: sourceId,
+            target_id: patternId,
+            relation_type: "part_of",
+            confidence: 0.75
+          });
+        } catch {}
+      }
+    } catch {}
+  }
+  return patternEntityIds;
 }
-/**
- * Detect potential contradictions for a newly created entity using semantic search.
- *
- * Uses hybrid FTS+vector search to find same-type entities with similar content,
- * then creates `contradicts` relations. Only applies to entity types allowed by
- * the schema: decision, pattern, preference, lesson.
- *
- * Returns the list of contradicting entities found (for inclusion in tool response).
- */
-export async function detectContradictions(client, entityId, entityType, title, content, tags, workspaceId, projectId) {
-    // Only types that can participate in contradicts relations
-    if (!CONTRADICTION_TYPES.has(entityType))
-        return [];
-    // Need at least a title to search
-    if (!title.trim())
-        return [];
+var CAUSAL_PATTERN_THRESHOLD = 3;
+async function detectCausalPatterns(client, createdPairs, session, workspaceId, projectId) {
+  const patternIds = [];
+  const errors = createdPairs.filter((p) => p.learning.type === "error");
+  const solutions = createdPairs.filter((p) => p.learning.type === "solution");
+  if (errors.length === 0 || solutions.length === 0)
+    return patternIds;
+  for (const errorPair of errors) {
     try {
-        const similar = await findSimilarEntities(client, title, content, workspaceId, {
-            projectId,
-            limit: 10,
-            excludeIds: [entityId],
+      const similarErrors = await findSimilarEntities(client, errorPair.learning.title, errorPair.learning.content, workspaceId, {
+        projectId,
+        limit: 20,
+        minRrfScore: 0.03,
+        excludeIds: createdPairs.map((p) => p.id),
+        type: "error"
+      });
+      const resolvedErrors = [];
+      for (const similar of similarErrors.slice(0, 10)) {
+        try {
+          const { outgoing } = await client.getRelatedEntities(similar.id);
+          const resolvedByRel = outgoing.find((r) => r.relation_type === "resolved_by");
+          if (resolvedByRel) {
+            resolvedErrors.push({
+              errorId: similar.id,
+              errorTitle: similar.title,
+              solutionTitle: resolvedByRel.target_title || "unknown"
+            });
+          }
+        } catch {}
+      }
+      if (resolvedErrors.length + 1 < CAUSAL_PATTERN_THRESHOLD)
+        continue;
+      const { entities: existingPatterns } = await client.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        type: "pattern",
+        limit: 10
+      });
+      const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_chain_type === "error_resolved_by_solution");
+      if (matchingPattern) {
+        await client.updateMemoryEntity(matchingPattern.id, {
+          content: [
+            `Recurring error→solution chain detected (${resolvedErrors.length + 1} instances).`,
+            "",
+            "## Error→Solution Pairs",
+            `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
+            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`),
+            "",
+            `Last updated: ${new Date().toISOString()}`
+          ].join(`
+`),
+          metadata: {
+            pattern_chain_type: "error_resolved_by_solution",
+            pattern_count: resolvedErrors.length + 1,
+            last_updated: new Date().toISOString()
+          }
         });
-        // Filter to same type only (contradictions are within the same type)
-        const candidates = similar.filter((e) => e.type === entityType && CONTRADICTION_TYPES.has(e.type));
-        if (candidates.length === 0)
-            return [];
-        // Check for actual content divergence: similar topic but different stance.
-        // Entities that are very similar (high RRF) are likely supporting, not contradicting.
-        // We want entities that share topic keywords but have meaningful differences.
-        const contradictions = [];
-        for (const candidate of candidates) {
-            // Skip entities with very high similarity — they're duplicates/supporting, not contradictions
-            if ((candidate.rrf_score ?? 0) > 0.8)
-                continue;
-            // Skip entities with very low similarity — they're unrelated
-            if ((candidate.rrf_score ?? 0) < 0.02)
-                continue;
-            // Check tag overlap: need at least 1 shared tag to indicate same domain
-            const sharedTags = tags.filter((t) => candidate.tags?.includes(t));
-            if (tags.length > 0 && sharedTags.length === 0)
-                continue;
-            contradictions.push({
-                entityId: candidate.id,
-                title: candidate.title,
-                type: candidate.type,
-                tags: candidate.tags || [],
+        for (const pair of [errorPair, solutions[0]]) {
+          try {
+            await client.createMemoryRelation({
+              source_id: pair.id,
+              target_id: matchingPattern.id,
+              relation_type: "part_of",
+              confidence: 0.75
             });
+          } catch {}
         }
-        // Create contradicts relations (fire-and-forget style, but await for response)
-        for (const c of contradictions) {
+      } else {
+        const result = await client.createMemoryEntity({
+          workspace_id: workspaceId,
+          project_id: projectId,
+          type: "pattern",
+          scope: "project",
+          memory_tier: "reference",
+          title: `Pattern: recurring error→solution chain (${resolvedErrors.length + 1} instances)`,
+          content: [
+            `Recurring error→solution chain detected across ${resolvedErrors.length + 1} sessions.`,
+            "",
+            "## Error→Solution Pairs",
+            `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
+            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`)
+          ].join(`
+`),
+          confidence: 0.8,
+          tags: ["auto-extracted", "pattern", "causal-chain"],
+          metadata: {
+            source: "causal_pattern_detection",
+            pattern_chain_type: "error_resolved_by_solution",
+            pattern_count: resolvedErrors.length + 1
+          },
+          agent_identifier: session.agentIdentifier
+        });
+        const created = result.entity;
+        if (created?.id) {
+          patternIds.push(created.id);
+          const memberIds = [
+            errorPair.id,
+            solutions[0].id,
+            ...resolvedErrors.slice(0, 4).map((r) => r.errorId)
+          ];
+          for (const memberId of memberIds) {
             try {
-                await client.createMemoryRelation({
-                    source_id: entityId,
-                    target_id: c.entityId,
-                    relation_type: "contradicts",
-                    confidence: 0.5,
-                });
-            }
-            catch {
-                // Skip duplicate/failed relations silently (409 Conflict is expected)
-            }
+              await client.createMemoryRelation({
+                source_id: memberId,
+                target_id: created.id,
+                relation_type: "part_of",
+                confidence: 0.75
+              });
+            } catch {}
+          }
         }
-        return contradictions;
+      }
+    } catch {}
+  }
+  return patternIds;
+}
+async function detectContradictions(client, entityId, entityType, title, content, tags, workspaceId, projectId) {
+  if (!CONTRADICTION_TYPES.has(entityType))
+    return [];
+  if (!title.trim())
+    return [];
+  try {
+    const similar = await findSimilarEntities(client, title, content, workspaceId, {
+      projectId,
+      limit: 10,
+      excludeIds: [entityId]
+    });
+    const candidates = similar.filter((e) => e.type === entityType && CONTRADICTION_TYPES.has(e.type));
+    if (candidates.length === 0)
+      return [];
+    const contradictions = [];
+    for (const candidate of candidates) {
+      if ((candidate.rrf_score ?? 0) > 0.8)
+        continue;
+      if ((candidate.rrf_score ?? 0) < 0.02)
+        continue;
+      const sharedTags = tags.filter((t) => candidate.tags?.includes(t));
+      if (tags.length > 0 && sharedTags.length === 0)
+        continue;
+      contradictions.push({
+        entityId: candidate.id,
+        title: candidate.title,
+        type: candidate.type,
+        tags: candidate.tags || []
+      });
     }
-    catch {
-        // Non-fatal: contradiction detection should never block entity creation
-        return [];
+    for (const c of contradictions) {
+      try {
+        await client.createMemoryRelation({
+          source_id: entityId,
+          target_id: c.entityId,
+          relation_type: "contradicts",
+          confidence: 0.5
+        });
+      } catch {}
     }
+    return contradictions;
+  } catch {
+    return [];
+  }
 }
+export {
+  linkSessionEntities,
+  extractMidSessionLearnings,
+  extractLearnings,
+  detectContradictions,
+  detectCausalPatterns,
+  detectAndCreatePatterns,
+  clearMidSessionTracking
+};