@gethmy/mcp 2.3.2 → 2.3.3

package/dist/lib/active-learning.js

@@ -1,974 +0,0 @@
-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);
-    }
-    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) {}
-      }
-    }
-    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);
-    }
-  }
-  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
-        });
-      }
-      existingSteps.push(newStep);
-      sessionTaskHistory.set(ctx.cardId, {
-        lastTask: ctx.currentTask,
-        lastExtractionAt: history?.lastExtractionAt ?? 0,
-        steps: existingSteps
-      });
-    }
-  }
-  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: [] };
-}
-function clearMidSessionTracking(cardId) {
-  sessionTaskHistory.delete(cardId);
-}
-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
-    };
-  });
-}
-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(`
-`);
-  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 {
-    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 {}
-  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
-      }
-    }
-  };
-}
-var SESSION_CAUSAL_RULES = [
-  {
-    sourceType: "error",
-    targetType: "solution",
-    relation: "resolved_by",
-    confidence: 0.8
-  },
-  {
-    sourceType: "lesson",
-    targetType: "error",
-    relation: "learned_from",
-    confidence: 0.75
-  }
-];
-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 {}
-      }
-    }
-  }
-  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: `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
-          }
-        });
-      }
-    }
-  }
-  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);
-      }
-    }
-  }
-  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);
-        }
-      }
-      if (!patternId)
-        continue;
-      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 {}
-      }
-    } catch {}
-  }
-  return patternEntityIds;
-}
-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 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()
-          }
-        });
-        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 {}
-        }
-      } 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: memberId,
-                target_id: created.id,
-                relation_type: "part_of",
-                confidence: 0.75
-              });
-            } catch {}
-          }
-        }
-      }
-    } 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 || []
-      });
-    }
-    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
-};