harmony-mcp 1.9.1 → 1.9.3

package/dist/cli.js

@@ -14210,7 +14210,8 @@ function loadConfig() {
       apiUrl: DEFAULT_API_URL,
       activeWorkspaceId: null,
       activeProjectId: null,
-      userEmail: null
+      userEmail: null,
+      memoryDir: null
     };
   }
   try {
@@ -14221,7 +14222,8 @@ function loadConfig() {
       apiUrl: config.apiUrl || DEFAULT_API_URL,
       activeWorkspaceId: config.activeWorkspaceId || null,
       activeProjectId: config.activeProjectId || null,
-      userEmail: config.userEmail || null
+      userEmail: config.userEmail || null,
+      memoryDir: config.memoryDir || null
     };
   } catch {
     return {
@@ -14229,7 +14231,8 @@ function loadConfig() {
       apiUrl: DEFAULT_API_URL,
       activeWorkspaceId: null,
       activeProjectId: null,
-      userEmail: null
+      userEmail: null,
+      memoryDir: null
     };
   }
 }
@@ -14362,6 +14365,12 @@ 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");
+}
 
 // ../../node_modules/zod/v4/core/index.js
 var exports_core2 = {};
@@ -30482,6 +30491,33 @@ class HarmonyApiClient {
       params.set("limit", String(options.limit));
     return this.request("GET", `/memory/search?${params.toString()}`);
   }
+  async getVaultIndex(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.request("GET", `/memory/index?${params.toString()}`);
+  }
+  async getVaultIndexMarkdown(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.requestRaw("GET", `/memory/index?${params.toString()}`, undefined, {
+      accept: "text/markdown"
+    });
+  }
+  async resolveLinks(options) {
+    return this.request("POST", "/memory/resolve-links", options);
+  }
   async listMemoryEntitiesMarkdown(options) {
     const params = new URLSearchParams;
     params.set("workspace_id", options.workspace_id);
@@ -30549,7 +30585,559 @@ function getClient() {
   }
   return client;
 }
-
+// ../memory/src/sync-storage.ts
+function parseSyncMarkdown(markdown) {
+  const trimmed = markdown.trim();
+  let frontmatter = {
+    type: "context",
+    scope: "project",
+    tier: "reference",
+    confidence: 1,
+    tags: []
+  };
+  let body = trimmed;
+  const fmMatch = trimmed.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (fmMatch) {
+    frontmatter = parseSyncYamlFrontmatter(fmMatch[1]);
+    body = fmMatch[2].trim();
+  }
+  let title = "";
+  const titleMatch = body.match(/^#\s+(.+)/m);
+  if (titleMatch) {
+    title = titleMatch[1].trim();
+    body = body.replace(/^#\s+.+\n?/, "").trim();
+  }
+  return { frontmatter, title, content: body };
+}
+function serializeSyncMarkdown(entity) {
+  const lines = ["---"];
+  lines.push(`id: ${entity.id}`);
+  lines.push(`workspace_id: ${entity.workspace_id}`);
+  if (entity.project_id) {
+    lines.push(`project_id: ${entity.project_id}`);
+  }
+  lines.push(`type: ${entity.type}`);
+  lines.push(`scope: ${entity.scope}`);
+  lines.push(`tier: ${entity.memory_tier || "reference"}`);
+  lines.push(`confidence: ${entity.confidence}`);
+  if (entity.tags.length > 0) {
+    lines.push(`tags: [${entity.tags.join(", ")}]`);
+  } else {
+    lines.push("tags: []");
+  }
+  if (entity.agent_identifier) {
+    lines.push(`agent: ${entity.agent_identifier}`);
+  }
+  lines.push(`created_at: ${entity.created_at}`);
+  lines.push(`updated_at: ${entity.updated_at}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${entity.title}`);
+  lines.push("");
+  lines.push(entity.content);
+  return lines.join(`
+`);
+}
+function parseSyncYamlFrontmatter(yaml) {
+  const result = {
+    type: "context",
+    scope: "project",
+    tier: "reference",
+    confidence: 1,
+    tags: []
+  };
+  for (const line of yaml.split(`
+`)) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "id":
+        result.id = value;
+        break;
+      case "workspace_id":
+        result.workspace_id = value;
+        break;
+      case "project_id":
+        result.project_id = value;
+        break;
+      case "type":
+        result.type = value;
+        break;
+      case "scope":
+        result.scope = value;
+        break;
+      case "tier":
+        result.tier = value;
+        break;
+      case "confidence":
+        result.confidence = parseFloat(value) || 1;
+        break;
+      case "tags":
+        result.tags = parseYamlArray(value);
+        break;
+      case "related":
+        result.related = parseYamlArray(value);
+        break;
+      case "agent":
+        result.agent = value;
+        break;
+      case "created_at":
+        result.created_at = value;
+        break;
+      case "updated_at":
+        result.updated_at = value;
+        break;
+    }
+  }
+  return result;
+}
+function parseYamlArray(value) {
+  const match = value.match(/^\[(.*)]\s*$/);
+  if (!match)
+    return [];
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+// ../memory/src/sync.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+function computeFileHash(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function slugifyTitle(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function entityToFilename(entity) {
+  const slug = slugifyTitle(entity.title);
+  const shortId = entity.id.slice(0, 8);
+  return `${entity.type}--${slug}--${shortId}.md`;
+}
+function entityToDirectoryPath(entity, memoryDir) {
+  const wsDir = join2(memoryDir, entity.workspace_id);
+  if (entity.scope === "private") {
+    return join2(wsDir, "_private");
+  }
+  if (entity.scope === "workspace" || !entity.project_id) {
+    return join2(wsDir, "_workspace");
+  }
+  return join2(wsDir, entity.project_id);
+}
+function emptySyncState() {
+  return { version: 1, lastPullAt: null, entities: {} };
+}
+function loadSyncState(memoryDir) {
+  const statePath = join2(memoryDir, ".sync-state.json");
+  if (!existsSync2(statePath))
+    return emptySyncState();
+  try {
+    return JSON.parse(readFileSync2(statePath, "utf-8"));
+  } catch {
+    return emptySyncState();
+  }
+}
+function saveSyncState(memoryDir, state) {
+  if (!existsSync2(memoryDir)) {
+    mkdirSync2(memoryDir, { recursive: true });
+  }
+  writeFileSync2(join2(memoryDir, ".sync-state.json"), JSON.stringify(state, null, 2));
+}
+function writeEntityFile(entity, memoryDir) {
+  const dir = entityToDirectoryPath(entity, memoryDir);
+  if (!existsSync2(dir))
+    mkdirSync2(dir, { recursive: true });
+  const filename = entityToFilename(entity);
+  const filePath = join2(dir, filename);
+  const markdown = serializeSyncMarkdown(entity);
+  writeFileSync2(filePath, markdown);
+  return relative(memoryDir, filePath);
+}
+function deleteEntityFile(relPath, memoryDir) {
+  const absPath = join2(memoryDir, relPath);
+  if (existsSync2(absPath)) {
+    rmSync(absPath);
+  }
+}
+function findMarkdownFiles(dir) {
+  const results = [];
+  if (!existsSync2(dir))
+    return results;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findMarkdownFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function syncPull(client2, config2, workspaceId, projectId) {
+  const { memoryDir } = config2;
+  const state = loadSyncState(memoryDir);
+  const result = {
+    pulled: 0,
+    pushed: 0,
+    deleted: 0,
+    conflicts: 0,
+    errors: []
+  };
+  const allEntities = [];
+  let offset = 0;
+  const batchSize = 100;
+  while (true) {
+    try {
+      const resp = await client2.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: batchSize,
+        offset
+      });
+      const batch = resp.entities;
+      allEntities.push(...batch);
+      if (batch.length < batchSize)
+        break;
+      offset += batchSize;
+    } catch (err) {
+      result.errors.push(`Failed to fetch entities: ${err}`);
+      return result;
+    }
+  }
+  const remoteIds = new Set(allEntities.map((e) => e.id));
+  for (const entity of allEntities) {
+    const existing = state.entities[entity.id];
+    const markdown = serializeSyncMarkdown(entity);
+    const hash2 = computeFileHash(markdown);
+    if (!existing) {
+      const relPath = writeEntityFile(entity, memoryDir);
+      state.entities[entity.id] = {
+        filePath: relPath,
+        remoteUpdatedAt: entity.updated_at,
+        lastSyncedHash: hash2
+      };
+      result.pulled++;
+    } else {
+      const remoteChanged = entity.updated_at > existing.remoteUpdatedAt;
+      if (!remoteChanged)
+        continue;
+      const absPath = join2(memoryDir, existing.filePath);
+      let localChanged = false;
+      if (existsSync2(absPath)) {
+        const localContent = readFileSync2(absPath, "utf-8");
+        const localHash = computeFileHash(localContent);
+        localChanged = localHash !== existing.lastSyncedHash;
+      }
+      if (localChanged) {
+        result.conflicts++;
+      }
+      const newRelPath = writeEntityFile(entity, memoryDir);
+      if (existing.filePath !== newRelPath) {
+        deleteEntityFile(existing.filePath, memoryDir);
+      }
+      state.entities[entity.id] = {
+        filePath: newRelPath,
+        remoteUpdatedAt: entity.updated_at,
+        lastSyncedHash: hash2
+      };
+      result.pulled++;
+    }
+  }
+  for (const [entityId, entry] of Object.entries(state.entities)) {
+    if (!remoteIds.has(entityId)) {
+      deleteEntityFile(entry.filePath, memoryDir);
+      delete state.entities[entityId];
+      result.deleted++;
+    }
+  }
+  state.lastPullAt = new Date().toISOString();
+  saveSyncState(memoryDir, state);
+  return result;
+}
+async function syncPush(client2, config2, workspaceId) {
+  const { memoryDir } = config2;
+  const state = loadSyncState(memoryDir);
+  const result = {
+    pulled: 0,
+    pushed: 0,
+    deleted: 0,
+    conflicts: 0,
+    errors: []
+  };
+  const mdFiles = findMarkdownFiles(memoryDir);
+  for (const absPath of mdFiles) {
+    const content = readFileSync2(absPath, "utf-8");
+    const hash2 = computeFileHash(content);
+    const parsed = parseSyncMarkdown(content);
+    if (parsed.frontmatter.id) {
+      const entityId = parsed.frontmatter.id;
+      const existing = state.entities[entityId];
+      if (existing && hash2 === existing.lastSyncedHash)
+        continue;
+      try {
+        const resp = await client2.updateMemoryEntity(entityId, {
+          title: parsed.title || "Untitled",
+          content: parsed.content,
+          type: parsed.frontmatter.type,
+          scope: parsed.frontmatter.scope,
+          confidence: parsed.frontmatter.confidence,
+          tags: parsed.frontmatter.tags
+        });
+        const updated = resp.entity;
+        const newMarkdown = serializeSyncMarkdown(updated);
+        writeFileSync2(absPath, newMarkdown);
+        const relPath = relative(memoryDir, absPath);
+        state.entities[entityId] = {
+          filePath: relPath,
+          remoteUpdatedAt: updated.updated_at,
+          lastSyncedHash: computeFileHash(newMarkdown)
+        };
+        result.pushed++;
+      } catch (err) {
+        result.errors.push(`Failed to update ${entityId}: ${err}`);
+      }
+    } else {
+      const relPath = relative(memoryDir, absPath);
+      const parts = relPath.split(sep);
+      const fileWorkspaceId = parts.length >= 2 ? parts[0] : workspaceId;
+      let fileProjectId;
+      if (parts.length >= 3) {
+        const scopeDir = parts[1];
+        if (scopeDir !== "_workspace" && scopeDir !== "_private") {
+          fileProjectId = scopeDir;
+        }
+      }
+      let scope = parsed.frontmatter.scope || "project";
+      if (parts.length >= 3) {
+        const scopeDir = parts[1];
+        if (scopeDir === "_private")
+          scope = "private";
+        else if (scopeDir === "_workspace")
+          scope = "workspace";
+      }
+      try {
+        const resp = await client2.createMemoryEntity({
+          workspace_id: fileWorkspaceId,
+          project_id: fileProjectId,
+          type: parsed.frontmatter.type,
+          scope,
+          title: parsed.title || "Untitled",
+          content: parsed.content,
+          confidence: parsed.frontmatter.confidence,
+          tags: parsed.frontmatter.tags,
+          agent_identifier: parsed.frontmatter.agent
+        });
+        const created = resp.entity;
+        const dir = entityToDirectoryPath(created, memoryDir);
+        if (!existsSync2(dir))
+          mkdirSync2(dir, { recursive: true });
+        const newFilename = entityToFilename(created);
+        const newAbsPath = join2(dir, newFilename);
+        const newMarkdown = serializeSyncMarkdown(created);
+        writeFileSync2(newAbsPath, newMarkdown);
+        if (absPath !== newAbsPath && existsSync2(absPath)) {
+          rmSync(absPath);
+        }
+        const newRelPath = relative(memoryDir, newAbsPath);
+        state.entities[created.id] = {
+          filePath: newRelPath,
+          remoteUpdatedAt: created.updated_at,
+          lastSyncedHash: computeFileHash(newMarkdown)
+        };
+        result.pushed++;
+      } catch (err) {
+        result.errors.push(`Failed to create entity from ${relPath}: ${err}`);
+      }
+    }
+  }
+  saveSyncState(memoryDir, state);
+  return result;
+}
+async function syncFull(client2, config2, workspaceId, projectId) {
+  const pullResult = await syncPull(client2, config2, workspaceId, projectId);
+  const pushResult = await syncPush(client2, config2, workspaceId);
+  return {
+    pulled: pullResult.pulled,
+    pushed: pushResult.pushed,
+    deleted: pullResult.deleted,
+    conflicts: pullResult.conflicts,
+    errors: [...pullResult.errors, ...pushResult.errors]
+  };
+}
+// ../memory/src/lifecycle.ts
+var DECAY_HALF_LIVES = {
+  draft: 7,
+  episode: 30,
+  reference: 180
+};
+var PROMOTION_RULES = {
+  draftToEpisode: {
+    minAccessCount: 5,
+    minConfidence: 0.8,
+    minAgeDays: 1
+  },
+  episodeToReference: {
+    minAccessCount: 10,
+    minConfidence: 0.9,
+    minAgeDays: 7
+  }
+};
+var ARCHIVE_THRESHOLD = 0.3;
+var STALE_DAYS = 90;
+var STALE_MIN_ACCESS = 3;
+function computeDecayScore(tier, lastAccessedAt, accessCount) {
+  const halfLife = DECAY_HALF_LIVES[tier];
+  const now = Date.now();
+  let daysSinceAccess = 0;
+  if (lastAccessedAt) {
+    daysSinceAccess = (now - new Date(lastAccessedAt).getTime()) / (1000 * 60 * 60 * 24);
+  }
+  const timeDecay = Math.pow(0.5, daysSinceAccess / halfLife);
+  const accessBonus = Math.log10(accessCount + 1) * 0.1;
+  const score = Math.min(timeDecay + accessBonus, 1);
+  return { score, daysSinceAccess, halfLife, accessBonus };
+}
+function checkPromotion(currentTier, accessCount, confidence, createdAt) {
+  const ageDays = (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60 * 24);
+  const base = {
+    eligible: false,
+    targetTier: null,
+    reason: null,
+    currentTier,
+    accessCount,
+    confidence,
+    ageDays
+  };
+  if (currentTier === "draft") {
+    const rules = PROMOTION_RULES.draftToEpisode;
+    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
+      return {
+        ...base,
+        eligible: true,
+        targetTier: "episode",
+        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
+      };
+    }
+  }
+  if (currentTier === "episode") {
+    const rules = PROMOTION_RULES.episodeToReference;
+    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
+      return {
+        ...base,
+        eligible: true,
+        targetTier: "reference",
+        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
+      };
+    }
+  }
+  return base;
+}
+function evaluateLifecycle(entity) {
+  const decay = computeDecayScore(entity.memory_tier, entity.last_accessed_at, entity.access_count);
+  const promotion = checkPromotion(entity.memory_tier, entity.access_count, entity.confidence, entity.created_at);
+  const shouldArchive = entity.confidence < ARCHIVE_THRESHOLD;
+  const archiveReason = shouldArchive ? `Confidence ${entity.confidence} below threshold ${ARCHIVE_THRESHOLD}` : undefined;
+  const shouldFlagForReview = decay.daysSinceAccess >= STALE_DAYS && entity.access_count < STALE_MIN_ACCESS;
+  const reviewReason = shouldFlagForReview ? `Not accessed in ${Math.round(decay.daysSinceAccess)} days with only ${entity.access_count} accesses` : undefined;
+  return {
+    decay,
+    promotion,
+    shouldArchive,
+    shouldFlagForReview,
+    archiveReason,
+    reviewReason
+  };
+}
+// ../memory/src/graph-walk.ts
+async function discoverRelatedContext(client2, startIds, maxDepth = 2, maxEntities = 20, minConfidence = 0.5) {
+  const visited = new Set;
+  const collectedEntities = [];
+  const collectedRelations = [];
+  let truncated = false;
+  const queue = startIds.map((id) => [id, 0]);
+  for (const id of startIds) {
+    visited.add(id);
+  }
+  while (queue.length > 0) {
+    const [entityId, depth] = queue.shift();
+    if (collectedEntities.length >= maxEntities) {
+      truncated = true;
+      break;
+    }
+    if (depth > maxDepth)
+      continue;
+    try {
+      const entityResult = await client2.getMemoryEntity(entityId);
+      const entity = entityResult.entity;
+      if (entity) {
+        collectedEntities.push({
+          id: entity.id,
+          type: entity.type,
+          title: entity.title,
+          confidence: entity.confidence ?? 1,
+          memory_tier: entity.memory_tier || "reference"
+        });
+      }
+      if (depth >= maxDepth)
+        continue;
+      const related = await client2.getRelatedEntities(entityId);
+      for (const raw of related.outgoing || []) {
+        const rel = raw;
+        const relConfidence = rel.confidence ?? 1;
+        if (relConfidence < minConfidence)
+          continue;
+        const target = rel.target;
+        const targetId = target?.id ?? rel.target_id;
+        if (targetId && !visited.has(targetId)) {
+          visited.add(targetId);
+          queue.push([targetId, depth + 1]);
+          collectedRelations.push({
+            id: rel.id,
+            source_id: entityId,
+            target_id: targetId,
+            relation_type: rel.relation_type,
+            confidence: relConfidence
+          });
+        }
+      }
+      for (const raw of related.incoming || []) {
+        const rel = raw;
+        const relConfidence = rel.confidence ?? 1;
+        if (relConfidence < minConfidence)
+          continue;
+        const source = rel.source;
+        const sourceId = source?.id ?? rel.source_id;
+        if (sourceId && !visited.has(sourceId)) {
+          visited.add(sourceId);
+          queue.push([sourceId, depth + 1]);
+          collectedRelations.push({
+            id: rel.id,
+            source_id: sourceId,
+            target_id: entityId,
+            relation_type: rel.relation_type,
+            confidence: relConfidence
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return {
+    entities: collectedEntities,
+    relations: collectedRelations,
+    depth: maxDepth,
+    truncated
+  };
+}
 // src/prompt-builder.ts
 var LABEL_CATEGORY_MAP = {
   bug: "bug",
@@ -30767,7 +31355,7 @@ ${lines.join(`
 `)}`;
 }
 function generatePrompt(options) {
-  const { card, column, variant, customConstraints, memories } = options;
+  const { card, column, variant, customConstraints, memories, assembledContext, assemblyId } = options;
   const contextOpts = {
     includeTitle: true,
     includeDescription: true,
@@ -30830,7 +31418,10 @@ ${card.description}`);
   roleFraming.outputSuggestions.forEach((s) => {
     sections.push(`- ${s}`);
   });
-  if (memories && memories.length > 0) {
+  if (assembledContext) {
+    sections.push(`
+${assembledContext}`);
+  } else if (memories && memories.length > 0) {
     sections.push(`
 ## Relevant Memories`);
     sections.push(`*${memories.length} memories recalled from knowledge graph:*`);
@@ -30851,6 +31442,7 @@ ${customConstraints}`);
 *Card #${card.short_id} | Generated for ${variant} mode*`);
   const prompt = sections.join(`
 `);
+  const memoryCount = assembledContext ? (assembledContext.match(/^### /gm) || []).length : memories?.length || 0;
   return {
     prompt,
     variant,
@@ -30862,11 +31454,453 @@ ${customConstraints}`);
       subtaskCount: subtasks.length,
       completedSubtasks: subtasks.filter((s) => s.completed).length,
       linkedCardCount: links.length,
-      memoryCount: memories?.length || 0
+      memoryCount
     },
-    tokenEstimate: estimateTokens(prompt)
+    tokenEstimate: estimateTokens(prompt),
+    ...assemblyId && { assemblyId }
+  };
+}
+
+// src/context-assembly.ts
+var DEFAULT_TOKEN_BUDGET = 4000;
+var MAX_TOKENS_PER_ENTITY = 500;
+var MIN_RELEVANCE_THRESHOLD = 0.1;
+var TIER_WEIGHTS = {
+  reference: 1,
+  episode: 0.7,
+  draft: 0.4
+};
+var TIER_BUDGET_ALLOCATION = {
+  reference: 0.6,
+  episode: 0.3,
+  draft: 0.1
+};
+var MIN_REFERENCE_SLOTS = 3;
+function estimateTokens2(text) {
+  return Math.ceil(text.length / 4);
+}
+function generateAssemblyId() {
+  return `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function truncateContent(content, maxTokens) {
+  const currentTokens = estimateTokens2(content);
+  if (currentTokens <= maxTokens) {
+    return { text: content, truncated: false };
+  }
+  const paragraphs = content.split(/\n\n+/);
+  let result = paragraphs[0];
+  for (let i = 1;i < paragraphs.length; i++) {
+    const lines = paragraphs[i].split(`
+`).filter((l) => l.startsWith("- ") || l.startsWith("* "));
+    if (lines.length > 0) {
+      const bulletSection = lines.join(`
+`);
+      if (estimateTokens2(result + `
+
+` + bulletSection) <= maxTokens) {
+        result += `
+
+` + bulletSection;
+      }
+    }
+  }
+  if (estimateTokens2(result) > maxTokens) {
+    const maxChars = maxTokens * 4;
+    result = result.slice(0, maxChars - 3) + "...";
+  }
+  return { text: result, truncated: true };
+}
+function computeRelevanceScore(entity, taskContext, cardLabels) {
+  const reasons = [];
+  let score = 0;
+  const taskWords = new Set(taskContext.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+  const entityWords = new Set(`${entity.title} ${entity.content}`.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+  const overlap = [...taskWords].filter((w) => entityWords.has(w));
+  if (overlap.length > 0) {
+    const textScore = Math.min(overlap.length / Math.max(taskWords.size, 1), 1) * 0.4;
+    score += textScore;
+    reasons.push(`text_match(${overlap.length} words)`);
+  }
+  if (cardLabels.length > 0 && entity.tags.length > 0) {
+    const labelSet = new Set(cardLabels.map((l) => l.toLowerCase()));
+    const tagOverlap = entity.tags.filter((t) => labelSet.has(t.toLowerCase()));
+    if (tagOverlap.length > 0) {
+      const tagScore = tagOverlap.length / cardLabels.length * 0.3;
+      score += tagScore;
+      reasons.push(`tag_match(${tagOverlap.join(",")})`);
+    }
+  }
+  score += entity.confidence * 0.15;
+  if (entity.confidence >= 0.9) {
+    reasons.push("high_confidence");
+  }
+  if (entity.last_accessed_at) {
+    const daysSinceAccess = (Date.now() - new Date(entity.last_accessed_at).getTime()) / (1000 * 60 * 60 * 24);
+    const halfLife = { draft: 7, episode: 30, reference: 180 }[entity.memory_tier];
+    const recencyScore = Math.pow(0.5, daysSinceAccess / halfLife) * 0.1;
+    score += recencyScore;
+    if (daysSinceAccess < 7)
+      reasons.push("recently_accessed");
+  }
+  if (entity.access_count > 0) {
+    const freqScore = Math.log10(entity.access_count + 1) * 0.05;
+    score += Math.min(freqScore, 0.1);
+    if (entity.access_count >= 5)
+      reasons.push(`frequently_used(${entity.access_count})`);
+  }
+  const tierWeight = TIER_WEIGHTS[entity.memory_tier];
+  score *= tierWeight;
+  return { score, reasons };
+}
+async function assembleContext(options) {
+  const {
+    workspaceId,
+    projectId,
+    taskContext,
+    cardLabels = [],
+    tokenBudget = DEFAULT_TOKEN_BUDGET,
+    client: client3
+  } = options;
+  const assemblyId = generateAssemblyId();
+  const manifest = {
+    assemblyId,
+    timestamp: new Date().toISOString(),
+    included: [],
+    excluded: [],
+    budgetUsed: 0,
+    budgetTotal: tokenBudget,
+    tierBreakdown: {
+      draft: { count: 0, tokens: 0 },
+      episode: { count: 0, tokens: 0 },
+      reference: { count: 0, tokens: 0 }
+    }
+  };
+  let candidates = [];
+  try {
+    const searchResult = await client3.searchMemoryEntities(workspaceId, taskContext, { project_id: projectId, limit: 30 });
+    if (searchResult.entities?.length > 0) {
+      candidates = searchResult.entities.map(mapToContextEntity);
+    }
+  } catch {}
+  if (candidates.length < 10 && projectId) {
+    try {
+      const listResult = await client3.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: 30
+      });
+      if (listResult.entities?.length > 0) {
+        const existingIds = new Set(candidates.map((c) => c.id));
+        const additional = listResult.entities.map(mapToContextEntity).filter((e) => !existingIds.has(e.id));
+        candidates.push(...additional);
+      }
+    } catch {}
+  }
+  if (candidates.length === 0) {
+    return {
+      context: "",
+      manifest,
+      memories: []
+    };
+  }
+  const scored = candidates.map((entity) => {
+    const { score, reasons } = computeRelevanceScore(entity, taskContext, cardLabels);
+    return { entity, score, reasons };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const tierBudgets = {
+    reference: Math.floor(tokenBudget * TIER_BUDGET_ALLOCATION.reference),
+    episode: Math.floor(tokenBudget * TIER_BUDGET_ALLOCATION.episode),
+    draft: Math.floor(tokenBudget * TIER_BUDGET_ALLOCATION.draft)
+  };
+  const tierUsed = { reference: 0, episode: 0, draft: 0 };
+  const included = [];
+  let totalUsed = 0;
+  let referenceCount = 0;
+  for (const item of scored) {
+    if (item.entity.memory_tier === "reference" && referenceCount < MIN_REFERENCE_SLOTS) {
+      const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
+      const tokens = estimateTokens2(`### ${item.entity.title}
+${text}`);
+      if (totalUsed + tokens <= tokenBudget) {
+        included.push({ ...item, tokens, truncated });
+        item.entity.content = text;
+        totalUsed += tokens;
+        tierUsed.reference += tokens;
+        referenceCount++;
+      }
+    }
+  }
+  const includedIds = new Set(included.map((i) => i.entity.id));
+  for (const item of scored) {
+    if (includedIds.has(item.entity.id))
+      continue;
+    if (item.score < MIN_RELEVANCE_THRESHOLD) {
+      manifest.excluded.push({
+        entityId: item.entity.id,
+        title: item.entity.title,
+        type: item.entity.type,
+        tier: item.entity.memory_tier,
+        relevanceScore: item.score,
+        reason: "below_relevance_threshold"
+      });
+      continue;
+    }
+    const tier = item.entity.memory_tier;
+    const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
+    const tokens = estimateTokens2(`### ${item.entity.title}
+${text}`);
+    if (tierUsed[tier] + tokens > tierBudgets[tier]) {
+      const totalRemaining = tokenBudget - totalUsed;
+      if (tokens > totalRemaining) {
+        manifest.excluded.push({
+          entityId: item.entity.id,
+          title: item.entity.title,
+          type: item.entity.type,
+          tier,
+          relevanceScore: item.score,
+          reason: "budget_exceeded"
+        });
+        continue;
+      }
+    }
+    if (totalUsed + tokens > tokenBudget) {
+      manifest.excluded.push({
+        entityId: item.entity.id,
+        title: item.entity.title,
+        type: item.entity.type,
+        tier,
+        relevanceScore: item.score,
+        reason: "total_budget_exceeded"
+      });
+      continue;
+    }
+    included.push({ ...item, tokens, truncated });
+    item.entity.content = text;
+    totalUsed += tokens;
+    tierUsed[tier] += tokens;
+    includedIds.add(item.entity.id);
+  }
+  manifest.budgetUsed = totalUsed;
+  manifest.tierBreakdown = {
+    reference: { count: included.filter((i) => i.entity.memory_tier === "reference").length, tokens: tierUsed.reference },
+    episode: { count: included.filter((i) => i.entity.memory_tier === "episode").length, tokens: tierUsed.episode },
+    draft: { count: included.filter((i) => i.entity.memory_tier === "draft").length, tokens: tierUsed.draft }
+  };
+  for (const item of included) {
+    manifest.included.push({
+      entityId: item.entity.id,
+      title: item.entity.title,
+      type: item.entity.type,
+      tier: item.entity.memory_tier,
+      relevanceScore: item.score,
+      reasons: item.reasons,
+      tokenCount: item.tokens,
+      truncated: item.truncated
+    });
+  }
+  const contextSections = [];
+  if (included.length > 0) {
+    contextSections.push(`## Relevant Memories (${included.length} loaded, ${manifest.excluded.length} excluded)`);
+    contextSections.push(`*Assembly: ${assemblyId} | Budget: ${totalUsed}/${tokenBudget} tokens*`);
+    for (const item of included) {
+      const tags = item.entity.tags.length > 0 ? ` [${item.entity.tags.join(", ")}]` : "";
+      const tierLabel = item.entity.memory_tier !== "reference" ? ` (${item.entity.memory_tier})` : "";
+      contextSections.push(`
+### ${item.entity.title} (${item.entity.type}, confidence: ${item.entity.confidence})${tierLabel}${tags}`);
+      contextSections.push(item.entity.content);
+    }
+  }
+  incrementAccessCounts(client3, included.map((i) => i.entity.id)).catch(() => {});
+  return {
+    context: contextSections.join(`
+`),
+    manifest,
+    memories: included.map((i) => i.entity)
   };
 }
+function mapToContextEntity(raw) {
+  const e = raw;
+  return {
+    id: e.id,
+    type: e.type,
+    title: e.title,
+    content: e.content,
+    confidence: e.confidence ?? 1,
+    tags: e.tags || [],
+    memory_tier: e.memory_tier || "reference",
+    access_count: e.access_count || 0,
+    last_accessed_at: e.last_accessed_at || null,
+    updated_at: e.updated_at || ""
+  };
+}
+async function incrementAccessCounts(client3, entityIds) {
+  for (const id of entityIds) {
+    try {
+      await client3.updateMemoryEntity(id, {
+        metadata: {
+          _last_context_load: new Date().toISOString()
+        }
+      });
+    } catch {}
+  }
+}
+var manifestCache = new Map;
+var MAX_CACHE_SIZE = 50;
+function cacheManifest(manifest) {
+  if (manifestCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = manifestCache.keys().next().value;
+    if (firstKey)
+      manifestCache.delete(firstKey);
+  }
+  manifestCache.set(manifest.assemblyId, manifest);
+}
+function getCachedManifest(assemblyId) {
+  return manifestCache.get(assemblyId);
+}
+
+// src/active-learning.ts
+async function extractLearnings(client3, session) {
+  const workspaceId = getActiveWorkspaceId();
+  if (!workspaceId) {
+    return { count: 0, entityIds: [] };
+  }
+  const projectId = getActiveProjectId() || undefined;
+  const learnings = [];
+  if (session.blockers && session.blockers.length > 0) {
+    for (const blocker of session.blockers) {
+      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: "reference",
+        confidence: 0.7,
+        tags: ["auto-extracted", "blocker", ...session.cardLabels.slice(0, 3)],
+        metadata: {
+          source: "active_learning",
+          card_id: session.cardId,
+          review_status: "pending"
+        }
+      });
+    }
+  }
+  if (session.status === "completed") {
+    const durationInfo = session.sessionDurationMs ? `
+Duration: ${Math.round(session.sessionDurationMs / 60000)} minutes` : "";
+    learnings.push({
+      title: `Session: ${session.cardTitle}`,
+      content: [
+        `Completed work on "${session.cardTitle}".`,
+        session.currentTask ? `Final task: ${session.currentTask}` : "",
+        session.progressPercent !== undefined ? `Progress: ${session.progressPercent}%` : "",
+        durationInfo,
+        session.blockers?.length ? `Blockers encountered: ${session.blockers.join("; ")}` : "",
+        `
+Agent: ${session.agentName}`
+      ].filter(Boolean).join(`
+`),
+      type: "lesson",
+      tier: "episode",
+      confidence: 0.7,
+      tags: ["auto-extracted", "session-summary", ...session.cardLabels.slice(0, 3)],
+      metadata: {
+        source: "active_learning",
+        card_id: session.cardId,
+        review_status: session.blockers?.length ? "pending" : undefined
+      }
+    });
+  }
+  const hasBugLabel = session.cardLabels.some((l) => ["bug", "fix", "hotfix", "defect", "error"].includes(l.toLowerCase()));
+  if (hasBugLabel && session.status === "completed") {
+    learnings.push({
+      title: `Solution: ${session.cardTitle}`,
+      content: [
+        `Resolved bug: "${session.cardTitle}"`,
+        session.currentTask ? `
+Approach: ${session.currentTask}` : "",
+        `
+Agent: ${session.agentName}`
+      ].filter(Boolean).join(`
+`),
+      type: "solution",
+      tier: "reference",
+      confidence: 0.8,
+      tags: ["auto-extracted", "bug-fix", ...session.cardLabels.slice(0, 3)],
+      metadata: {
+        source: "active_learning",
+        card_id: session.cardId,
+        auto_confidence: true
+      }
+    });
+  }
+  const entityIds = [];
+  for (const learning of learnings) {
+    try {
+      const shouldAutoStore = learning.confidence >= 0.85;
+      const metadata = {
+        ...learning.metadata,
+        ...shouldAutoStore ? {} : { review_status: "pending" }
+      };
+      const result = await client3.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);
+      }
+    } catch {}
+  }
+  return { count: entityIds.length, entityIds };
+}
+async function listPendingLearnings(client3, workspaceId, projectId) {
+  try {
+    const result = await client3.listMemoryEntities({
+      workspace_id: workspaceId,
+      project_id: projectId,
+      limit: 50
+    });
+    return (result.entities || []).filter((e) => {
+      const entity = e;
+      return entity.metadata?.review_status === "pending";
+    });
+  } catch {
+    return [];
+  }
+}
+async function approveLearning(client3, entityId, newConfidence) {
+  await client3.updateMemoryEntity(entityId, {
+    confidence: newConfidence ?? 1,
+    metadata: {
+      review_status: "approved",
+      reviewed_at: new Date().toISOString()
+    }
+  });
+}
+async function rejectLearning(client3, entityId) {
+  await client3.updateMemoryEntity(entityId, {
+    confidence: 0,
+    metadata: {
+      review_status: "rejected",
+      reviewed_at: new Date().toISOString(),
+      archived: true
+    }
+  });
+}
 
 // src/server.ts
 var TOOLS = {
@@ -31413,6 +32447,11 @@ var TOOLS = {
           enum: ["private", "project", "workspace", "global"],
           description: "Visibility scope (default: project). Private = only creator can see."
         },
+        tier: {
+          type: "string",
+          enum: ["draft", "episode", "reference"],
+          description: "Memory tier: draft (working notes), episode (session summaries), reference (durable knowledge). Auto-inferred from type if not set."
+        },
         tags: {
           type: "array",
           items: { type: "string" },
@@ -31558,7 +32597,7 @@ var TOOLS = {
     }
   },
   harmony_relate: {
-    description: "Create a typed relationship between two memory entities. Relation types: learned_from, resolved_by, contradicts, supports, depends_on, part_of, caused_by.",
+    description: "Create a typed relationship between two memory entities. Relation types: learned_from, resolved_by, contradicts, supports, depends_on, part_of, caused_by, relates_to.",
     inputSchema: {
       type: "object",
       properties: {
@@ -31579,7 +32618,8 @@ var TOOLS = {
             "supports",
             "depends_on",
             "part_of",
-            "caused_by"
+            "caused_by",
+            "relates_to"
           ],
           description: "Type of relationship between entities"
         },
@@ -31632,28 +32672,107 @@ var TOOLS = {
       required: ["query"]
     }
   },
-  harmony_create_plan: {
-    description: "Create a new project plan. Use this to upload implementation plans created during planning. Returns a URL where the plan can be viewed and edited in Harmony.",
+  harmony_vault_index: {
+    description: "Get a compact index of all memory entities in the vault. Returns a markdown table with title, type, scope, confidence, tags, summary, and last updated date. Use this for quick overview of stored knowledge.",
     inputSchema: {
       type: "object",
       properties: {
-        projectId: {
+        workspaceId: {
           type: "string",
-          description: "Project ID (optional if context set)"
+          description: "Workspace ID (optional if context set)"
         },
-        title: { type: "string", description: "Plan title" },
-        content: {
+        projectId: {
           type: "string",
-          description: "Plan content in Markdown format"
+          description: "Project ID (optional, filters to project scope)"
         },
-        source: {
+        type: {
           type: "string",
-          enum: ["user", "agent", "imported"],
-          description: "Plan source: agent for AI-generated plans (default: agent)"
+          enum: [
+            "agent",
+            "task",
+            "decision",
+            "context",
+            "pattern",
+            "error",
+            "solution",
+            "preference",
+            "relationship",
+            "commitment",
+            "lesson",
+            "project",
+            "handoff"
+          ],
+          description: "Filter by entity type"
         },
-        tasks: {
-          type: "array",
-          items: {
+        limit: {
+          type: "number",
+          description: "Max entities to return (default: 200)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_resolve_links: {
+    description: "Batch-scan all memory entities in a workspace/project for [[wiki-links]] and auto-create 'relates_to' relations. Use this to retroactively link existing entities.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional, limits scan to project)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_sync: {
+    description: "Synchronize local markdown memory files with the shared database. Pull downloads remote entities as .md files, push uploads local changes, full does both (pull first, then push). Server wins on conflicts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        direction: {
+          type: "string",
+          enum: ["pull", "push", "full"],
+          description: "Sync direction: pull (remote->local), push (local->remote), full (pull then push). Default: full"
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional, limits pull scope)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_create_plan: {
+    description: "Create a new project plan. Use this to upload implementation plans created during planning. Returns a URL where the plan can be viewed and edited in Harmony.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Project ID (optional if context set)"
+        },
+        title: { type: "string", description: "Plan title" },
+        content: {
+          type: "string",
+          description: "Plan content in Markdown format"
+        },
+        source: {
+          type: "string",
+          enum: ["user", "agent", "imported"],
+          description: "Plan source: agent for AI-generated plans (default: agent)"
+        },
+        tasks: {
+          type: "array",
+          items: {
             type: "object",
             properties: {
               content: { type: "string", description: "Task description" },
@@ -31709,6 +32828,148 @@ var TOOLS = {
       },
       required: ["planId"]
     }
+  },
+  harmony_review_learnings: {
+    description: "List pending auto-extracted memories awaiting human review. These are memories automatically created from agent work sessions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_approve_learning: {
+    description: "Approve or reject a pending auto-extracted memory. Approved memories get confidence boosted to 1.0. Rejected memories are archived.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        entityId: {
+          type: "string",
+          description: "Memory entity ID to approve or reject"
+        },
+        action: {
+          type: "string",
+          enum: ["approve", "reject"],
+          description: "Whether to approve or reject the learning"
+        },
+        confidence: {
+          type: "number",
+          description: "Override confidence for approved memories (default: 1.0)"
+        }
+      },
+      required: ["entityId", "action"]
+    }
+  },
+  harmony_prune_draft: {
+    description: "Remove stale draft memories that haven't been accessed recently. Runs in dry-run mode by default to preview what would be pruned.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        },
+        dryRun: {
+          type: "boolean",
+          description: "Preview what would be pruned without deleting (default: true)"
+        },
+        maxAgeDays: {
+          type: "number",
+          description: "Maximum age in days for draft memories to keep (default: 30)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_get_context_manifest: {
+    description: "Retrieve the context assembly manifest for a given assembly ID to debug what memories were loaded or excluded and why.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assemblyId: {
+          type: "string",
+          description: "Assembly ID from a previous harmony_generate_prompt call"
+        }
+      },
+      required: ["assemblyId"]
+    }
+  },
+  harmony_debug_context: {
+    description: "Explain why a specific memory was or wasn't included in context assembly for a given task. Returns relevance score breakdown.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        entityId: {
+          type: "string",
+          description: "Memory entity ID to analyze"
+        },
+        taskContext: {
+          type: "string",
+          description: "Task context (card title + description) to score against"
+        },
+        cardLabels: {
+          type: "array",
+          items: { type: "string" },
+          description: "Card labels for tag matching"
+        }
+      },
+      required: ["entityId", "taskContext"]
+    }
+  },
+  harmony_export_memory_graph: {
+    description: "Export the knowledge graph as DOT format for Graphviz visualization. Nodes are colored by tier (draft=yellow, episode=blue, reference=green).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        },
+        limit: {
+          type: "number",
+          description: "Max entities to include (default: 50)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_promote_memory: {
+    description: "Promote a memory entity to a higher tier: draft→episode or episode→reference. Tracks promotion reason and source.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        entityId: {
+          type: "string",
+          description: "Memory entity ID to promote"
+        },
+        targetTier: {
+          type: "string",
+          enum: ["episode", "reference"],
+          description: "Target tier to promote to"
+        },
+        reason: {
+          type: "string",
+          description: "Reason for promotion (e.g., 'proven useful across 5+ sessions')"
+        }
+      },
+      required: ["entityId", "targetTier", "reason"]
+    }
   }
 };
 var RESOURCES = [
@@ -31783,7 +33044,7 @@ class HarmonyMCPServer {
       throw new Error(`Not configured. Run "harmony-mcp configure" to set your API key.
 ` + "You can generate an API key at https://gethmy.com → Settings → API Keys.");
     }
-    const client2 = getClient();
+    const client3 = getClient();
     const getProjectId = () => {
       const id = args.projectId || getActiveProjectId();
       if (!id) {
@@ -31802,7 +33063,7 @@ class HarmonyMCPServer {
       case "harmony_create_card": {
         const title = exports_external.string().min(1).parse(args.title);
         const projectId = args.projectId || getProjectId();
-        const result = await client2.createCard(projectId, {
+        const result = await client3.createCard(projectId, {
           title,
           columnId: args.columnId,
           description: args.description,
@@ -31813,7 +33074,7 @@ class HarmonyMCPServer {
       }
       case "harmony_update_card": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
-        const result = await client2.updateCard(cardId, {
+        const result = await client3.updateCard(cardId, {
           title: args.title,
           description: args.description,
           priority: args.priority,
@@ -31825,114 +33086,139 @@ class HarmonyMCPServer {
       case "harmony_move_card": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
         const columnId = exports_external.string().uuid().parse(args.columnId);
-        const result = await client2.moveCard(cardId, columnId, args.position);
-        return { success: true, ...result };
+        const result = await client3.moveCard(cardId, columnId, args.position);
+        let sessionEnded = false;
+        try {
+          const { card } = result;
+          if (card?.project_id) {
+            const board = await client3.getBoard(card.project_id, {
+              summary: true
+            });
+            const columns = board.columns;
+            const destCol = columns.find((c) => c.id === columnId);
+            const colName = destCol?.name?.toLowerCase() || "";
+            const isTerminal2 = destCol?.mark_cards_done || colName === "done" || colName === "completed" || colName === "review";
+            if (isTerminal2) {
+              const { session } = await client3.getAgentSession(cardId);
+              if (session) {
+                await client3.endAgentSession(cardId, { status: "completed" });
+                sessionEnded = true;
+              }
+            }
+          }
+        } catch {}
+        return { success: true, sessionEnded, ...result };
       }
       case "harmony_delete_card": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
-        await client2.deleteCard(cardId);
+        await client3.deleteCard(cardId);
         return { success: true };
       }
       case "harmony_assign_card": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
         const assigneeId = args.assigneeId ? exports_external.string().uuid().parse(args.assigneeId) : null;
-        const result = await client2.updateCard(cardId, { assigneeId });
+        const result = await client3.updateCard(cardId, { assigneeId });
         return { success: true, ...result };
       }
       case "harmony_search_cards": {
         const query = exports_external.string().min(1).parse(args.query);
-        const result = await client2.searchCards(query, {
+        const result = await client3.searchCards(query, {
           projectId: args.projectId
         });
         return { success: true, ...result, count: result.cards.length };
       }
       case "harmony_get_card": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
-        const result = await client2.getCard(cardId);
+        const result = await client3.getCard(cardId);
         return { success: true, ...result };
       }
       case "harmony_get_card_by_short_id": {
         const shortId = exports_external.number().int().positive().parse(args.shortId);
         const projectId = args.projectId || getProjectId();
-        const result = await client2.getCardByShortId(projectId, shortId);
+        const result = await client3.getCardByShortId(projectId, shortId);
         return { success: true, ...result };
       }
       case "harmony_create_column": {
         const name2 = exports_external.string().min(1).parse(args.name);
         const projectId = args.projectId || getProjectId();
-        const result = await client2.createColumn(projectId, name2);
+        const result = await client3.createColumn(projectId, name2);
         return { success: true, ...result };
       }
       case "harmony_update_column": {
         const columnId = exports_external.string().uuid().parse(args.columnId);
         const name2 = exports_external.string().min(1).parse(args.name);
-        const result = await client2.updateColumn(columnId, name2);
+        const result = await client3.updateColumn(columnId, name2);
         return { success: true, ...result };
       }
       case "harmony_delete_column": {
         const columnId = exports_external.string().uuid().parse(args.columnId);
-        await client2.deleteColumn(columnId);
+        await client3.deleteColumn(columnId);
         return { success: true };
       }
       case "harmony_create_label": {
         const name2 = exports_external.string().min(1).parse(args.name);
         const color = exports_external.string().regex(/^#[0-9a-fA-F]{6}$/).parse(args.color);
         const projectId = args.projectId || getProjectId();
-        const result = await client2.createLabel(projectId, { name: name2, color });
+        const board = await client3.getBoard(projectId, { summary: true });
+        const existing = board.labels.find((l) => l.name.toLowerCase() === name2.toLowerCase());
+        if (existing) {
+          return { success: true, ...existing, deduplicated: true };
+        }
+        const result = await client3.createLabel(projectId, { name: name2, color });
         return { success: true, ...result };
       }
       case "harmony_add_label_to_card": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
         const labelId = exports_external.string().uuid().parse(args.labelId);
-        await client2.addLabelToCard(cardId, labelId);
+        await client3.addLabelToCard(cardId, labelId);
         return { success: true };
       }
       case "harmony_remove_label_from_card": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
         const labelId = exports_external.string().uuid().parse(args.labelId);
-        await client2.removeLabelFromCard(cardId, labelId);
+        await client3.removeLabelFromCard(cardId, labelId);
         return { success: true };
       }
       case "harmony_add_link_to_card": {
         const sourceCardId = exports_external.string().uuid().parse(args.sourceCardId);
         const targetCardId = exports_external.string().uuid().parse(args.targetCardId);
         const linkType = exports_external.enum(["relates_to", "blocks", "duplicates", "is_part_of"]).parse(args.linkType);
-        const result = await client2.addLinkToCard(sourceCardId, targetCardId, linkType);
+        const result = await client3.addLinkToCard(sourceCardId, targetCardId, linkType);
         return { success: true, ...result };
       }
       case "harmony_remove_link_from_card": {
         const linkId = exports_external.string().uuid().parse(args.linkId);
-        await client2.removeLinkFromCard(linkId);
+        await client3.removeLinkFromCard(linkId);
         return { success: true };
       }
       case "harmony_get_card_links": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
-        const result = await client2.getCardLinks(cardId);
+        const result = await client3.getCardLinks(cardId);
         return result;
       }
       case "harmony_create_subtask": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
         const title = exports_external.string().min(1).parse(args.title);
-        const result = await client2.createSubtask(cardId, title);
+        const result = await client3.createSubtask(cardId, title);
         return { success: true, ...result };
       }
       case "harmony_toggle_subtask": {
         const subtaskId = exports_external.string().uuid().parse(args.subtaskId);
-        const result = await client2.toggleSubtask(subtaskId);
+        const result = await client3.toggleSubtask(subtaskId);
         return { success: true, ...result };
       }
       case "harmony_delete_subtask": {
         const subtaskId = exports_external.string().uuid().parse(args.subtaskId);
-        await client2.deleteSubtask(subtaskId);
+        await client3.deleteSubtask(subtaskId);
         return { success: true };
       }
       case "harmony_list_workspaces": {
-        const result = await client2.listWorkspaces();
+        const result = await client3.listWorkspaces();
         return { success: true, ...result };
       }
       case "harmony_list_projects": {
         const workspaceId = getWorkspaceId();
-        const result = await client2.listProjects(workspaceId);
+        const result = await client3.listProjects(workspaceId);
         return { success: true, ...result };
       }
       case "harmony_get_board": {
@@ -31946,12 +33232,12 @@ class HarmonyMCPServer {
           options.columnId = String(args.columnId);
         if (args.summary === true || args.summary === "true")
           options.summary = true;
-        const result = await client2.getBoard(projectId, options);
+        const result = await client3.getBoard(projectId, options);
         return { success: true, board: result };
       }
       case "harmony_get_workspace_members": {
         const workspaceId = getWorkspaceId();
-        const result = await client2.getWorkspaceMembers(workspaceId);
+        const result = await client3.getWorkspaceMembers(workspaceId);
         return { success: true, ...result };
       }
       case "harmony_set_workspace_context": {
@@ -31975,7 +33261,7 @@ class HarmonyMCPServer {
       }
       case "harmony_process_command": {
         const command = exports_external.string().min(1).parse(args.command);
-        const result = await client2.processNLU({
+        const result = await client3.processNLU({
           command,
           projectId: args.projectId || getActiveProjectId() || undefined,
           workspaceId: args.workspaceId || getActiveWorkspaceId() || undefined,
@@ -31994,10 +33280,10 @@ class HarmonyMCPServer {
         const labelsAdded = [];
         if (moveToColumn || addLabels?.length) {
           try {
-            const { card } = await client2.getCard(cardId);
+            const { card } = await client3.getCard(cardId);
             const projectId = card.project_id;
             if (projectId) {
-              const board = await client2.getBoard(projectId, {
+              const board = await client3.getBoard(projectId, {
                 summary: true
               });
               const columns = board.columns;
@@ -32005,7 +33291,7 @@ class HarmonyMCPServer {
               if (moveToColumn) {
                 const col = columns.find((c) => c.name.toLowerCase().includes(moveToColumn.toLowerCase()));
                 if (col) {
-                  await client2.moveCard(cardId, col.id);
+                  await client3.moveCard(cardId, col.id);
                   movedTo = col.name;
                 }
               }
@@ -32013,7 +33299,7 @@ class HarmonyMCPServer {
                 for (const labelName of addLabels) {
                   const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
                   if (label) {
-                    await client2.addLabelToCard(cardId, label.id);
+                    await client3.addLabelToCard(cardId, label.id);
                     labelsAdded.push(label.name);
                   }
                 }
@@ -32027,27 +33313,56 @@ class HarmonyMCPServer {
           try {
             const workspaceId = getActiveWorkspaceId();
             if (workspaceId) {
-              const { members } = await client2.getWorkspaceMembers(workspaceId);
+              const { members } = await client3.getWorkspaceMembers(workspaceId);
               const user = members.find((m) => m.email === userEmail);
               if (user) {
-                await client2.updateCard(cardId, { assigneeId: user.id });
+                await client3.updateCard(cardId, { assigneeId: user.id });
                 assignedTo = user.email;
               }
             }
           } catch {}
         }
-        const result = await client2.startAgentSession(cardId, {
+        const result = await client3.startAgentSession(cardId, {
           agentIdentifier,
           agentName,
           status: "working",
           currentTask: args.currentTask,
           estimatedMinutesRemaining: args.estimatedMinutesRemaining
         });
+        let prefetchedMemoryIds = [];
+        try {
+          const workspaceId = getActiveWorkspaceId();
+          if (workspaceId) {
+            const { card } = await client3.getCard(cardId);
+            const typedCard = card;
+            const cardLabels = (typedCard.labels || []).map((l) => l.name);
+            const taskContext = [
+              typedCard.title || "",
+              typedCard.description || ""
+            ].filter(Boolean).join(" ");
+            const assembled = await assembleContext({
+              workspaceId,
+              projectId: getActiveProjectId() || undefined,
+              taskContext,
+              cardLabels,
+              cardId,
+              tokenBudget: 2000,
+              client: client3
+            });
+            prefetchedMemoryIds = assembled.memories.map((m) => m.id);
+            if (prefetchedMemoryIds.length > 0) {
+              const graphResult = await discoverRelatedContext(client3, prefetchedMemoryIds.slice(0, 5), 2, 10);
+              const additionalIds = graphResult.entities.map((e) => e.id).filter((id) => !prefetchedMemoryIds.includes(id));
+              prefetchedMemoryIds.push(...additionalIds);
+            }
+          }
+        } catch {}
         return {
           success: true,
           assignedTo,
           movedTo,
           labelsAdded,
+          prefetchedMemoryCount: prefetchedMemoryIds.length,
           ...result
         };
       }
@@ -32055,7 +33370,7 @@ class HarmonyMCPServer {
         const cardId = exports_external.string().uuid().parse(args.cardId);
         const agentIdentifier = exports_external.string().min(1).parse(args.agentIdentifier);
         const agentName = exports_external.string().min(1).parse(args.agentName);
-        const result = await client2.updateAgentProgress(cardId, {
+        const result = await client3.updateAgentProgress(cardId, {
           agentIdentifier,
           agentName,
           status: args.status,
@@ -32069,33 +33384,54 @@ class HarmonyMCPServer {
       case "harmony_end_agent_session": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
         const moveToColumn = args.moveToColumn;
-        const result = await client2.endAgentSession(cardId, {
-          status: args.status || "completed",
+        const sessionStatus = args.status || "completed";
+        const result = await client3.endAgentSession(cardId, {
+          status: sessionStatus,
           progressPercent: args.progressPercent
         });
         let movedTo = null;
-        if (moveToColumn) {
-          try {
-            const { card } = await client2.getCard(cardId);
-            const projectId = card.project_id;
-            if (projectId) {
-              const board = await client2.getBoard(projectId, {
-                summary: true
-              });
-              const columns = board.columns;
-              const col = columns.find((c) => c.name.toLowerCase().includes(moveToColumn.toLowerCase()));
-              if (col) {
-                await client2.moveCard(cardId, col.id);
-                movedTo = col.name;
-              }
+        let learningsExtracted = 0;
+        let cardTitle = "";
+        let cardLabels = [];
+        try {
+          const { card } = await client3.getCard(cardId);
+          const typedCard = card;
+          cardTitle = typedCard.title || "";
+          cardLabels = (typedCard.labels || []).map((l) => l.name);
+          const projectId = typedCard.project_id;
+          if (moveToColumn && projectId) {
+            const board = await client3.getBoard(projectId, {
+              summary: true
+            });
+            const columns = board.columns;
+            const col = columns.find((c) => c.name.toLowerCase().includes(moveToColumn.toLowerCase()));
+            if (col) {
+              await client3.moveCard(cardId, col.id);
+              movedTo = col.name;
             }
-          } catch {}
-        }
-        return { success: true, movedTo, ...result };
+          }
+        } catch {}
+        try {
+          const session = result.session;
+          const sessionContext = {
+            cardId,
+            cardTitle,
+            cardLabels,
+            agentIdentifier: session?.agent_identifier || "unknown",
+            agentName: session?.agent_name || "Unknown Agent",
+            status: sessionStatus,
+            progressPercent: args.progressPercent,
+            blockers: session?.blockers || undefined,
+            currentTask: session?.current_task || undefined
+          };
+          const learningResult = await extractLearnings(client3, sessionContext);
+          learningsExtracted = learningResult.count;
+        } catch {}
+        return { success: true, movedTo, learningsExtracted, ...result };
       }
       case "harmony_get_agent_session": {
         const cardId = exports_external.string().uuid().parse(args.cardId);
-        const result = await client2.getAgentSession(cardId, {
+        const result = await client3.getAgentSession(cardId, {
           includeEnded: args.includeEnded === true || args.includeEnded === "true"
         });
         return { success: true, ...result };
@@ -32105,7 +33441,7 @@ class HarmonyMCPServer {
         let columnData = null;
         if (args.cardId) {
           const cardId = exports_external.string().uuid().parse(args.cardId);
-          const cardResult = await client2.getCard(cardId);
+          const cardResult = await client3.getCard(cardId);
           cardData = cardResult.card;
         } else if (args.shortId !== undefined) {
           const shortId = exports_external.number().int().positive().parse(args.shortId);
@@ -32113,7 +33449,7 @@ class HarmonyMCPServer {
           if (!projectId) {
             throw new Error("Project ID required when using shortId. Use harmony_set_project_context or provide projectId.");
           }
-          const cardResult = await client2.getCardByShortId(projectId, shortId);
+          const cardResult = await client3.getCardByShortId(projectId, shortId);
           cardData = cardResult.card;
         } else {
           throw new Error("Either cardId or shortId must be provided");
@@ -32121,7 +33457,7 @@ class HarmonyMCPServer {
         const projectIdForBoard = args.projectId || getActiveProjectId() || cardData.project_id;
         if (projectIdForBoard) {
           try {
-            const board = await client2.getBoard(projectIdForBoard, {
+            const board = await client3.getBoard(projectIdForBoard, {
               summary: true
             });
             const columnId = cardData.column_id;
@@ -32142,36 +33478,64 @@ class HarmonyMCPServer {
         if (args.includeDescription !== undefined) {
           contextOptions.includeDescription = args.includeDescription === true || args.includeDescription === "true";
         }
+        let assembledContextStr;
+        let assemblyId;
         let memories;
         try {
           const workspaceId = getActiveWorkspaceId();
           if (workspaceId && cardData.title) {
-            const memoryResult = await client2.searchMemoryEntities(workspaceId, cardData.title, {
-              project_id: getActiveProjectId() || undefined,
-              limit: 5
+            const cardLabels = (cardData.labels || []).map((l) => l.name);
+            const taskContext = [
+              cardData.title,
+              cardData.description || ""
+            ].filter(Boolean).join(" ");
+            const assembled = await assembleContext({
+              workspaceId,
+              projectId: getActiveProjectId() || undefined,
+              taskContext,
+              cardLabels,
+              cardId: cardData.id,
+              client: client3
             });
-            if (memoryResult.entities?.length > 0) {
-              memories = memoryResult.entities.map((e) => {
-                const entity = e;
-                return {
-                  id: entity.id,
-                  type: entity.type,
-                  title: entity.title,
-                  content: entity.content,
-                  confidence: entity.confidence,
-                  tags: entity.tags || []
-                };
-              });
+            if (assembled.context) {
+              assembledContextStr = assembled.context;
+              assemblyId = assembled.manifest.assemblyId;
+              cacheManifest(assembled.manifest);
             }
           }
-        } catch {}
+        } catch {
+          try {
+            const workspaceId = getActiveWorkspaceId();
+            if (workspaceId && cardData.title) {
+              const memoryResult = await client3.searchMemoryEntities(workspaceId, cardData.title, {
+                project_id: getActiveProjectId() || undefined,
+                limit: 5
+              });
+              if (memoryResult.entities?.length > 0) {
+                memories = memoryResult.entities.map((e) => {
+                  const entity = e;
+                  return {
+                    id: entity.id,
+                    type: entity.type,
+                    title: entity.title,
+                    content: entity.content,
+                    confidence: entity.confidence,
+                    tags: entity.tags || []
+                  };
+                });
+              }
+            }
+          } catch {}
+        }
         const result = generatePrompt({
           card: cardData,
           column: columnData,
           variant,
           contextOptions,
           customConstraints: args.customConstraints,
-          memories
+          memories,
+          assembledContext: assembledContextStr,
+          assemblyId
         });
         return {
           success: true,
@@ -32188,11 +33552,13 @@ class HarmonyMCPServer {
         if (!workspaceId) {
           throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
         }
-        const result = await client2.createMemoryEntity({
+        const entityType = args.type || "context";
+        const result = await client3.createMemoryEntity({
           workspace_id: workspaceId,
           project_id: args.projectId || getActiveProjectId() || undefined,
-          type: args.type || "context",
+          type: entityType,
           scope: args.scope || "project",
+          memory_tier: args.tier || undefined,
           title,
           content,
           metadata: args.metadata,
@@ -32207,7 +33573,7 @@ class HarmonyMCPServer {
         if (!workspaceId) {
           throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
         }
-        const markdown = await client2.listMemoryEntitiesMarkdown({
+        const markdown = await client3.listMemoryEntitiesMarkdown({
           workspace_id: workspaceId,
           project_id: args.projectId || getActiveProjectId() || undefined,
           type: args.type,
@@ -32236,12 +33602,12 @@ class HarmonyMCPServer {
           updates.confidence = args.confidence;
         if (args.metadata !== undefined)
           updates.metadata = args.metadata;
-        const result = await client2.updateMemoryEntity(entityId, updates);
+        const result = await client3.updateMemoryEntity(entityId, updates);
         return { success: true, ...result };
       }
       case "harmony_forget": {
         const entityId = exports_external.string().uuid().parse(args.entityId);
-        await client2.deleteMemoryEntity(entityId);
+        await client3.deleteMemoryEntity(entityId);
         return { success: true };
       }
       case "harmony_relate": {
@@ -32254,9 +33620,10 @@ class HarmonyMCPServer {
           "supports",
           "depends_on",
           "part_of",
-          "caused_by"
+          "caused_by",
+          "relates_to"
         ]).parse(args.relationType);
-        const result = await client2.createMemoryRelation({
+        const result = await client3.createMemoryRelation({
           source_id: sourceId,
           target_id: targetId,
           relation_type: relationType,
@@ -32270,17 +33637,81 @@ class HarmonyMCPServer {
         if (!workspaceId) {
           throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
         }
-        const markdown = await client2.searchMemoryEntitiesMarkdown(workspaceId, query, {
+        const markdown = await client3.searchMemoryEntitiesMarkdown(workspaceId, query, {
           project_id: args.projectId || getActiveProjectId() || undefined,
           type: args.type,
           limit: args.limit
         });
         return markdown || "No memories found.";
       }
+      case "harmony_vault_index": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const markdown = await client3.getVaultIndexMarkdown({
+          workspace_id: workspaceId,
+          project_id: args.projectId || getActiveProjectId() || undefined,
+          type: args.type,
+          limit: args.limit
+        });
+        return markdown || "No entities found.";
+      }
+      case "harmony_resolve_links": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const result = await client3.resolveLinks({
+          workspace_id: workspaceId,
+          project_id: args.projectId || getActiveProjectId() || undefined
+        });
+        return {
+          success: true,
+          ...result,
+          message: `Resolved ${result.resolved} wiki-links, ${result.unresolved} remain unresolved.`
+        };
+      }
+      case "harmony_sync": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const direction = args.direction || "full";
+        const syncProjectId = args.projectId || getActiveProjectId() || undefined;
+        const syncConfig = { memoryDir: getMemoryDir() };
+        let syncResult;
+        switch (direction) {
+          case "pull":
+            syncResult = await syncPull(client3, syncConfig, workspaceId, syncProjectId);
+            break;
+          case "push":
+            syncResult = await syncPush(client3, syncConfig, workspaceId);
+            break;
+          default:
+            syncResult = await syncFull(client3, syncConfig, workspaceId, syncProjectId);
+        }
+        const parts = [];
+        if (syncResult.pulled > 0)
+          parts.push(`${syncResult.pulled} pulled`);
+        if (syncResult.pushed > 0)
+          parts.push(`${syncResult.pushed} pushed`);
+        if (syncResult.deleted > 0)
+          parts.push(`${syncResult.deleted} deleted`);
+        if (syncResult.conflicts > 0)
+          parts.push(`${syncResult.conflicts} conflicts (server wins)`);
+        const summary = parts.length > 0 ? parts.join(", ") : "Already in sync";
+        return {
+          success: syncResult.errors.length === 0,
+          ...syncResult,
+          memoryDir: syncConfig.memoryDir,
+          message: summary
+        };
+      }
       case "harmony_create_plan": {
         const title = exports_external.string().min(1).parse(args.title);
         const projectId = args.projectId || getProjectId();
-        const result = await client2.createPlan(projectId, {
+        const result = await client3.createPlan(projectId, {
           title,
           content: args.content,
           source: args.source || "agent",
@@ -32299,10 +33730,10 @@ class HarmonyMCPServer {
         let result = null;
         if (args.planId) {
           const planId = exports_external.string().uuid().parse(args.planId);
-          result = await client2.getPlan(planId);
+          result = await client3.getPlan(planId);
         } else if (args.cardId) {
           const cardId = exports_external.string().uuid().parse(args.cardId);
-          result = await client2.getPlanByCardId(cardId);
+          result = await client3.getPlanByCardId(cardId);
           if (!result) {
             return {
               success: true,
@@ -32330,9 +33761,251 @@ class HarmonyMCPServer {
         if (args.status !== undefined) {
           updates.status = exports_external.enum(["draft", "active", "archived"]).parse(args.status);
         }
-        const result = await client2.updatePlan(planId, updates);
+        const result = await client3.updatePlan(planId, updates);
         return { success: true, plan: result.plan };
       }
+      case "harmony_debug_context": {
+        const entityId = exports_external.string().uuid().parse(args.entityId);
+        const taskContext = exports_external.string().min(1).parse(args.taskContext);
+        const cardLabels = args.cardLabels || [];
+        const entityResult = await client3.getMemoryEntity(entityId);
+        const entity = mapToContextEntity(entityResult.entity);
+        const { score, reasons } = computeRelevanceScore(entity, taskContext, cardLabels);
+        const lifecycle2 = evaluateLifecycle({
+          memory_tier: entity.memory_tier,
+          confidence: entity.confidence,
+          access_count: entity.access_count,
+          last_accessed_at: entity.last_accessed_at,
+          created_at: entity.updated_at
+        });
+        return {
+          success: true,
+          entity: {
+            id: entity.id,
+            title: entity.title,
+            type: entity.type,
+            tier: entity.memory_tier,
+            confidence: entity.confidence,
+            accessCount: entity.access_count
+          },
+          relevance: {
+            score: Math.round(score * 1000) / 1000,
+            reasons,
+            wouldBeIncluded: score >= 0.1,
+            threshold: 0.1
+          },
+          lifecycle: {
+            decayScore: Math.round(lifecycle2.decay.score * 1000) / 1000,
+            daysSinceAccess: Math.round(lifecycle2.decay.daysSinceAccess),
+            promotionEligible: lifecycle2.promotion.eligible,
+            promotionTarget: lifecycle2.promotion.targetTier,
+            shouldArchive: lifecycle2.shouldArchive,
+            shouldFlagForReview: lifecycle2.shouldFlagForReview
+          },
+          suggestions: [
+            ...lifecycle2.promotion.eligible ? [`Eligible for promotion to ${lifecycle2.promotion.targetTier}: ${lifecycle2.promotion.reason}`] : [],
+            ...lifecycle2.shouldArchive ? [`Consider archiving: ${lifecycle2.archiveReason}`] : [],
+            ...lifecycle2.shouldFlagForReview ? [`Flagged for review: ${lifecycle2.reviewReason}`] : [],
+            ...score < 0.1 ? ["Below relevance threshold - consider adding more specific tags or updating content"] : []
+          ]
+        };
+      }
+      case "harmony_export_memory_graph": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const projectId = args.projectId || getActiveProjectId() || undefined;
+        const limit = args.limit || 50;
+        const result = await client3.listMemoryEntities({
+          workspace_id: workspaceId,
+          project_id: projectId,
+          limit
+        });
+        const entities = result.entities || [];
+        const tierColors = {
+          draft: "#FFEB3B",
+          episode: "#2196F3",
+          reference: "#4CAF50"
+        };
+        const typeShapes = {
+          error: "octagon",
+          solution: "diamond",
+          pattern: "hexagon",
+          decision: "house",
+          lesson: "ellipse",
+          preference: "parallelogram"
+        };
+        const lines = [
+          "digraph KnowledgeGraph {",
+          "  rankdir=LR;",
+          "  node [style=filled, fontsize=10];",
+          ""
+        ];
+        for (const entity of entities) {
+          const tier = entity.memory_tier || "reference";
+          const color = tierColors[tier] || "#9E9E9E";
+          const shape = typeShapes[entity.type] || "box";
+          const label = entity.title.length > 40 ? entity.title.slice(0, 37) + "..." : entity.title;
+          const safeLabel = label.replace(/"/g, "\\\"");
+          lines.push(`  "${entity.id.slice(0, 8)}" [label="${safeLabel}\\n(${entity.type}, ${tier})", fillcolor="${color}", shape=${shape}];`);
+        }
+        const entityIds = new Set(entities.map((e) => e.id));
+        const addedEdges = new Set;
+        for (const entity of entities.slice(0, 20)) {
+          try {
+            const related = await client3.getRelatedEntities(entity.id);
+            for (const raw of [...related.outgoing || [], ...related.incoming || []]) {
+              const rel = raw;
+              if (entityIds.has(rel.source_id) && entityIds.has(rel.target_id)) {
+                const edgeKey = `${rel.source_id}-${rel.target_id}-${rel.relation_type}`;
+                if (!addedEdges.has(edgeKey)) {
+                  addedEdges.add(edgeKey);
+                  lines.push(`  "${rel.source_id.slice(0, 8)}" -> "${rel.target_id.slice(0, 8)}" [label="${rel.relation_type}"];`);
+                }
+              }
+            }
+          } catch {}
+        }
+        lines.push("}");
+        const dotGraph = lines.join(`
+`);
+        return {
+          success: true,
+          format: "dot",
+          entityCount: entities.length,
+          edgeCount: addedEdges.size,
+          graph: dotGraph,
+          message: `Exported ${entities.length} entities and ${addedEdges.size} relations as DOT graph. Use Graphviz to render: echo '<graph>' | dot -Tpng -o graph.png`
+        };
+      }
+      case "harmony_prune_draft": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const projectId = args.projectId || getActiveProjectId() || undefined;
+        const dryRun = args.dryRun !== false;
+        const maxAgeDays = args.maxAgeDays || 30;
+        const result = await client3.listMemoryEntities({
+          workspace_id: workspaceId,
+          project_id: projectId,
+          limit: 100
+        });
+        const drafts = (result.entities || []).filter((e) => {
+          const entity = e;
+          return entity.memory_tier === "draft";
+        });
+        const now = Date.now();
+        const stale = [];
+        for (const raw of drafts) {
+          const entity = raw;
+          const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
+          if (ageDays < maxAgeDays)
+            continue;
+          const lifecycle2 = evaluateLifecycle(entity);
+          stale.push({
+            id: entity.id,
+            title: entity.title,
+            ageDays: Math.round(ageDays),
+            decayScore: Math.round(lifecycle2.decay.score * 100) / 100
+          });
+        }
+        if (!dryRun) {
+          for (const item of stale) {
+            try {
+              await client3.deleteMemoryEntity(item.id);
+            } catch {}
+          }
+        }
+        return {
+          success: true,
+          dryRun,
+          totalDrafts: drafts.length,
+          staleDrafts: stale.length,
+          pruned: dryRun ? 0 : stale.length,
+          items: stale,
+          message: dryRun ? `Found ${stale.length} stale drafts (>${maxAgeDays} days old). Run with dryRun=false to delete.` : `Pruned ${stale.length} stale draft memories.`
+        };
+      }
+      case "harmony_review_learnings": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const projectId = args.projectId || getActiveProjectId() || undefined;
+        const pending = await listPendingLearnings(client3, workspaceId, projectId);
+        return {
+          success: true,
+          count: pending.length,
+          learnings: pending,
+          message: pending.length > 0 ? `${pending.length} pending learnings awaiting review. Use harmony_approve_learning to approve or reject.` : "No pending learnings to review."
+        };
+      }
+      case "harmony_approve_learning": {
+        const entityId = exports_external.string().uuid().parse(args.entityId);
+        const action = exports_external.enum(["approve", "reject"]).parse(args.action);
+        if (action === "approve") {
+          await approveLearning(client3, entityId, args.confidence);
+          return {
+            success: true,
+            action: "approved",
+            message: "Learning approved and confidence set."
+          };
+        }
+        await rejectLearning(client3, entityId);
+        return {
+          success: true,
+          action: "rejected",
+          message: "Learning rejected and archived."
+        };
+      }
+      case "harmony_get_context_manifest": {
+        const assemblyId = exports_external.string().min(1).parse(args.assemblyId);
+        const manifest = getCachedManifest(assemblyId);
+        if (!manifest) {
+          throw new Error(`Manifest not found for assembly '${assemblyId}'. Manifests are cached in-memory and expire after server restart.`);
+        }
+        return {
+          success: true,
+          manifest,
+          summary: {
+            totalIncluded: manifest.included.length,
+            totalExcluded: manifest.excluded.length,
+            budgetUsed: `${manifest.budgetUsed}/${manifest.budgetTotal} tokens`,
+            tierBreakdown: manifest.tierBreakdown
+          }
+        };
+      }
+      case "harmony_promote_memory": {
+        const entityId = exports_external.string().uuid().parse(args.entityId);
+        const targetTier = exports_external.enum(["episode", "reference"]).parse(args.targetTier);
+        const reason = exports_external.string().min(1).parse(args.reason);
+        const entityResult = await client3.getMemoryEntity(entityId);
+        const entity = entityResult.entity;
+        const currentTier = entity.memory_tier || "reference";
+        const tierOrder = { draft: 0, episode: 1, reference: 2 };
+        if ((tierOrder[targetTier] || 0) <= (tierOrder[currentTier] || 0)) {
+          throw new Error(`Cannot promote from '${currentTier}' to '${targetTier}'. Must promote to a higher tier.`);
+        }
+        const result = await client3.updateMemoryEntity(entityId, {
+          memory_tier: targetTier,
+          metadata: {
+            promoted_from_tier: currentTier,
+            promotion_reason: reason,
+            promoted_at: new Date().toISOString()
+          }
+        });
+        return {
+          success: true,
+          promoted: {
+            from: currentTier,
+            to: targetTier,
+            reason
+          },
+          ...result
+        };
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
@@ -32341,19 +34014,32 @@ class HarmonyMCPServer {
     const transport = new StdioServerTransport;
     await this.server.connect(transport);
     console.error("Harmony MCP server running on stdio");
+    try {
+      if (isConfigured()) {
+        const workspaceId = getActiveWorkspaceId();
+        if (workspaceId) {
+          const client3 = getClient();
+          const syncConfig = { memoryDir: getMemoryDir() };
+          const result = await syncPull(client3, syncConfig, workspaceId);
+          console.error(`Startup sync: ${result.pulled} pulled, ${result.deleted} deleted, ${result.errors.length} errors`);
+        }
+      }
+    } catch (err) {
+      console.error(`Startup sync failed (non-fatal): ${err}`);
+    }
   }
 }
 
 // src/tui/setup.ts
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   lstatSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   symlinkSync,
   unlinkSync
 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname3, join as join4 } from "node:path";
 
 // ../../node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
@@ -33067,16 +34753,16 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/tui/agents.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var AGENT_DEFINITIONS = [
   {
     id: "claude",
     name: "Claude Code",
     description: "Anthropic CLI agent",
     hint: "/hmy <card>",
-    globalPaths: [join2(homedir2(), ".claude")],
+    globalPaths: [join3(homedir2(), ".claude")],
     localPaths: [".claude"]
   },
   {
@@ -33084,7 +34770,7 @@ var AGENT_DEFINITIONS = [
     name: "Codex",
     description: "OpenAI coding agent",
     hint: "/prompts:hmy <card>",
-    globalPaths: [join2(homedir2(), ".codex")],
+    globalPaths: [join3(homedir2(), ".codex")],
     localPaths: ["AGENTS.md"]
   },
   {
@@ -33100,20 +34786,20 @@ var AGENT_DEFINITIONS = [
     name: "Windsurf",
     description: "Codeium AI IDE",
     hint: "MCP tools available automatically",
-    globalPaths: [join2(homedir2(), ".codeium", "windsurf")],
+    globalPaths: [join3(homedir2(), ".codeium", "windsurf")],
     localPaths: [".windsurf", ".windsurfrules"]
   }
 ];
 function detectAgents(cwd = process.cwd()) {
   return AGENT_DEFINITIONS.map((def) => {
-    const globalPath = def.globalPaths.find((p2) => existsSync2(p2)) || null;
-    const localPath = def.localPaths.find((p2) => existsSync2(join2(cwd, p2))) || null;
+    const globalPath = def.globalPaths.find((p2) => existsSync3(p2)) || null;
+    const localPath = def.localPaths.find((p2) => existsSync3(join3(cwd, p2))) || null;
     return {
       id: def.id,
       name: def.name,
       detected: !!(globalPath || localPath),
       globalPath,
-      localPath: localPath ? join2(cwd, localPath) : null,
+      localPath: localPath ? join3(cwd, localPath) : null,
       description: def.description,
       hint: def.hint
     };
@@ -33185,23 +34871,23 @@ function formatPath(path, homeDir) {
 }
 
 // src/tui/writer.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 function ensureDir(dirPath) {
-  if (!existsSync3(dirPath)) {
-    mkdirSync2(dirPath, { recursive: true, mode: 493 });
+  if (!existsSync4(dirPath)) {
+    mkdirSync3(dirPath, { recursive: true, mode: 493 });
   }
 }
 function writeFile(filePath, content, options = {}) {
-  const exists = existsSync3(filePath);
+  const exists = existsSync4(filePath);
   if (exists && !options.force) {
     return { path: filePath, action: "skip" };
   }
   try {
-    ensureDir(dirname(filePath));
+    ensureDir(dirname2(filePath));
     const mode = filePath.includes(".harmony-mcp") ? 384 : 420;
-    writeFileSync2(filePath, content, { mode });
+    writeFileSync3(filePath, content, { mode });
     return { path: filePath, action: exists ? "update" : "create" };
   } catch (error48) {
     return {
@@ -33212,11 +34898,11 @@ function writeFile(filePath, content, options = {}) {
   }
 }
 function mergeJsonFile(filePath, updates, options = {}) {
-  const exists = existsSync3(filePath);
+  const exists = existsSync4(filePath);
   if (!exists) {
     try {
-      ensureDir(dirname(filePath));
-      writeFileSync2(filePath, JSON.stringify(updates, null, 2), {
+      ensureDir(dirname2(filePath));
+      writeFileSync3(filePath, JSON.stringify(updates, null, 2), {
         mode: 420
       });
       return { path: filePath, action: "create" };
@@ -33229,7 +34915,7 @@ function mergeJsonFile(filePath, updates, options = {}) {
     }
   }
   try {
-    const existing = JSON.parse(readFileSync2(filePath, "utf-8"));
+    const existing = JSON.parse(readFileSync3(filePath, "utf-8"));
     if (updates.mcpServers && existing.mcpServers) {
       const existingServers = existing.mcpServers;
       const updateServers = updates.mcpServers;
@@ -33237,12 +34923,12 @@ function mergeJsonFile(filePath, updates, options = {}) {
     } else {
       Object.assign(existing, updates);
     }
-    writeFileSync2(filePath, JSON.stringify(existing, null, 2), { mode: 420 });
+    writeFileSync3(filePath, JSON.stringify(existing, null, 2), { mode: 420 });
     return { path: filePath, action: "merge" };
   } catch {
     if (options.force) {
       try {
-        writeFileSync2(filePath, JSON.stringify(updates, null, 2), {
+        writeFileSync3(filePath, JSON.stringify(updates, null, 2), {
           mode: 420
         });
         return { path: filePath, action: "update" };
@@ -33262,11 +34948,11 @@ function mergeJsonFile(filePath, updates, options = {}) {
   }
 }
 function appendToToml(filePath, section, content, options = {}) {
-  const exists = existsSync3(filePath);
+  const exists = existsSync4(filePath);
   if (!exists) {
     try {
-      ensureDir(dirname(filePath));
-      writeFileSync2(filePath, content, { mode: 420 });
+      ensureDir(dirname2(filePath));
+      writeFileSync3(filePath, content, { mode: 420 });
       return { path: filePath, action: "create" };
     } catch (error48) {
       return {
@@ -33277,18 +34963,18 @@ function appendToToml(filePath, section, content, options = {}) {
     }
   }
   try {
-    const existing = readFileSync2(filePath, "utf-8");
+    const existing = readFileSync3(filePath, "utf-8");
     if (existing.includes(section)) {
       if (options.force) {
         const updated = existing.replace(new RegExp(`\\[${section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\][\\s\\S]*?(?=\\[|$)`), content.trim() + `
 
 `);
-        writeFileSync2(filePath, updated, { mode: 420 });
+        writeFileSync3(filePath, updated, { mode: 420 });
         return { path: filePath, action: "update" };
       }
       return { path: filePath, action: "skip" };
     }
-    writeFileSync2(filePath, existing + `
+    writeFileSync3(filePath, existing + `
 ` + content, { mode: 420 });
     return { path: filePath, action: "merge" };
   } catch (error48) {
@@ -33338,7 +35024,7 @@ function getWriteSummary(files, options = {}) {
   const home = homedir3();
   for (const file2 of files) {
     const displayPath = formatPath(file2.path, home);
-    const exists = existsSync3(file2.path);
+    const exists = existsSync4(file2.path);
     if (exists && !options.force) {
       toSkip.push(displayPath);
     } else if (exists) {
@@ -33351,7 +35037,7 @@ function getWriteSummary(files, options = {}) {
 }
 
 // src/tui/setup.ts
-var GLOBAL_SKILLS_DIR = join3(homedir4(), ".agents", "skills");
+var GLOBAL_SKILLS_DIR = join4(homedir4(), ".agents", "skills");
 var API_URL = "https://gethmy.com/api";
 var HARMONY_WORKFLOW_PROMPT = `# Harmony Card Workflow
 
@@ -33578,16 +35264,16 @@ async function registerMcpServer() {
   }
 }
 async function writeMcpConfigFallback(home) {
-  const { readFileSync: readFileSync3, writeFileSync: writeFileSync3, mkdirSync: mkdirSync4, existsSync: existsSync5 } = await import("node:fs");
-  const settingsPath = join3(home, ".claude", "settings.json");
-  const settingsDir = dirname2(settingsPath);
-  if (!existsSync5(settingsDir)) {
-    mkdirSync4(settingsDir, { recursive: true });
+  const { readFileSync: readFileSync4, writeFileSync: writeFileSync4, mkdirSync: mkdirSync5, existsSync: existsSync6 } = await import("node:fs");
+  const settingsPath = join4(home, ".claude", "settings.json");
+  const settingsDir = dirname3(settingsPath);
+  if (!existsSync6(settingsDir)) {
+    mkdirSync5(settingsDir, { recursive: true });
   }
   let settings = {};
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+      settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
     } catch {}
   }
   const mcpServers = settings.mcpServers || {};
@@ -33596,7 +35282,7 @@ async function writeMcpConfigFallback(home) {
     args: ["-y", "harmony-mcp@latest", "serve"]
   };
   settings.mcpServers = mcpServers;
-  writeFileSync3(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync4(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function validateApiKey(apiKey, apiUrl = API_URL) {
   try {
@@ -33685,31 +35371,31 @@ ${HARMONY_PLAN_PROMPT.replace("$ARGUMENTS", "$ARGUMENTS")}
 `;
       if (installMode === "global") {
         files.push({
-          path: join3(GLOBAL_SKILLS_DIR, "hmy", "SKILL.md"),
+          path: join4(GLOBAL_SKILLS_DIR, "hmy", "SKILL.md"),
           content: skillContent,
           type: "text"
         });
         symlinks.push({
-          target: join3(GLOBAL_SKILLS_DIR, "hmy"),
-          link: join3(home, ".claude", "skills", "hmy")
+          target: join4(GLOBAL_SKILLS_DIR, "hmy"),
+          link: join4(home, ".claude", "skills", "hmy")
         });
         files.push({
-          path: join3(GLOBAL_SKILLS_DIR, "hmy-plan", "SKILL.md"),
+          path: join4(GLOBAL_SKILLS_DIR, "hmy-plan", "SKILL.md"),
           content: planSkillContent,
           type: "text"
         });
         symlinks.push({
-          target: join3(GLOBAL_SKILLS_DIR, "hmy-plan"),
-          link: join3(home, ".claude", "skills", "hmy-plan")
+          target: join4(GLOBAL_SKILLS_DIR, "hmy-plan"),
+          link: join4(home, ".claude", "skills", "hmy-plan")
         });
       } else {
         files.push({
-          path: join3(cwd, ".claude", "skills", "hmy", "SKILL.md"),
+          path: join4(cwd, ".claude", "skills", "hmy", "SKILL.md"),
           content: skillContent,
           type: "text"
         });
         files.push({
-          path: join3(cwd, ".claude", "skills", "hmy-plan", "SKILL.md"),
+          path: join4(cwd, ".claude", "skills", "hmy-plan", "SKILL.md"),
           content: planSkillContent,
           type: "text"
         });
@@ -33744,7 +35430,7 @@ When given a card reference (e.g., #42 or a card name), follow this workflow:
 - \`harmony_generate_prompt\` - Get role-based guidance and focus areas for the card
 `;
       files.push({
-        path: join3(cwd, "AGENTS.md"),
+        path: join4(cwd, "AGENTS.md"),
         content: agentsContent,
         type: "text"
       });
@@ -33761,17 +35447,17 @@ ${HARMONY_WORKFLOW_PROMPT.replace("$ARGUMENTS", "{{card}}").replace("Your agent
 `;
       if (installMode === "global") {
         files.push({
-          path: join3(GLOBAL_SKILLS_DIR, "codex", "hmy.md"),
+          path: join4(GLOBAL_SKILLS_DIR, "codex", "hmy.md"),
           content: promptContent,
           type: "text"
         });
         symlinks.push({
-          target: join3(GLOBAL_SKILLS_DIR, "codex", "hmy.md"),
-          link: join3(home, ".codex", "prompts", "hmy.md")
+          target: join4(GLOBAL_SKILLS_DIR, "codex", "hmy.md"),
+          link: join4(home, ".codex", "prompts", "hmy.md")
         });
       } else {
         files.push({
-          path: join3(home, ".codex", "prompts", "hmy.md"),
+          path: join4(home, ".codex", "prompts", "hmy.md"),
           content: promptContent,
           type: "text"
         });
@@ -33783,7 +35469,7 @@ command = "npx"
 args = ["-y", "harmony-mcp@latest", "serve"]
 `;
       files.push({
-        path: join3(home, ".codex", "config.toml"),
+        path: join4(home, ".codex", "config.toml"),
         content: tomlContent,
         type: "toml",
         tomlSection: "mcp_servers.harmony"
@@ -33792,7 +35478,7 @@ args = ["-y", "harmony-mcp@latest", "serve"]
     }
     case "cursor": {
       files.push({
-        path: join3(cwd, ".cursor", "mcp.json"),
+        path: join4(cwd, ".cursor", "mcp.json"),
         content: JSON.stringify({
           mcpServers: {
             harmony: {
@@ -33818,17 +35504,17 @@ ${HARMONY_WORKFLOW_PROMPT.replace("$ARGUMENTS", "the card reference").replace("Y
 `;
       if (installMode === "global") {
         files.push({
-          path: join3(GLOBAL_SKILLS_DIR, "cursor", "harmony.mdc"),
+          path: join4(GLOBAL_SKILLS_DIR, "cursor", "harmony.mdc"),
           content: ruleContent,
           type: "text"
         });
         symlinks.push({
-          target: join3(GLOBAL_SKILLS_DIR, "cursor", "harmony.mdc"),
-          link: join3(home, ".cursor", "rules", "harmony.mdc")
+          target: join4(GLOBAL_SKILLS_DIR, "cursor", "harmony.mdc"),
+          link: join4(home, ".cursor", "rules", "harmony.mdc")
         });
       } else {
         files.push({
-          path: join3(cwd, ".cursor", "rules", "harmony.mdc"),
+          path: join4(cwd, ".cursor", "rules", "harmony.mdc"),
           content: ruleContent,
           type: "text"
         });
@@ -33837,7 +35523,7 @@ ${HARMONY_WORKFLOW_PROMPT.replace("$ARGUMENTS", "the card reference").replace("Y
     }
     case "windsurf": {
       files.push({
-        path: join3(home, ".codeium", "windsurf", "mcp_config.json"),
+        path: join4(home, ".codeium", "windsurf", "mcp_config.json"),
         content: JSON.stringify({
           mcpServers: {
             harmony: {
@@ -33863,17 +35549,17 @@ ${HARMONY_WORKFLOW_PROMPT.replace("$ARGUMENTS", "the card reference").replace("Y
 `;
       if (installMode === "global") {
         files.push({
-          path: join3(GLOBAL_SKILLS_DIR, "windsurf", "harmony.md"),
+          path: join4(GLOBAL_SKILLS_DIR, "windsurf", "harmony.md"),
           content: ruleContent,
           type: "text"
         });
         symlinks.push({
-          target: join3(GLOBAL_SKILLS_DIR, "windsurf", "harmony.md"),
-          link: join3(home, ".codeium", "windsurf", "rules", "harmony.md")
+          target: join4(GLOBAL_SKILLS_DIR, "windsurf", "harmony.md"),
+          link: join4(home, ".codeium", "windsurf", "rules", "harmony.md")
         });
       } else {
         files.push({
-          path: join3(cwd, ".windsurf", "rules", "harmony.md"),
+          path: join4(cwd, ".windsurf", "rules", "harmony.md"),
           content: ruleContent,
           type: "text"
         });
@@ -34148,9 +35834,9 @@ async function runSetup(options = {}) {
   if (allSymlinks.length > 0) {
     for (const symlink of allSymlinks) {
       try {
-        const linkDir = dirname2(symlink.link);
-        if (!existsSync4(linkDir)) {
-          mkdirSync3(linkDir, { recursive: true });
+        const linkDir = dirname3(symlink.link);
+        if (!existsSync5(linkDir)) {
+          mkdirSync4(linkDir, { recursive: true });
         }
         let linkExists = false;
         try {
@@ -34178,7 +35864,7 @@ async function runSetup(options = {}) {
     } else {
       try {
         await writeMcpConfigFallback(home);
-        console.log(`  ${colors.success("✓")} ${colors.dim(formatPath(join3(home, ".claude", "settings.json"), home))} ${colors.dim("(updated)")}`);
+        console.log(`  ${colors.success("✓")} ${colors.dim(formatPath(join4(home, ".claude", "settings.json"), home))} ${colors.dim("(updated)")}`);
       } catch {
         M2.warning("Could not register MCP server. Run manually: claude mcp add --transport stdio harmony -- npx -y harmony-mcp@latest serve");
       }