@gethmy/mcp 2.4.3 → 2.4.6

package/dist/remote.js

@@ -7070,6 +7070,7 @@ __export(exports_context_assembly, {
   mapToContextEntity: () => mapToContextEntity,
   getSessionAssemblyId: () => getSessionAssemblyId,
   getCachedManifest: () => getCachedManifest,
+  expandQuery: () => expandQuery,
   computeRelevanceScore: () => computeRelevanceScore,
   cacheManifest: () => cacheManifest,
   assembleContext: () => assembleContext
@@ -7077,6 +7078,29 @@ __export(exports_context_assembly, {
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
+function passesQualityGate(entity) {
+  const content = entity.content.trim();
+  if (content.length < 50)
+    return false;
+  const normalizedTitle = entity.title.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
+  const normalizedContent = content.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
+  if (normalizedContent.length < normalizedTitle.length * 1.5) {
+    return false;
+  }
+  if (entity.type === "pattern" && /recurring .+ \(\d+ instances\)/i.test(entity.title)) {
+    const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+    const bulletLines = lines.filter((l) => l.trim().startsWith("- "));
+    if (bulletLines.length > lines.length * 0.6)
+      return false;
+  }
+  if (entity.type === "procedure") {
+    const stepCount = (content.match(/^\d+\.\s/gm) || []).length;
+    if (stepCount < 3)
+      return false;
+  }
+  return true;
+}
 function generateAssemblyId() {
   return `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -7108,7 +7132,45 @@ function truncateContent(content, maxTokens) {
   }
   return { text: result, truncated: true };
 }
-function computeRelevanceScore(entity, taskContext, cardLabels) {
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function expandQuery(taskContext) {
+  const queries = [taskContext];
+  const lowerQueries = [taskContext.toLowerCase()];
+  const words = taskContext.toLowerCase().split(/\W+/).filter((w) => w.length > 2);
+  const expandableWords = words.filter((w) => QUERY_SYNONYMS[w]);
+  for (const word of expandableWords) {
+    const synonyms = QUERY_SYNONYMS[word];
+    if (!synonyms)
+      continue;
+    const variation = taskContext.replace(new RegExp(`\\b${escapeRegex2(word)}\\b`, "gi"), synonyms[0]);
+    const lowerVariation = variation.toLowerCase();
+    if (lowerVariation !== taskContext.toLowerCase() && !lowerQueries.includes(lowerVariation)) {
+      queries.push(variation);
+      lowerQueries.push(lowerVariation);
+    }
+    if (queries.length >= MAX_QUERY_VARIATIONS)
+      break;
+  }
+  if (words.length >= 3) {
+    const keyPhrases = words.filter((w) => ![
+      "the",
+      "and",
+      "for",
+      "with",
+      "this",
+      "that",
+      "from",
+      "into"
+    ].includes(w)).slice(0, 4).join(" ");
+    if (!lowerQueries.includes(keyPhrases)) {
+      queries.push(keyPhrases);
+    }
+  }
+  return queries.slice(0, MAX_QUERY_VARIATIONS);
+}
+function computeRelevanceScore(entity, taskContext, cardLabels, graphRelations) {
   const reasons = [];
   let score = 0;
   const hasRrfScore = entity.rrf_score !== undefined && entity.rrf_score > 0;
@@ -7167,7 +7229,23 @@ function computeRelevanceScore(entity, taskContext, cardLabels) {
     score += 0.1;
     reasons.push("procedure_boost");
   }
-  score = Math.min(score, 1);
+  if (graphRelations && graphRelations.length > 0) {
+    const entityRelations = graphRelations.filter((r) => r.source_id === entity.id || r.target_id === entity.id);
+    if (entityRelations.length > 0) {
+      let bestBonus = 0;
+      let bestRelType = "";
+      for (const rel of entityRelations) {
+        const bonus = RELATION_BONUSES[rel.relation_type] ?? 0.1;
+        if (bonus > bestBonus) {
+          bestBonus = bonus;
+          bestRelType = rel.relation_type;
+        }
+      }
+      score += bestBonus;
+      reasons.push(`graph_walk(${bestRelType})`);
+    }
+  }
+  score = Math.max(0, Math.min(score, 1));
   const tierWeight = TIER_WEIGHTS[entity.memory_tier];
   score *= tierWeight;
   return { score, reasons };
@@ -7179,7 +7257,11 @@ async function assembleContext(options) {
     taskContext,
     cardLabels = [],
     tokenBudget = DEFAULT_TOKEN_BUDGET,
-    client: client2
+    client: client2,
+    graphWalkEnabled = true,
+    queryExpansionEnabled = true,
+    enableLlmReranking = false,
+    rerankFn
   } = options;
   const assemblyId = generateAssemblyId();
   const manifest = {
@@ -7195,13 +7277,26 @@ async function assembleContext(options) {
       reference: { count: 0, tokens: 0 }
     }
   };
-  let candidates = [];
-  try {
-    const searchResult = await client2.searchMemoryEntities(workspaceId, taskContext, { project_id: projectId, limit: 30 });
-    if (searchResult.entities?.length > 0) {
-      candidates = searchResult.entities.map(mapToContextEntity);
+  const candidates = [];
+  const queries = queryExpansionEnabled ? expandQuery(taskContext) : [taskContext];
+  const searchResults = await Promise.allSettled(queries.map((query) => client2.searchMemoryEntities(workspaceId, query, {
+    project_id: projectId,
+    limit: 30
+  })));
+  const candidateIds = new Set;
+  for (const result of searchResults) {
+    if (result.status !== "fulfilled")
+      continue;
+    if (result.value.entities?.length > 0) {
+      for (const raw2 of result.value.entities) {
+        const entity = mapToContextEntity(raw2);
+        if (!candidateIds.has(entity.id)) {
+          candidateIds.add(entity.id);
+          candidates.push(entity);
+        }
+      }
     }
-  } catch {}
+  }
   if (candidates.length < 10 && projectId) {
     try {
       const listResult = await client2.listMemoryEntities({
@@ -7210,9 +7305,13 @@ async function assembleContext(options) {
         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);
+        for (const raw2 of listResult.entities) {
+          const entity = mapToContextEntity(raw2);
+          if (!candidateIds.has(entity.id)) {
+            candidateIds.add(entity.id);
+            candidates.push(entity);
+          }
+        }
       }
     } catch {}
   }
@@ -7224,9 +7323,33 @@ async function assembleContext(options) {
         limit: 20
       });
       if (wsResult.entities?.length > 0) {
-        const existingIds = new Set(candidates.map((c) => c.id));
-        const additional = wsResult.entities.map(mapToContextEntity).filter((e) => !existingIds.has(e.id));
-        candidates.push(...additional);
+        for (const raw2 of wsResult.entities) {
+          const entity = mapToContextEntity(raw2);
+          if (!candidateIds.has(entity.id)) {
+            candidateIds.add(entity.id);
+            candidates.push(entity);
+          }
+        }
+      }
+    } catch {}
+  }
+  let graphRelations = [];
+  if (graphWalkEnabled && candidates.length > 0) {
+    try {
+      const seedCandidates = [...candidates].sort((a, b) => (b.rrf_score ?? 0) - (a.rrf_score ?? 0)).slice(0, GRAPH_WALK_SEED_COUNT);
+      const seedIds = seedCandidates.map((c) => c.id);
+      const walkResult = await discoverRelatedContext(client2, seedIds, GRAPH_WALK_MAX_DEPTH, GRAPH_WALK_MAX_ENTITIES, GRAPH_WALK_MIN_CONFIDENCE);
+      graphRelations = walkResult.relations;
+      const newEntityIds = walkResult.entities.filter((e) => !candidateIds.has(e.id)).map((e) => e.id);
+      if (newEntityIds.length > 0) {
+        const fetchResults = await Promise.allSettled(newEntityIds.map((id) => client2.getMemoryEntity(id)));
+        for (const result of fetchResults) {
+          if (result.status !== "fulfilled" || !result.value.entity)
+            continue;
+          const mapped = mapToContextEntity(result.value.entity);
+          candidateIds.add(mapped.id);
+          candidates.push(mapped);
+        }
       }
     } catch {}
   }
@@ -7237,11 +7360,52 @@ async function assembleContext(options) {
       memories: []
     };
   }
-  const scored = candidates.map((entity) => {
-    const { score, reasons } = computeRelevanceScore(entity, taskContext, cardLabels);
+  const qualityCandidates = candidates.filter((entity) => {
+    if (passesQualityGate(entity))
+      return true;
+    manifest.excluded.push({
+      entityId: entity.id,
+      title: entity.title,
+      type: entity.type,
+      tier: entity.memory_tier,
+      relevanceScore: 0,
+      reason: "failed_quality_gate"
+    });
+    return false;
+  });
+  if (qualityCandidates.length === 0) {
+    return {
+      context: "",
+      manifest,
+      memories: []
+    };
+  }
+  const scored = qualityCandidates.map((entity) => {
+    const { score, reasons } = computeRelevanceScore(entity, taskContext, cardLabels, graphRelations.length > 0 ? graphRelations : undefined);
     return { entity, score, reasons };
   });
   scored.sort((a, b) => b.score - a.score);
+  if (enableLlmReranking && rerankFn && scored.length >= RERANK_MIN_CANDIDATES) {
+    const topN = scored.slice(0, RERANK_TOP_N);
+    const scoreRange = topN[0].score - topN[topN.length - 1].score;
+    if (scoreRange <= RERANK_CLUSTER_THRESHOLD) {
+      try {
+        const rerankCandidates = topN.map((s) => ({
+          id: s.entity.id,
+          title: s.entity.title,
+          snippet: s.entity.content.slice(0, 200)
+        }));
+        const rerankedIds = await rerankFn(taskContext, rerankCandidates);
+        const idOrder = new Map(rerankedIds.map((id, i) => [id, i]));
+        topN.sort((a, b) => {
+          const aIdx = idOrder.get(a.entity.id) ?? 999;
+          const bIdx = idOrder.get(b.entity.id) ?? 999;
+          return aIdx - bIdx;
+        });
+        scored.splice(0, topN.length, ...topN);
+      } catch {}
+    }
+  }
   const procedureBudget = Math.floor(tokenBudget * PROCEDURE_BUDGET_FRACTION);
   const remainingBudget = tokenBudget - procedureBudget;
   const tierBudgets = {
@@ -7553,7 +7717,7 @@ async function recordContextFeedback(client2, cardId, sessionStatus, progressPer
   sessionAssemblyMap.delete(cardId);
   return { adjusted };
 }
-var DEFAULT_TOKEN_BUDGET = 4000, MAX_TOKENS_PER_ENTITY = 500, MIN_RELEVANCE_THRESHOLD = 0.1, TIER_WEIGHTS, PROCEDURE_BUDGET_FRACTION = 0.15, TIER_BUDGET_ALLOCATION, MIN_REFERENCE_SLOTS = 3, manifestCache, MAX_CACHE_SIZE = 50, sessionAssemblyMap, MAX_SESSION_MAP_SIZE = 100;
+var DEFAULT_TOKEN_BUDGET = 4000, MAX_TOKENS_PER_ENTITY = 500, MIN_RELEVANCE_THRESHOLD = 0.15, TIER_WEIGHTS, PROCEDURE_BUDGET_FRACTION = 0.15, TIER_BUDGET_ALLOCATION, MIN_REFERENCE_SLOTS = 1, GRAPH_WALK_MAX_DEPTH = 1, GRAPH_WALK_MAX_ENTITIES = 10, GRAPH_WALK_MIN_CONFIDENCE = 0.5, GRAPH_WALK_SEED_COUNT = 5, MAX_QUERY_VARIATIONS = 4, RERANK_CLUSTER_THRESHOLD = 0.05, RERANK_TOP_N = 10, RERANK_MIN_CANDIDATES = 5, RELATION_BONUSES, QUERY_SYNONYMS, manifestCache, MAX_CACHE_SIZE = 50, sessionAssemblyMap, MAX_SESSION_MAP_SIZE = 100;
 var init_context_assembly = __esm(() => {
   init_dist();
   TIER_WEIGHTS = {
@@ -7566,6 +7730,33 @@ var init_context_assembly = __esm(() => {
     episode: 0.3,
     draft: 0.1
   };
+  RELATION_BONUSES = {
+    depends_on: 0.15,
+    resolved_by: 0.2,
+    relates_to: 0.1,
+    implements: 0.15,
+    blocks: 0.15,
+    references: 0.1,
+    extends: 0.1,
+    caused_by: 0.15
+  };
+  QUERY_SYNONYMS = {
+    auth: ["authentication", "authorization", "session"],
+    authentication: ["auth", "session", "sign-in"],
+    login: ["sign-in", "authentication", "session"],
+    bug: ["error", "issue", "defect", "problem"],
+    error: ["exception", "failure", "issue"],
+    fix: ["resolve", "patch", "repair", "correct"],
+    deploy: ["deployment", "release", "ship", "publish"],
+    test: ["testing", "spec", "assertion", "verify"],
+    config: ["configuration", "settings", "setup"],
+    db: ["database", "storage", "persistence"],
+    database: ["storage", "persistence", "data store"],
+    api: ["endpoint", "route", "service"],
+    ui: ["frontend", "component", "view"],
+    perf: ["performance", "speed", "latency"],
+    performance: ["speed", "latency", "optimization"]
+  };
   manifestCache = new Map;
   sessionAssemblyMap = new Map;
 });
@@ -7694,7 +7885,11 @@ ${card.description}`);
   roleFraming.focus.forEach((f) => {
     sections.push(`- ${f}`);
   });
-  sections.push(`- **Memory:** When you discover important domain knowledge, architectural decisions, or infrastructure details, store them via \`harmony_remember\`. Focus on durable knowledge that future agents would benefit from \u2014 not ephemeral task details (those are auto-extracted from your session).`);
+  sections.push(`- **Memory:** Store reusable knowledge via \`harmony_remember\`. Only store what a future agent couldn't easily discover from the code itself, applies beyond this specific card, and includes a "because" (not just what, but why).`);
+  sections.push(`  - GOOD: "BoardContext card state must use moveCard action, never direct setState \u2014 optimistic updates depend on action ordering"`);
+  sections.push(`  - GOOD: "Mobile bottom bar is 64px, overlaps fixed-position drawers \u2014 always add pb-16 to drawer content"`);
+  sections.push(`  - BAD: "Fixed the login button" (no reusable knowledge \u2014 the fix is in the code)`);
+  sections.push(`  - BAD: "Completed card #42" (ephemeral, auto-tracked by session)`);
   sections.push(`
 ## Suggested Outputs`);
   roleFraming.outputSuggestions.forEach((s) => {
@@ -26137,9 +26332,20 @@ class HarmonyApiClient {
           },
           body: options?.rawBody ?? (body ? JSON.stringify(body) : undefined)
         });
-        const data = await response.json();
+        const text = await response.text();
+        const responseContentType = response.headers.get("content-type") || "";
+        const looksLikeJson = responseContentType.includes("application/json");
+        let data = null;
+        let parseError = null;
+        if (text) {
+          try {
+            data = JSON.parse(text);
+          } catch (err) {
+            parseError = err instanceof Error ? err : new Error(String(err));
+          }
+        }
         if (!response.ok) {
-          const errorMsg = data.error || `API error: ${response.status}`;
+          const errorMsg = data?.error || (looksLikeJson ? null : `API error: ${response.status} (non-JSON response)`) || `API error: ${response.status}`;
           if (!isRetryableError(null, response.status)) {
             throw new Error(errorMsg);
           }
@@ -26150,6 +26356,9 @@ class HarmonyApiClient {
           }
           throw lastError;
         }
+        if (parseError) {
+          throw new Error(`API returned ${response.status} with invalid JSON body: ${parseError.message}`);
+        }
         return data;
       } catch (error48) {
         lastError = error48 instanceof Error ? error48 : new Error(String(error48));
@@ -26298,6 +26507,9 @@ class HarmonyApiClient {
   async createLabel(projectId, data) {
     return this.request("POST", "/labels", { projectId, ...data });
   }
+  async deleteLabel(labelId) {
+    return this.request("DELETE", `/labels/${labelId}`);
+  }
   async createSubtask(cardId, title) {
     return this.request("POST", "/subtasks", { cardId, title });
   }
@@ -26316,6 +26528,12 @@ class HarmonyApiClient {
   async endAgentSession(cardId, data) {
     return this.request("DELETE", `/cards/${cardId}/agent-context`, data);
   }
+  async flushActivityLog(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/agent-activity-log`, data);
+  }
+  async getActivityLog(cardId, sessionId) {
+    return this.request("GET", `/cards/${cardId}/agent-activity-log?sessionId=${sessionId}`);
+  }
   async getAgentSession(cardId, options) {
     const params = new URLSearchParams;
     if (options?.includeEnded)
@@ -26872,13 +27090,13 @@ function levenshteinSimilarity(a, b) {
   const maxLen = Math.max(sa.length, sb.length);
   return 1 - matrix[sa.length][sb.length] / maxLen;
 }
-async function extractMidSessionLearnings(client3, ctx) {
+async function extractMidSessionLearnings(_client, ctx) {
   const workspaceId = getActiveWorkspaceId();
   if (!workspaceId)
     return { count: 0, entityIds: [] };
-  const projectId = getActiveProjectId() || undefined;
+  const _projectId = getActiveProjectId() || undefined;
   const now = Date.now();
-  const entityIds = [];
+  const _entityIds = [];
   const history = sessionTaskHistory.get(ctx.cardId);
   if (ctx.currentTask) {
     const previousTask = history?.lastTask || "";
@@ -26911,81 +27129,22 @@ async function extractMidSessionLearnings(client3, ctx) {
     }
   }
   if (ctx.status === "blocked" && ctx.blockers?.length) {
-    for (const blocker of ctx.blockers) {
-      try {
-        const result = await client3.createMemoryEntity({
-          workspace_id: workspaceId,
-          project_id: projectId,
-          type: "error",
-          scope: "project",
-          memory_tier: "draft",
-          title: `Blocker (mid-session): ${blocker.slice(0, 100)}`,
-          content: `Encountered while working on "${ctx.cardTitle}":
-
-${blocker}
-
-Agent: ${ctx.agentName}
-Progress: ${ctx.progressPercent ?? "unknown"}%`,
-          confidence: 0.5,
-          tags: ["auto-extracted", "blocker", "mid-session"],
-          metadata: {
-            source: "mid_session",
-            card_id: ctx.cardId
-          },
-          agent_identifier: ctx.agentIdentifier
-        });
-        const entity = result.entity;
-        if (entity?.id)
-          entityIds.push(entity.id);
-      } catch {}
-    }
     sessionTaskHistory.set(ctx.cardId, {
       lastTask: ctx.currentTask || "",
       lastExtractionAt: now,
       steps: history?.steps || []
     });
-    return { count: entityIds.length, entityIds };
+    return { count: 0, entityIds: [] };
   }
   if (ctx.currentTask) {
-    const previousTask = history?.lastTask || "";
-    const similarity = levenshteinSimilarity(previousTask, ctx.currentTask);
-    if (similarity < 0.6 && previousTask.length > 0) {
-      try {
-        const result = await client3.createMemoryEntity({
-          workspace_id: workspaceId,
-          project_id: projectId,
-          type: "context",
-          scope: "project",
-          memory_tier: "draft",
-          title: `Task transition: ${ctx.cardTitle}`,
-          content: `Agent transitioned tasks on "${ctx.cardTitle}".
-
-Previous: ${previousTask}
-Current: ${ctx.currentTask}
-Progress: ${ctx.progressPercent ?? "unknown"}%`,
-          confidence: 0.5,
-          tags: ["auto-extracted", "task-transition", "mid-session"],
-          metadata: {
-            source: "mid_session",
-            card_id: ctx.cardId,
-            previous_task: previousTask,
-            current_task: ctx.currentTask
-          },
-          agent_identifier: ctx.agentIdentifier
-        });
-        const entity = result.entity;
-        if (entity?.id)
-          entityIds.push(entity.id);
-      } catch {}
-    }
     const currentHistory = sessionTaskHistory.get(ctx.cardId);
     sessionTaskHistory.set(ctx.cardId, {
       lastTask: ctx.currentTask,
-      lastExtractionAt: entityIds.length > 0 ? now : currentHistory?.lastExtractionAt ?? 0,
+      lastExtractionAt: currentHistory?.lastExtractionAt ?? 0,
       steps: currentHistory?.steps || []
     });
   }
-  return { count: entityIds.length, entityIds };
+  return { count: 0, entityIds: [] };
 }
 function clearMidSessionTracking(cardId) {
   sessionTaskHistory.delete(cardId);
@@ -27169,49 +27328,60 @@ async function extractLearnings(client3, session) {
 Related: ${relatedEntityTitles.map((t) => `[[${t}]]`).join(", ")}` : "";
   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}":
+      if (blocker.length < 80)
+        continue;
+      let isDuplicate = false;
+      try {
+        const similar = await findSimilarEntities(client3, blocker.slice(0, 200), blocker, workspaceId, { projectId, limit: 3, minRrfScore: 0.05 });
+        isDuplicate = similar.some((e) => e.type === "error" && (e.rrf_score ?? 0) >= 0.06);
+      } catch {}
+      if (!isDuplicate) {
+        learnings.push({
+          title: `Blocker: ${blocker.slice(0, 100)}`,
+          content: `Encountered while working on "${session.cardTitle}":
 
 ${blocker}
 
 Agent: ${session.agentName}
 Session status: ${session.status}`,
-        type: "error",
-        tier: "reference",
-        confidence: 0.7,
-        tags: ["auto-extracted", "blocker", ...session.cardLabels.slice(0, 3)],
-        metadata: {
-          source: "active_learning",
-          card_id: session.cardId
-        }
-      });
+          type: "error",
+          tier: "episode",
+          confidence: 0.6,
+          tags: [
+            "auto-extracted",
+            "blocker",
+            ...session.cardLabels.slice(0, 3)
+          ],
+          metadata: {
+            source: "active_learning",
+            card_id: session.cardId
+          }
+        });
+      }
     }
   }
-  const hasMeaningfulContent = (session.blockers?.length ?? 0) > 0 || session.status === "paused" || (session.cardSubtasks?.length ?? 0) > 0 && session.cardSubtasks?.some((s) => !s.done);
-  if (session.status === "completed" && hasMeaningfulContent) {
+  if (session.status === "paused" && (session.blockers?.length ?? 0) > 0) {
     const durationInfo = session.sessionDurationMs ? `
 Duration: ${Math.round(session.sessionDurationMs / 60000)} minutes` : "";
     learnings.push({
-      title: `Session: ${session.cardTitle}`,
+      title: `Paused: ${session.cardTitle}`,
       content: [
-        `Completed work on "${session.cardTitle}".`,
-        session.currentTask ? `Final task: ${session.currentTask}` : "",
+        `Paused work on "${session.cardTitle}".`,
+        session.currentTask ? `Last task: ${session.currentTask}` : "",
         session.progressPercent !== undefined ? `Progress: ${session.progressPercent}%` : "",
         durationInfo,
-        session.cardLabels.length > 0 ? `Labels: ${session.cardLabels.join(", ")}` : "",
-        session.blockers?.length ? `Blockers encountered: ${session.blockers.join("; ")}` : "",
+        session.blockers?.length ? `Blockers: ${session.blockers.join("; ")}` : "",
         `
 Agent: ${session.agentName}`,
         wikiLinksLine
       ].filter(Boolean).join(`
 `),
       type: "lesson",
-      tier: "episode",
-      confidence: 0.7,
+      tier: "draft",
+      confidence: 0.6,
       tags: [
         "auto-extracted",
-        "session-summary",
+        "session-paused",
         ...session.cardLabels.slice(0, 3)
       ],
       metadata: {
@@ -27220,35 +27390,14 @@ Agent: ${session.agentName}`,
       }
     });
   }
-  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}`,
-        wikiLinksLine
-      ].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 = [];
   const stepHistory = sessionTaskHistory.get(session.cardId);
-  const hasEnoughSteps = stepHistory && stepHistory.steps.length >= 2;
+  const MIN_PROCEDURE_STEPS = 5;
+  const MIN_PROCEDURE_DURATION_MS = 10 * 60 * 1000;
+  const hasEnoughSteps = stepHistory && stepHistory.steps.length >= MIN_PROCEDURE_STEPS;
+  const hasMinDuration = (session.sessionDurationMs ?? 0) >= MIN_PROCEDURE_DURATION_MS;
   const isSuccessful = session.status === "completed" && (session.progressPercent === undefined || session.progressPercent >= 85) && !session.blockers?.length;
-  if (isSuccessful && hasEnoughSteps) {
+  if (isSuccessful && hasEnoughSteps && hasMinDuration) {
     const procedureResult = await extractOrReinforceProcedure(client3, session, stepHistory.steps, workspaceId, projectId, wikiLinksLine);
     if (procedureResult) {
       if (procedureResult.mode === "created") {
@@ -27292,218 +27441,9 @@ Agent: ${session.agentName}`,
   if (createdPairs.length >= 2) {
     linkSessionEntities(client3, createdPairs, workspaceId, projectId).catch(() => {});
   }
-  if (entityIds.length > 0) {
-    detectAndCreatePatterns(client3, entityIds, session, workspaceId, projectId).catch(() => {});
-  }
-  if (createdPairs.length > 0) {
-    detectCausalPatterns(client3, createdPairs, session, workspaceId, projectId).catch(() => {});
-  }
   clearMidSessionTracking(session.cardId);
   return { count: entityIds.length, entityIds };
 }
-var PATTERN_THRESHOLD = 3;
-async function detectAndCreatePatterns(client3, newEntityIds, session, workspaceId, projectId) {
-  const patternEntityIds = [];
-  for (const newEntityId of newEntityIds) {
-    try {
-      const { entity: rawEntity } = await client3.getMemoryEntity(newEntityId);
-      const entity = rawEntity;
-      if (!entity?.type)
-        continue;
-      const similar = await findSimilarEntities(client3, entity.title, entity.content, workspaceId, { projectId, limit: 30, minRrfScore: 0.01 });
-      const existing = similar.filter((c) => !newEntityIds.includes(c.id) && c.type === entity.type);
-      if (existing.length < PATTERN_THRESHOLD)
-        continue;
-      const memberTitles = [
-        entity.title,
-        ...existing.slice(0, 4).map((e) => e.title)
-      ];
-      const patternTitle = `Pattern: recurring ${entity.type} (${existing.length + 1} instances)`;
-      const { entities: existingPatterns } = await client3.listMemoryEntities({
-        workspace_id: workspaceId,
-        project_id: projectId,
-        type: "pattern",
-        limit: 10
-      });
-      const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_type === entity.type);
-      let patternId = null;
-      if (matchingPattern) {
-        patternId = matchingPattern.id;
-        await client3.updateMemoryEntity(patternId, {
-          content: `Recurring pattern: ${entity.type} entities appearing ${existing.length + 1} times.
-
-Members:
-${memberTitles.map((t) => `- ${t}`).join(`
-`)}
-
-Last updated: ${new Date().toISOString()}`,
-          metadata: {
-            pattern_count: existing.length + 1,
-            pattern_type: entity.type,
-            last_updated: new Date().toISOString()
-          }
-        });
-      } else {
-        const result = await client3.createMemoryEntity({
-          workspace_id: workspaceId,
-          project_id: projectId,
-          type: "pattern",
-          scope: "project",
-          memory_tier: "reference",
-          title: patternTitle,
-          content: `Recurring pattern: ${entity.type} entities detected ${existing.length + 1} times.
-
-Members:
-${memberTitles.map((t) => `- ${t}`).join(`
-`)}`,
-          confidence: 0.75,
-          tags: ["auto-extracted", "pattern", entity.type],
-          metadata: {
-            source: "pattern_detection",
-            pattern_type: entity.type,
-            pattern_count: existing.length + 1
-          },
-          agent_identifier: session.agentIdentifier
-        });
-        const created = result.entity;
-        if (created?.id) {
-          patternId = created.id;
-          patternEntityIds.push(patternId);
-        }
-      }
-      if (!patternId)
-        continue;
-      const toLink = [newEntityId, ...existing.slice(0, 4).map((e) => e.id)];
-      for (const sourceId of toLink) {
-        try {
-          await client3.createMemoryRelation({
-            source_id: sourceId,
-            target_id: patternId,
-            relation_type: "part_of",
-            confidence: 0.75
-          });
-        } catch {}
-      }
-    } catch {}
-  }
-  return patternEntityIds;
-}
-var CAUSAL_PATTERN_THRESHOLD = 3;
-async function detectCausalPatterns(client3, createdPairs, session, workspaceId, projectId) {
-  const patternIds = [];
-  const errors3 = createdPairs.filter((p) => p.learning.type === "error");
-  const solutions = createdPairs.filter((p) => p.learning.type === "solution");
-  if (errors3.length === 0 || solutions.length === 0)
-    return patternIds;
-  for (const errorPair of errors3) {
-    try {
-      const similarErrors = await findSimilarEntities(client3, errorPair.learning.title, errorPair.learning.content, workspaceId, {
-        projectId,
-        limit: 20,
-        minRrfScore: 0.03,
-        excludeIds: createdPairs.map((p) => p.id),
-        type: "error"
-      });
-      const resolvedErrors = [];
-      for (const similar of similarErrors.slice(0, 10)) {
-        try {
-          const { outgoing } = await client3.getRelatedEntities(similar.id);
-          const resolvedByRel = outgoing.find((r) => r.relation_type === "resolved_by");
-          if (resolvedByRel) {
-            resolvedErrors.push({
-              errorId: similar.id,
-              errorTitle: similar.title,
-              solutionTitle: resolvedByRel.target_title || "unknown"
-            });
-          }
-        } catch {}
-      }
-      if (resolvedErrors.length + 1 < CAUSAL_PATTERN_THRESHOLD)
-        continue;
-      const { entities: existingPatterns } = await client3.listMemoryEntities({
-        workspace_id: workspaceId,
-        project_id: projectId,
-        type: "pattern",
-        limit: 10
-      });
-      const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_chain_type === "error_resolved_by_solution");
-      if (matchingPattern) {
-        await client3.updateMemoryEntity(matchingPattern.id, {
-          content: [
-            `Recurring error\u2192solution chain detected (${resolvedErrors.length + 1} instances).`,
-            "",
-            "## Error\u2192Solution Pairs",
-            `- ${errorPair.learning.title} \u2192 ${solutions[0].learning.title}`,
-            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} \u2192 ${r.solutionTitle}`),
-            "",
-            `Last updated: ${new Date().toISOString()}`
-          ].join(`
-`),
-          metadata: {
-            pattern_chain_type: "error_resolved_by_solution",
-            pattern_count: resolvedErrors.length + 1,
-            last_updated: new Date().toISOString()
-          }
-        });
-        for (const pair of [errorPair, solutions[0]]) {
-          try {
-            await client3.createMemoryRelation({
-              source_id: pair.id,
-              target_id: matchingPattern.id,
-              relation_type: "part_of",
-              confidence: 0.75
-            });
-          } catch {}
-        }
-      } else {
-        const result = await client3.createMemoryEntity({
-          workspace_id: workspaceId,
-          project_id: projectId,
-          type: "pattern",
-          scope: "project",
-          memory_tier: "reference",
-          title: `Pattern: recurring error\u2192solution chain (${resolvedErrors.length + 1} instances)`,
-          content: [
-            `Recurring error\u2192solution chain detected across ${resolvedErrors.length + 1} sessions.`,
-            "",
-            "## Error\u2192Solution Pairs",
-            `- ${errorPair.learning.title} \u2192 ${solutions[0].learning.title}`,
-            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} \u2192 ${r.solutionTitle}`)
-          ].join(`
-`),
-          confidence: 0.8,
-          tags: ["auto-extracted", "pattern", "causal-chain"],
-          metadata: {
-            source: "causal_pattern_detection",
-            pattern_chain_type: "error_resolved_by_solution",
-            pattern_count: resolvedErrors.length + 1
-          },
-          agent_identifier: session.agentIdentifier
-        });
-        const created = result.entity;
-        if (created?.id) {
-          patternIds.push(created.id);
-          const memberIds = [
-            errorPair.id,
-            solutions[0].id,
-            ...resolvedErrors.slice(0, 4).map((r) => r.errorId)
-          ];
-          for (const memberId of memberIds) {
-            try {
-              await client3.createMemoryRelation({
-                source_id: memberId,
-                target_id: created.id,
-                relation_type: "part_of",
-                confidence: 0.75
-              });
-            } catch {}
-          }
-        }
-      }
-    } catch {}
-  }
-  return patternIds;
-}
 async function detectContradictions(client3, entityId, entityType, title, content, tags, workspaceId, projectId) {
   if (!CONTRADICTION_TYPES.has(entityType))
     return [];
@@ -27703,7 +27643,7 @@ async function autoEndSession(client3, cardId, status) {
 // src/consolidation.ts
 async function consolidateMemories(client3, workspaceId, projectId, options) {
   const dryRun = options?.dryRun !== false;
-  const minClusterSize = options?.minClusterSize ?? 2;
+  const minClusterSize = options?.minClusterSize ?? 3;
   const result = {
     consolidated: 0,
     clustersFound: 0,
@@ -27768,12 +27708,7 @@ async function consolidateMemories(client3, workspaceId, projectId, options) {
       result.clustersFound++;
       const mergedTitle = deriveClusterTitle(cluster, type);
       const memberTitles = cluster.map((e) => e.title);
-      const mergedContent = [
-        `Consolidated from ${cluster.length} ${type} memories:
-`,
-        ...cluster.map((e) => `- **${e.title}**: ${e.content.slice(0, 200)}`)
-      ].join(`
-`);
+      const mergedContent = synthesizeClusterContent(cluster, type);
       const maxConfidence = Math.max(...cluster.map((e) => e.confidence));
       const allTags = [...new Set(cluster.flatMap((e) => e.tags || []))];
       const detail = {
@@ -27835,6 +27770,60 @@ async function consolidateMemories(client3, workspaceId, projectId, options) {
   }
   return result;
 }
+function synthesizeClusterContent(cluster, type) {
+  const SKIP_PATTERNS = [
+    /^##\s/,
+    /^Agent:/,
+    /^Duration:/,
+    /^Labels:/,
+    /^Progress:/,
+    /^Session status:/,
+    /^Completed at/,
+    /^Final state:/,
+    /^Related:/,
+    /^When working on:/,
+    /^\d+\.\s+.+\(\d+%,\s*\+\d+%\)/,
+    /^Last updated:/,
+    /^Recurring pattern:/,
+    /^Consolidated from/
+  ];
+  const seenLines = new Set;
+  const knowledgeLines = [];
+  for (const entity of cluster) {
+    const lines = entity.content.split(`
+`).map((l) => l.trim());
+    for (const line of lines) {
+      if (!line || line.length < 20)
+        continue;
+      if (SKIP_PATTERNS.some((p) => p.test(line)))
+        continue;
+      const normalized = line.toLowerCase().replace(/[*_`#[\]]/g, "").trim();
+      if (seenLines.has(normalized))
+        continue;
+      seenLines.add(normalized);
+      knowledgeLines.push(line);
+    }
+  }
+  if (knowledgeLines.length === 0) {
+    return `${cluster.length} related ${type} entities consolidated. Original titles:
+${cluster.map((e) => `- ${e.title}`).join(`
+`)}`;
+  }
+  const MAX_CHARS = 1600;
+  const result = [
+    `Consolidated knowledge from ${cluster.length} ${type} entities:
+`
+  ];
+  let charCount = result[0].length;
+  for (const line of knowledgeLines) {
+    if (charCount + line.length + 3 > MAX_CHARS)
+      break;
+    result.push(`- ${line}`);
+    charCount += line.length + 3;
+  }
+  return result.join(`
+`);
+}
 function deriveClusterTitle(cluster, type) {
   const stopWords = new Set([
     "the",
@@ -27889,9 +27878,9 @@ function deriveClusterTitle(cluster, type) {
       wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
     }
   }
-  const topWords = [...wordCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([word]) => word);
-  const suffix = topWords.length > 0 ? topWords.join(", ") : "various";
-  return `Consolidated ${type}: ${suffix}`;
+  const topWords = [...wordCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4).map(([word]) => word[0].toUpperCase() + word.slice(1));
+  const suffix = topWords.length > 0 ? topWords.join(" / ") : "Various";
+  return `${type[0].toUpperCase() + type.slice(1)}: ${suffix}`;
 }
 
 // src/server.ts
@@ -27967,47 +27956,1000 @@ async function runLifecycleMaintenance(client3, workspaceId, projectId) {
   return result;
 }
 
-// src/server.ts
-var memorySessions = new Map;
-function initMemorySession(cardId, agentIdentifier, agentName) {
-  memorySessions.set(cardId, {
-    cardId,
-    agentIdentifier,
-    agentName,
-    memoryReadCount: 0,
-    pendingActions: [],
-    allActions: [],
-    dirty: false
-  });
-}
-function getMemorySession(cardId) {
-  return memorySessions.get(cardId);
-}
-function appendMemoryAction(cardId, action) {
-  const session = memorySessions.get(cardId);
-  if (!session)
-    return;
-  const truncated = action.length > 512 ? action.slice(0, 509) + "..." : action;
-  const entry = { action: truncated, ts: new Date().toISOString() };
-  session.pendingActions.push(entry);
-  session.dirty = true;
-}
-function incrementMemoryReads(cardId) {
-  const session = memorySessions.get(cardId);
-  if (!session)
-    return;
-  session.memoryReadCount++;
-  session.dirty = true;
+// src/memory-audit.ts
+init_dist();
+var EMBEDDINGS_MIGRATION_AT = Date.parse("2026-02-18T00:00:00Z");
+var MS_PER_DAY = 1000 * 60 * 60 * 24;
+var BATCH_SIZE = 100;
+var CONCURRENCY_LIMIT = 5;
+var BOILERPLATE_PATTERNS = [
+  /^todo:?$/i,
+  /^placeholder/i,
+  /^\.\.\.$/,
+  /^untitled/i,
+  /^(note|memo|draft)\s*\d*$/i,
+  /^task transition:/i
+];
+function isBoilerplate(title, content) {
+  const t = title.trim();
+  const c = content.trim();
+  if (c.length === 0)
+    return true;
+  for (const pat of BOILERPLATE_PATTERNS) {
+    if (pat.test(t))
+      return true;
+  }
+  return false;
 }
-async function flushMemoryActions(client3, cardId) {
-  const session = memorySessions.get(cardId);
-  if (!session || !session.dirty)
-    return;
+function scoreEntity(entity, relationCount, archiveBelow, deleteBelow, staleDraftAgeDays) {
+  const now = Date.now();
+  const ageDays = (now - Date.parse(entity.created_at)) / MS_PER_DAY;
+  const effectiveLastAccess = entity.last_accessed_at ?? entity.created_at;
+  const lifecycle2 = evaluateLifecycle({
+    memory_tier: entity.memory_tier,
+    confidence: entity.confidence,
+    access_count: entity.access_count,
+    last_accessed_at: effectiveLastAccess,
+    created_at: entity.created_at
+  });
+  const reasons = [];
+  const legacyReasons = [];
+  const confidence = Math.max(0, Math.min(1, entity.confidence)) * 25;
+  const decay = Math.max(0, Math.min(1, lifecycle2.decay.score)) * 20;
+  if (lifecycle2.decay.score < 0.2)
+    reasons.push(`decay score ${lifecycle2.decay.score.toFixed(2)}`);
+  const hasEmbedding = entity.embedding != null;
+  const hasTags = (entity.tags?.length || 0) >= 1;
+  const hasRelations = relationCount > 0;
+  let structural = 0;
+  if (hasEmbedding)
+    structural += 6;
+  if (hasTags)
+    structural += 4;
+  if (hasRelations)
+    structural += 5;
+  if (!hasEmbedding)
+    reasons.push("no embedding");
+  if (!hasTags)
+    reasons.push("no tags");
+  if (!hasRelations)
+    reasons.push("no relations");
+  let content = 0;
+  const contentLen = entity.content?.length || 0;
+  const boilerplate = isBoilerplate(entity.title, entity.content);
+  if (boilerplate) {
+    reasons.push("boilerplate title/content");
+  } else {
+    if (contentLen >= 80)
+      content += 8;
+    const titleOk = entity.title.trim().length >= 4 && !/^(untitled|draft|note)\b/i.test(entity.title.trim());
+    if (titleOk)
+      content += 4;
+    content += 3;
+    if (contentLen < 80)
+      reasons.push(`thin content (${contentLen} chars)`);
+  }
+  let tierAgeFit = 15;
+  if (entity.memory_tier === "draft" && ageDays > 60 && !entity.promoted_from_id) {
+    tierAgeFit = 0;
+    reasons.push("stuck draft >60d never promoted");
+  } else if (entity.memory_tier === "draft" && (entity.access_count || 0) === 0 && ageDays > 2) {
+    tierAgeFit = 5;
+    reasons.push("draft >2d with zero access");
+  }
+  if (entity.promoted_from_id) {
+    tierAgeFit = Math.min(15, tierAgeFit + 5);
+  }
+  const access = Math.min(10, Math.log10((entity.access_count || 0) + 1) * 5);
+  if (entity.access_count === 0 && ageDays > 14)
+    reasons.push("never accessed");
+  const raw2 = confidence + decay + structural + content + tierAgeFit + access;
+  const score = Math.round(Math.max(0, Math.min(100, raw2)));
+  let legacy = false;
+  if (entity.confidence === 1 && entity.access_count === 0 && ageDays > 30) {
+    legacy = true;
+    legacyReasons.push("default confidence never validated");
+  }
+  if (!hasEmbedding && Date.parse(entity.created_at) < EMBEDDINGS_MIGRATION_AT) {
+    legacy = true;
+    legacyReasons.push("pre-embeddings migration");
+  }
+  if (entity.memory_tier === "draft" && ageDays > 60 && !entity.promoted_from_id) {
+    legacy = true;
+    legacyReasons.push("stuck draft");
+  }
+  if (!hasTags && !hasRelations) {
+    legacy = true;
+    legacyReasons.push("no graph presence");
+  }
+  let bucket;
+  if (score < deleteBelow)
+    bucket = "delete";
+  else if (score < archiveBelow)
+    bucket = "archive";
+  else if (score < 70)
+    bucket = "review";
+  else
+    bucket = "keep";
+  const staleDraft = entity.memory_tier === "draft" && (entity.access_count || 0) === 0 && ageDays > staleDraftAgeDays;
+  return {
+    id: entity.id,
+    title: entity.title,
+    type: entity.type,
+    tier: entity.memory_tier,
+    ageDays: Math.round(ageDays),
+    score,
+    bucket,
+    reasons,
+    legacy,
+    legacyReasons,
+    staleDraft,
+    subScores: {
+      confidence: Math.round(confidence),
+      decay: Math.round(decay),
+      structural,
+      content,
+      tierAgeFit,
+      access: Math.round(access)
+    }
+  };
+}
+async function runMemoryAudit(client3, workspaceId, projectId, options) {
+  const dryRun = options?.dryRun !== false;
+  const archiveBelow = options?.archiveBelow ?? 40;
+  const deleteBelow = options?.deleteBelow ?? 20;
+  const limit = options?.limit ?? 500;
+  const staleDraftAgeDays = options?.staleDraftAgeDays ?? 7;
+  const report = {
+    success: true,
+    dryRun,
+    timestamp: new Date().toISOString(),
+    workspace: { id: workspaceId, projectId },
+    summary: {
+      totalEntities: 0,
+      scanned: 0,
+      keep: 0,
+      review: 0,
+      archive: 0,
+      delete: 0,
+      legacyCount: 0,
+      staleDraftCount: 0
+    },
+    actionsTaken: { flaggedReview: 0, archived: 0, deleted: 0 },
+    distribution: { "0-20": 0, "20-40": 0, "40-70": 0, "70-100": 0 },
+    legacyBreakdown: {
+      defaultConfidence: 0,
+      missingEmbedding: 0,
+      stuckDraft: 0,
+      noGraphPresence: 0
+    },
+    lowest: [],
+    staleDrafts: [],
+    errors: [],
+    healthReport: ""
+  };
+  const entities = [];
+  let offset = 0;
   try {
-    if (session.memoryReadCount > 0) {
-      session.allActions.push({
-        action: `Recalled ${session.memoryReadCount} memor${session.memoryReadCount === 1 ? "y" : "ies"}`,
-        ts: new Date().toISOString()
+    while (entities.length < limit) {
+      const pageSize = Math.min(BATCH_SIZE, limit - entities.length);
+      const result = await client3.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: pageSize,
+        offset
+      });
+      const page = result.entities || [];
+      if (page.length === 0)
+        break;
+      entities.push(...page);
+      if (page.length < pageSize)
+        break;
+      offset += pageSize;
+    }
+  } catch (err) {
+    report.errors.push({
+      step: "fetch",
+      message: `Failed to fetch entities: ${err.message}`
+    });
+    report.success = false;
+    report.healthReport = renderReport(report);
+    return report;
+  }
+  report.summary.totalEntities = entities.length;
+  const relationCounts = new Map;
+  for (let i = 0;i < entities.length; i += CONCURRENCY_LIMIT) {
+    const batch = entities.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(batch.map(async (e) => {
+      const related = await client3.getRelatedEntities(e.id);
+      const count = (related.outgoing?.length || 0) + (related.incoming?.length || 0);
+      return { id: e.id, count };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        relationCounts.set(r.value.id, r.value.count);
+      }
+    }
+  }
+  const audits = [];
+  for (const entity of entities) {
+    const relCount = relationCounts.get(entity.id) ?? 0;
+    const audit = scoreEntity(entity, relCount, archiveBelow, deleteBelow, staleDraftAgeDays);
+    audits.push(audit);
+    report.summary.scanned++;
+    report.summary[audit.bucket]++;
+    if (audit.legacy)
+      report.summary.legacyCount++;
+    if (audit.staleDraft)
+      report.summary.staleDraftCount++;
+    if (audit.score < 20)
+      report.distribution["0-20"]++;
+    else if (audit.score < 40)
+      report.distribution["20-40"]++;
+    else if (audit.score < 70)
+      report.distribution["40-70"]++;
+    else
+      report.distribution["70-100"]++;
+    for (const reason of audit.legacyReasons) {
+      if (reason.startsWith("default confidence"))
+        report.legacyBreakdown.defaultConfidence++;
+      else if (reason.startsWith("pre-embeddings"))
+        report.legacyBreakdown.missingEmbedding++;
+      else if (reason.startsWith("stuck draft"))
+        report.legacyBreakdown.stuckDraft++;
+      else if (reason.startsWith("no graph"))
+        report.legacyBreakdown.noGraphPresence++;
+    }
+  }
+  report.lowest = [...audits].sort((a, b) => a.score - b.score).slice(0, 10);
+  report.staleDrafts = audits.filter((a) => a.staleDraft).sort((a, b) => b.ageDays - a.ageDays);
+  if (!dryRun) {
+    for (const audit of audits) {
+      try {
+        if (audit.bucket === "delete") {
+          await client3.deleteMemoryEntity(audit.id);
+          report.actionsTaken.deleted++;
+        } else if (audit.bucket === "archive") {
+          await client3.updateMemoryEntity(audit.id, {
+            confidence: 0.25,
+            metadata: {
+              audit_archived_at: new Date().toISOString(),
+              audit_score: audit.score,
+              audit_reasons: audit.reasons
+            }
+          });
+          report.actionsTaken.archived++;
+        } else if (audit.bucket === "review") {
+          await client3.updateMemoryEntity(audit.id, {
+            metadata: {
+              needs_review: true,
+              audit_score: audit.score,
+              audit_reasons: audit.reasons,
+              audit_at: new Date().toISOString()
+            }
+          });
+          report.actionsTaken.flaggedReview++;
+        }
+      } catch (err) {
+        report.errors.push({
+          entityId: audit.id,
+          step: audit.bucket,
+          message: err.message
+        });
+      }
+    }
+  }
+  report.healthReport = renderReport(report);
+  return report;
+}
+function renderReport(report) {
+  const mode = report.dryRun ? "Dry Run (preview)" : "Executed";
+  const s = report.summary;
+  const lines = [
+    `# Memory Quality Audit
+`,
+    `**Mode:** ${mode} | **Scanned:** ${s.scanned}/${s.totalEntities} | **Legacy:** ${s.legacyCount} | **Stale drafts:** ${s.staleDraftCount}`,
+    "",
+    "## Distribution",
+    `- 70-100 (keep):    ${report.distribution["70-100"]}`,
+    `- 40-69  (review):  ${report.distribution["40-70"]}`,
+    `- 20-39  (archive): ${report.distribution["20-40"]}`,
+    `- 0-19   (delete):  ${report.distribution["0-20"]}`,
+    "",
+    "## Buckets",
+    `- **Keep:**    ${s.keep}`,
+    `- **Review:**  ${s.review}${!report.dryRun ? ` (flagged ${report.actionsTaken.flaggedReview})` : ""}`,
+    `- **Archive:** ${s.archive}${!report.dryRun ? ` (archived ${report.actionsTaken.archived})` : ""}`,
+    `- **Delete:**  ${s.delete}${!report.dryRun ? ` (deleted ${report.actionsTaken.deleted})` : ""}`,
+    ""
+  ];
+  const l = report.legacyBreakdown;
+  if (s.legacyCount > 0) {
+    lines.push("## Legacy Breakdown");
+    lines.push(`- Default confidence, never validated: ${l.defaultConfidence}`);
+    lines.push(`- Pre-embeddings migration:            ${l.missingEmbedding}`);
+    lines.push(`- Stuck drafts (>60d, no promotion):   ${l.stuckDraft}`);
+    lines.push(`- No tags + no relations:              ${l.noGraphPresence}`);
+    lines.push("");
+  }
+  if (report.staleDrafts.length > 0) {
+    lines.push("## Stale Drafts (promote-or-drop candidates)");
+    lines.push("Filter: `tier=draft AND access=0 AND age>threshold`");
+    lines.push("| Age | Score | Title |");
+    lines.push("|-----|-------|-------|");
+    for (const a of report.staleDrafts.slice(0, 20)) {
+      const titleTrunc = a.title.length > 50 ? `${a.title.slice(0, 47)}...` : a.title;
+      lines.push(`| ${a.ageDays}d | ${a.score} | ${titleTrunc} |`);
+    }
+    lines.push("");
+  }
+  if (report.lowest.length > 0) {
+    lines.push("## Lowest-Scoring (top 10)");
+    lines.push("| Score | Bucket | Tier | Age | Title | Reasons |");
+    lines.push("|-------|--------|------|-----|-------|---------|");
+    for (const a of report.lowest) {
+      const reasonStr = a.reasons.slice(0, 3).join(", ") || "\u2014";
+      const titleTrunc = a.title.length > 40 ? `${a.title.slice(0, 37)}...` : a.title;
+      lines.push(`| ${a.score} | ${a.bucket} | ${a.tier} | ${a.ageDays}d | ${titleTrunc} | ${reasonStr} |`);
+    }
+    lines.push("");
+  }
+  if (report.errors.length > 0) {
+    lines.push("## Errors");
+    for (const e of report.errors.slice(0, 10)) {
+      lines.push(`- **${e.step}${e.entityId ? ` ${e.entityId}` : ""}:** ${e.message}`);
+    }
+    lines.push("");
+  }
+  if (report.dryRun) {
+    lines.push("---");
+    lines.push("*Run with `dryRun: false` to flag review entries, archive low-quality memories, and delete worst offenders.*");
+  }
+  return lines.join(`
+`);
+}
+
+// src/memory-cleanup.ts
+init_dist();
+var ALL_STEPS = [
+  "prune",
+  "consolidate",
+  "orphans",
+  "duplicates",
+  "backfill",
+  "audit"
+];
+var MS_PER_DAY2 = 1000 * 60 * 60 * 24;
+var MAX_ENTITIES_FETCH = 200;
+var DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+var CONCURRENCY_LIMIT2 = 5;
+async function runMemoryCleanup(client3, workspaceId, projectId, options) {
+  const dryRun = options?.dryRun !== false;
+  const steps = options?.steps ?? ALL_STEPS;
+  const maxAgeDays = options?.maxAgeDays ?? 30;
+  const minClusterSize = options?.minClusterSize ?? 3;
+  const orphanAgeDays = options?.orphanAgeDays ?? 14;
+  const report = {
+    success: true,
+    dryRun,
+    timestamp: new Date().toISOString(),
+    workspace: { id: workspaceId, projectId },
+    summary: { totalEntities: 0, issuesFound: 0, actionsTaken: 0 },
+    steps: {},
+    errors: [],
+    healthReport: ""
+  };
+  let entities = [];
+  try {
+    const listResult = await client3.listMemoryEntities({
+      workspace_id: workspaceId,
+      project_id: projectId,
+      limit: MAX_ENTITIES_FETCH
+    });
+    entities = listResult.entities || [];
+    report.summary.totalEntities = entities.length;
+  } catch (err) {
+    report.errors.push({
+      step: "init",
+      message: `Failed to fetch entities: ${err.message}`
+    });
+    report.success = false;
+    report.healthReport = generateHealthReport(report);
+    return report;
+  }
+  if (steps.includes("prune")) {
+    try {
+      report.steps.prune = runPruneStep(entities, maxAgeDays);
+      if (!dryRun) {
+        for (const item of report.steps.prune.items) {
+          try {
+            await client3.deleteMemoryEntity(item.id);
+            report.steps.prune.pruned++;
+          } catch (err) {
+            report.errors.push({
+              step: "prune",
+              message: `Failed to delete ${item.id}: ${err.message}`
+            });
+          }
+        }
+        report.summary.actionsTaken += report.steps.prune.pruned;
+      }
+      report.summary.issuesFound += report.steps.prune.staleDraftsFound;
+    } catch (err) {
+      report.errors.push({
+        step: "prune",
+        message: err.message
+      });
+    }
+  }
+  if (steps.includes("consolidate")) {
+    try {
+      const result = await consolidateMemories(client3, workspaceId, projectId, {
+        dryRun,
+        minClusterSize
+      });
+      report.steps.consolidate = {
+        clustersFound: result.clustersFound,
+        entitiesProcessed: result.entitiesProcessed,
+        consolidated: result.consolidated,
+        details: result.details
+      };
+      report.summary.issuesFound += result.clustersFound;
+      if (!dryRun)
+        report.summary.actionsTaken += result.consolidated;
+    } catch (err) {
+      report.errors.push({
+        step: "consolidate",
+        message: err.message
+      });
+    }
+  }
+  if (steps.includes("orphans")) {
+    try {
+      report.steps.orphans = await runOrphanStep(client3, entities, orphanAgeDays);
+      if (!dryRun) {
+        for (const item of report.steps.orphans.items) {
+          try {
+            await client3.deleteMemoryEntity(item.id);
+            report.steps.orphans.removed++;
+          } catch (err) {
+            report.errors.push({
+              step: "orphans",
+              message: `Failed to delete ${item.id}: ${err.message}`
+            });
+          }
+        }
+        report.summary.actionsTaken += report.steps.orphans.removed;
+      }
+      report.summary.issuesFound += report.steps.orphans.orphansFound;
+    } catch (err) {
+      report.errors.push({
+        step: "orphans",
+        message: err.message
+      });
+    }
+  }
+  if (steps.includes("duplicates")) {
+    try {
+      report.steps.duplicates = await runDuplicateStep(client3, entities, workspaceId, projectId);
+      if (!dryRun) {
+        for (const pair of report.steps.duplicates.pairs) {
+          try {
+            await client3.deleteMemoryEntity(pair.removeId);
+            report.steps.duplicates.resolved++;
+          } catch (err) {
+            report.errors.push({
+              step: "duplicates",
+              message: `Failed to delete ${pair.removeId}: ${err.message}`
+            });
+          }
+        }
+        report.summary.actionsTaken += report.steps.duplicates.resolved;
+      }
+      report.summary.issuesFound += report.steps.duplicates.duplicatePairsFound;
+    } catch (err) {
+      report.errors.push({
+        step: "duplicates",
+        message: err.message
+      });
+    }
+  }
+  if (steps.includes("backfill")) {
+    try {
+      if (dryRun) {
+        report.steps.backfill = {
+          processed: 0,
+          remaining: -1,
+          errors: []
+        };
+      } else {
+        const result = await client3.backfillEmbeddings(workspaceId);
+        report.steps.backfill = {
+          processed: result.processed,
+          remaining: result.remaining,
+          errors: result.errors || []
+        };
+        report.summary.actionsTaken += result.processed;
+      }
+    } catch (err) {
+      report.errors.push({
+        step: "backfill",
+        message: err.message
+      });
+    }
+  }
+  if (steps.includes("audit")) {
+    try {
+      const auditReport = await runMemoryAudit(client3, workspaceId, projectId, {
+        dryRun,
+        archiveBelow: options?.auditArchiveBelow,
+        deleteBelow: options?.auditDeleteBelow
+      });
+      const low = auditReport.lowest.length > 0 ? auditReport.lowest[0].score : null;
+      report.steps.audit = {
+        scanned: auditReport.summary.scanned,
+        legacyCount: auditReport.summary.legacyCount,
+        buckets: {
+          keep: auditReport.summary.keep,
+          review: auditReport.summary.review,
+          archive: auditReport.summary.archive,
+          delete: auditReport.summary.delete
+        },
+        actions: auditReport.actionsTaken,
+        lowestScore: low,
+        report: auditReport
+      };
+      report.summary.issuesFound += auditReport.summary.review + auditReport.summary.archive + auditReport.summary.delete;
+      if (!dryRun) {
+        report.summary.actionsTaken += auditReport.actionsTaken.flaggedReview + auditReport.actionsTaken.archived + auditReport.actionsTaken.deleted;
+      }
+      for (const err of auditReport.errors) {
+        report.errors.push({
+          step: `audit:${err.step}`,
+          message: err.entityId ? `${err.entityId}: ${err.message}` : err.message
+        });
+      }
+    } catch (err) {
+      report.errors.push({
+        step: "audit",
+        message: err.message
+      });
+    }
+  }
+  report.healthReport = generateHealthReport(report);
+  return report;
+}
+function runPruneStep(entities, maxAgeDays) {
+  const now = Date.now();
+  const drafts = entities.filter((e) => e.memory_tier === "draft");
+  const stale = [];
+  for (const entity of drafts) {
+    const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY2;
+    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
+    });
+  }
+  return { staleDraftsFound: stale.length, pruned: 0, items: stale };
+}
+async function runOrphanStep(client3, entities, orphanAgeDays) {
+  const now = Date.now();
+  const result = { orphansFound: 0, removed: 0, items: [] };
+  const candidates = entities.filter((e) => {
+    if (e.memory_tier === "reference")
+      return false;
+    if (e.access_count >= 2)
+      return false;
+    const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY2;
+    return ageDays >= orphanAgeDays;
+  });
+  for (let i = 0;i < candidates.length; i += CONCURRENCY_LIMIT2) {
+    const batch = candidates.slice(i, i + CONCURRENCY_LIMIT2);
+    const results = await Promise.allSettled(batch.map(async (entity) => {
+      const related = await client3.getRelatedEntities(entity.id);
+      const totalRelations = (related.outgoing?.length || 0) + (related.incoming?.length || 0);
+      if (totalRelations > 0)
+        return null;
+      const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY2;
+      return {
+        id: entity.id,
+        title: entity.title,
+        type: entity.type,
+        tier: entity.memory_tier,
+        ageDays: Math.round(ageDays),
+        accessCount: entity.access_count
+      };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled" && r.value) {
+        result.items.push(r.value);
+        result.orphansFound++;
+      }
+    }
+  }
+  return result;
+}
+async function runDuplicateStep(client3, entities, workspaceId, projectId) {
+  const result = {
+    duplicatePairsFound: 0,
+    resolved: 0,
+    pairs: []
+  };
+  const seenPairs = new Set;
+  const flaggedForRemoval = new Set;
+  const entityMap = new Map(entities.map((e) => [e.id, e]));
+  const similarityMap = new Map;
+  for (let i = 0;i < entities.length; i += CONCURRENCY_LIMIT2) {
+    const batch = entities.slice(i, i + CONCURRENCY_LIMIT2);
+    const results = await Promise.allSettled(batch.map(async (entity) => {
+      const similar = await findSimilarEntities(client3, entity.title, entity.content, workspaceId, { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] });
+      return { entityId: entity.id, similar };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        similarityMap.set(r.value.entityId, r.value.similar);
+      }
+    }
+  }
+  for (const entity of entities) {
+    if (flaggedForRemoval.has(entity.id))
+      continue;
+    const similar = similarityMap.get(entity.id) || [];
+    for (const match2 of similar) {
+      if (flaggedForRemoval.has(match2.id))
+        continue;
+      const pairKey = [entity.id, match2.id].sort().join(":");
+      if (seenPairs.has(pairKey))
+        continue;
+      seenPairs.add(pairKey);
+      const sim = titleSimilarity(entity.title, match2.title);
+      if (sim < DUPLICATE_SIMILARITY_THRESHOLD)
+        continue;
+      const entityScore = entityQualityScore(entity);
+      const matchEntity = entityMap.get(match2.id);
+      const matchScore = matchEntity ? entityQualityScore(matchEntity) : match2.confidence;
+      const [keep, remove] = entityScore >= matchScore ? [entity, { id: match2.id, title: match2.title }] : [{ id: match2.id, title: match2.title }, entity];
+      flaggedForRemoval.add(remove.id);
+      result.pairs.push({
+        keepId: keep.id,
+        keepTitle: keep.title,
+        removeId: remove.id,
+        removeTitle: remove.title,
+        similarity: Math.round(sim * 100) / 100
+      });
+      result.duplicatePairsFound++;
+    }
+  }
+  return result;
+}
+var TIER_WEIGHTS2 = {
+  reference: 3,
+  episode: 2,
+  draft: 1
+};
+function entityQualityScore(entity) {
+  return entity.confidence + (TIER_WEIGHTS2[entity.memory_tier] || 0) + Math.min(entity.access_count, 10) * 0.1;
+}
+function titleSimilarity(a, b) {
+  const na = a.toLowerCase().trim();
+  const nb = b.toLowerCase().trim();
+  if (na === nb)
+    return 1;
+  const wordsA = new Set(na.split(/\W+/).filter(Boolean));
+  const wordsB = new Set(nb.split(/\W+/).filter(Boolean));
+  if (wordsA.size === 0 || wordsB.size === 0)
+    return 0;
+  let intersection3 = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w))
+      intersection3++;
+  }
+  const union3 = wordsA.size + wordsB.size - intersection3;
+  return union3 > 0 ? intersection3 / union3 : 0;
+}
+function generateHealthReport(report) {
+  const mode = report.dryRun ? "Dry Run (preview)" : "Executed";
+  const lines = [
+    `# Memory Health Report
+`,
+    `**Mode:** ${mode} | **Entities:** ${report.summary.totalEntities} | **Issues:** ${report.summary.issuesFound} | **Actions:** ${report.summary.actionsTaken}`,
+    ""
+  ];
+  if (report.summary.totalEntities >= MAX_ENTITIES_FETCH) {
+    lines.push(`> **Note:** Entity count hit the ${MAX_ENTITIES_FETCH} fetch limit. Some entities may not have been analyzed.
+`);
+  }
+  if (report.steps.prune) {
+    const p = report.steps.prune;
+    lines.push("## Stale Drafts");
+    if (p.staleDraftsFound === 0) {
+      lines.push(`No stale drafts found.
+`);
+    } else {
+      lines.push(`Found **${p.staleDraftsFound}** stale drafts${!report.dryRun ? ` (pruned ${p.pruned})` : ""}:`);
+      lines.push("| Title | Age | Decay |");
+      lines.push("|-------|-----|-------|");
+      for (const item of p.items.slice(0, 20)) {
+        lines.push(`| ${item.title} | ${item.ageDays}d | ${item.decayScore} |`);
+      }
+      lines.push("");
+    }
+  }
+  if (report.steps.consolidate) {
+    const c = report.steps.consolidate;
+    lines.push("## Consolidation");
+    if (c.clustersFound === 0) {
+      lines.push(`Scanned ${c.entitiesProcessed} draft/episode entities \u2014 no clusters found.
+`);
+    } else {
+      lines.push(`Found **${c.clustersFound}** clusters across ${c.entitiesProcessed} entities:`);
+      for (const d of c.details.slice(0, 10)) {
+        lines.push(`- **${d.mergedTitle}** \u2014 ${d.clusterSize} entities`);
+      }
+      lines.push("");
+    }
+  }
+  if (report.steps.orphans) {
+    const o = report.steps.orphans;
+    lines.push("## Orphaned Entities");
+    if (o.orphansFound === 0) {
+      lines.push(`No orphans found.
+`);
+    } else {
+      lines.push(`Found **${o.orphansFound}** orphans${!report.dryRun ? ` (removed ${o.removed})` : ""}:`);
+      lines.push("| Title | Type | Tier | Age | Accesses |");
+      lines.push("|-------|------|------|-----|----------|");
+      for (const item of o.items.slice(0, 20)) {
+        lines.push(`| ${item.title} | ${item.type} | ${item.tier} | ${item.ageDays}d | ${item.accessCount} |`);
+      }
+      lines.push("");
+    }
+  }
+  if (report.steps.duplicates) {
+    const d = report.steps.duplicates;
+    lines.push("## Near-Duplicates");
+    if (d.duplicatePairsFound === 0) {
+      lines.push(`No duplicates found.
+`);
+    } else {
+      lines.push(`Found **${d.duplicatePairsFound}** duplicate pairs${!report.dryRun ? ` (resolved ${d.resolved})` : ""}:`);
+      for (const pair of d.pairs.slice(0, 20)) {
+        lines.push(`- "${pair.keepTitle}" ~ "${pair.removeTitle}" (${Math.round(pair.similarity * 100)}% similar, keep first)`);
+      }
+      lines.push("");
+    }
+  }
+  if (report.steps.backfill) {
+    const b = report.steps.backfill;
+    lines.push("## Embedding Coverage");
+    if (report.dryRun) {
+      lines.push("Backfill will run when executed with `dryRun: false`.\n");
+    } else if (b.remaining === 0) {
+      lines.push(`All embeddings up to date (processed ${b.processed}).
+`);
+    } else {
+      lines.push(`Processed ${b.processed} entities. ${b.remaining} still need embeddings.
+`);
+    }
+  }
+  if (report.steps.audit) {
+    const a = report.steps.audit;
+    lines.push("## Quality Audit");
+    lines.push(`Scanned ${a.scanned} entities. Legacy signals on ${a.legacyCount}.`);
+    lines.push(`Buckets \u2014 keep: ${a.buckets.keep}, review: ${a.buckets.review}, archive: ${a.buckets.archive}, delete: ${a.buckets.delete}.`);
+    if (!report.dryRun) {
+      lines.push(`Actions \u2014 flagged: ${a.actions.flaggedReview}, archived: ${a.actions.archived}, deleted: ${a.actions.deleted}.`);
+    }
+    if (a.report.lowest.length > 0) {
+      const worst = a.report.lowest[0];
+      lines.push(`Lowest score: **${worst.score}** \u2014 "${worst.title}" (${worst.reasons.slice(0, 2).join(", ") || "\u2014"}).`);
+    }
+    lines.push("");
+  }
+  if (report.errors.length > 0) {
+    lines.push("## Errors");
+    for (const e of report.errors) {
+      lines.push(`- **${e.step}:** ${e.message}`);
+    }
+    lines.push("");
+  }
+  if (report.dryRun) {
+    lines.push("---\n*Run with `dryRun: false` to execute cleanup.*");
+  }
+  return lines.join(`
+`);
+}
+async function purgeMemories(client3, workspaceId, projectId, options) {
+  const dryRun = options.dryRun !== false;
+  const { filters } = options;
+  const hasFilter = filters.tier || filters.scope || filters.type || filters.olderThanDays !== undefined || filters.maxConfidence !== undefined || filters.tags && filters.tags.length > 0;
+  if (!hasFilter) {
+    throw new Error("At least one narrowing filter (tier, scope, type, olderThanDays, maxConfidence, tags) is required.");
+  }
+  const allMatches = [];
+  let offset = 0;
+  const pageSize = 100;
+  const now = Date.now();
+  while (true) {
+    const result = await client3.listMemoryEntities({
+      workspace_id: workspaceId,
+      project_id: projectId,
+      type: filters.type,
+      scope: filters.scope,
+      tags: filters.tags,
+      limit: pageSize,
+      offset
+    });
+    const entities = result.entities || [];
+    if (entities.length === 0)
+      break;
+    for (const entity of entities) {
+      if (filters.tier && entity.memory_tier !== filters.tier)
+        continue;
+      if (filters.maxConfidence !== undefined && entity.confidence > filters.maxConfidence)
+        continue;
+      if (filters.olderThanDays !== undefined) {
+        const ref = entity.last_accessed_at || entity.created_at;
+        const ageDays = (now - new Date(ref).getTime()) / MS_PER_DAY2;
+        if (ageDays < filters.olderThanDays)
+          continue;
+      }
+      allMatches.push(entity);
+    }
+    if (entities.length < pageSize)
+      break;
+    offset += pageSize;
+  }
+  const items = allMatches.map((e) => ({
+    id: e.id,
+    title: e.title,
+    type: e.type,
+    tier: e.memory_tier,
+    confidence: e.confidence,
+    ageDays: Math.round((now - new Date(e.last_accessed_at || e.created_at).getTime()) / MS_PER_DAY2)
+  }));
+  const errors3 = [];
+  let purged = 0;
+  if (!dryRun) {
+    for (let i = 0;i < allMatches.length; i += CONCURRENCY_LIMIT2) {
+      const batch = allMatches.slice(i, i + CONCURRENCY_LIMIT2);
+      const results = await Promise.allSettled(batch.map((e) => client3.deleteMemoryEntity(e.id)));
+      for (let j = 0;j < results.length; j++) {
+        if (results[j].status === "fulfilled") {
+          purged++;
+        } else {
+          errors3.push({
+            entityId: batch[j].id,
+            message: results[j].status === "rejected" ? String(results[j].reason) : "Unknown error"
+          });
+        }
+      }
+    }
+  }
+  return {
+    success: errors3.length === 0,
+    dryRun,
+    timestamp: new Date().toISOString(),
+    workspace: { id: workspaceId, projectId },
+    filters,
+    matched: allMatches.length,
+    purged: dryRun ? 0 : purged,
+    items,
+    errors: errors3
+  };
+}
+
+// src/onboard.ts
+async function onboardNewUser(params) {
+  const {
+    email: email3,
+    password,
+    fullName,
+    workspaceName = `${fullName}'s Workspace`,
+    projectName = "My First Board",
+    template = "kanban",
+    keyName = "mcp-agent",
+    apiUrl = getApiUrl()
+  } = params;
+  const signupResult = await signupUser(apiUrl, {
+    email: email3,
+    password,
+    full_name: fullName
+  });
+  const token = signupResult.session.access_token;
+  const workspaceResult = await requestWithBearer(apiUrl, token, "POST", "/workspaces", {
+    name: workspaceName
+  });
+  const projectResult = await requestWithBearer(apiUrl, token, "POST", "/projects", {
+    workspaceId: workspaceResult.workspace.id,
+    name: projectName,
+    template
+  });
+  const keyResult = await requestWithBearer(apiUrl, token, "POST", "/api-keys", {
+    name: keyName
+  });
+  return {
+    user: signupResult.user,
+    workspace: workspaceResult.workspace,
+    project: projectResult.project,
+    columns: projectResult.columns,
+    apiKey: {
+      rawKey: keyResult.rawKey,
+      prefix: keyResult.apiKey.prefix
+    }
+  };
+}
+
+// src/server.ts
+var memorySessions = new Map;
+function parseLabelList(raw2) {
+  if (raw2 === undefined || raw2 === null)
+    return;
+  if (Array.isArray(raw2)) {
+    const arr = raw2.filter((v) => typeof v === "string").map((v) => v.trim()).filter((v) => v.length > 0);
+    return arr.length ? arr : undefined;
+  }
+  if (typeof raw2 === "string") {
+    const trimmed = raw2.trim();
+    if (!trimmed)
+      return;
+    if (trimmed.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed) && parsed.every((x) => typeof x === "string")) {
+          const arr = parsed.map((v) => v.trim()).filter((v) => v.length > 0);
+          return arr.length ? arr : undefined;
+        }
+      } catch {}
+    }
+    return [trimmed];
+  }
+  return;
+}
+function initMemorySession(cardId, agentIdentifier, agentName) {
+  memorySessions.set(cardId, {
+    cardId,
+    agentIdentifier,
+    agentName,
+    memoryReadCount: 0,
+    pendingActions: [],
+    allActions: [],
+    dirty: false
+  });
+}
+function getMemorySession(cardId) {
+  return memorySessions.get(cardId);
+}
+function appendMemoryAction(cardId, action) {
+  const session = memorySessions.get(cardId);
+  if (!session)
+    return;
+  const truncated = action.length > 512 ? action.slice(0, 509) + "..." : action;
+  const entry = { action: truncated, ts: new Date().toISOString() };
+  session.pendingActions.push(entry);
+  session.dirty = true;
+}
+function incrementMemoryReads(cardId) {
+  const session = memorySessions.get(cardId);
+  if (!session)
+    return;
+  session.memoryReadCount++;
+  session.dirty = true;
+}
+async function flushMemoryActions(client3, cardId) {
+  const session = memorySessions.get(cardId);
+  if (!session || !session.dirty)
+    return;
+  try {
+    if (session.memoryReadCount > 0) {
+      session.allActions.push({
+        action: `Recalled ${session.memoryReadCount} memor${session.memoryReadCount === 1 ? "y" : "ies"}`,
+        ts: new Date().toISOString()
       });
       session.memoryReadCount = 0;
     }
@@ -28101,18 +29043,22 @@ var TOOLS = {
     }
   },
   harmony_move_card: {
-    description: "Move a card to a different column or position",
+    description: "Move a card to a different column or position. Provide either columnId (UUID) or columnName (e.g. 'Review', 'Done').",
     inputSchema: {
       type: "object",
       properties: {
         cardId: { type: "string", description: "Card ID to move" },
-        columnId: { type: "string", description: "Target column ID" },
+        columnId: { type: "string", description: "Target column ID (UUID)" },
+        columnName: {
+          type: "string",
+          description: "Target column name (e.g. 'To Do', 'In Progress', 'Review', 'Done'). Used if columnId is not provided."
+        },
         position: {
           type: "number",
           description: "Position in column (0-indexed)"
         }
       },
-      required: ["cardId", "columnId"]
+      required: ["cardId"]
     }
   },
   harmony_archive_card: {
@@ -28242,6 +29188,16 @@ var TOOLS = {
       required: ["name", "color"]
     }
   },
+  harmony_delete_label: {
+    description: "Delete a label from a project. Also removes it from any cards that reference it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        labelId: { type: "string", description: "Label ID to delete" }
+      },
+      required: ["labelId"]
+    }
+  },
   harmony_add_label_to_card: {
     description: "Add a label to a card. Provide labelId directly, or labelName to look up (or auto-create) the label by name.",
     inputSchema: {
@@ -28516,6 +29472,20 @@ var TOOLS = {
         estimatedMinutesRemaining: {
           type: "number",
           description: "Updated time estimate"
+        },
+        actions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              description: {
+                type: "string",
+                description: "What was done, e.g. 'Edited CardDetailSheet.tsx \u2014 added done toggle'"
+              }
+            },
+            required: ["description"]
+          },
+          description: "Actions performed since last update. Each becomes a visible activity log entry."
         }
       },
       required: ["cardId", "agentIdentifier", "agentName"]
@@ -29356,6 +30326,146 @@ var TOOLS = {
       },
       required: []
     }
+  },
+  harmony_cleanup_memories: {
+    description: "Run a unified memory cleanup: prune stale drafts, consolidate similar memories, detect orphans and duplicates, backfill embeddings, and optionally run a quality audit. Returns a health report. Dry-run by default \u2014 run with dryRun=false to execute.",
+    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 cleanup without executing changes (default: true)"
+        },
+        steps: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: [
+              "prune",
+              "consolidate",
+              "orphans",
+              "duplicates",
+              "backfill",
+              "audit"
+            ]
+          },
+          description: "Which cleanup steps to run (default: all). Options: prune, consolidate, orphans, duplicates, backfill, audit."
+        },
+        maxAgeDays: {
+          type: "number",
+          description: "Max age in days for stale draft pruning (default: 30)"
+        },
+        minClusterSize: {
+          type: "number",
+          description: "Min cluster size for consolidation (default: 3)"
+        },
+        orphanAgeDays: {
+          type: "number",
+          description: "Min age in days for orphan detection (default: 14)"
+        },
+        auditArchiveBelow: {
+          type: "number",
+          description: "Audit: archive entities scoring below this (default: 40)"
+        },
+        auditDeleteBelow: {
+          type: "number",
+          description: "Audit: delete entities scoring below this (default: 20)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_audit_memories: {
+    description: "Rate every memory against state-of-the-art quality standards (confidence, decay, structural completeness, content, tier-age fit, access). Flags legacy entities from before recent optimizations (default confidence, missing embeddings, stuck drafts). Buckets: keep (\u226570), review (40-69), archive (20-39), delete (<20). Dry-run by default.",
+    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 audit without flagging/archiving/deleting (default: true)"
+        },
+        archiveBelow: {
+          type: "number",
+          description: "Score threshold below which entities are archived (confidence set to 0.25). Default: 40"
+        },
+        deleteBelow: {
+          type: "number",
+          description: "Score threshold below which entities are hard-deleted. Default: 20. Set to 0 to never delete."
+        },
+        limit: {
+          type: "number",
+          description: "Max number of entities to audit (default: 500). Paginated fetch."
+        },
+        staleDraftAgeDays: {
+          type: "number",
+          description: "Age threshold (days) for the stale-draft filter: flags drafts with 0 accesses older than this. Reported separately from bucket scoring \u2014 surfaces promote-or-drop candidates the thresholds miss. Default: 7."
+        }
+      },
+      required: []
+    }
+  },
+  harmony_purge_memories: {
+    description: "Bulk-delete memory entities matching filters within a project. Requires at least one narrowing filter (tier, scope, type, olderThanDays, maxConfidence, tags). Dry-run by default \u2014 preview what would be deleted before executing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (required \u2014 purge is project-scoped). Falls back to active project context."
+        },
+        dryRun: {
+          type: "boolean",
+          description: "Preview what would be deleted without executing (default: true)"
+        },
+        tier: {
+          type: "string",
+          enum: ["draft", "episode", "reference"],
+          description: 'Filter by memory tier (e.g. "draft")'
+        },
+        scope: {
+          type: "string",
+          description: 'Filter by scope (e.g. "private", "project", "workspace")'
+        },
+        type: {
+          type: "string",
+          description: 'Filter by entity type (e.g. "error", "pattern", "lesson", "decision")'
+        },
+        olderThanDays: {
+          type: "number",
+          description: "Only include entities not accessed in at least this many days"
+        },
+        maxConfidence: {
+          type: "number",
+          description: "Only include entities with confidence at or below this value (e.g. 0.3 for low-confidence junk)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Only include entities matching these tags"
+        }
+      },
+      required: []
+    }
   }
 };
 var RESOURCES = [
@@ -29574,6 +30684,17 @@ function registerHandlers(server, deps) {
     throw new Error(`Unknown resource: ${uri}`);
   });
 }
+async function resolveColumnByName(client3, projectId, columnName) {
+  const board = await client3.getBoard(projectId, { summary: true });
+  const columns = board.columns;
+  const lower = columnName.toLowerCase();
+  const col = columns.find((c) => c.name.toLowerCase() === lower) || columns.find((c) => c.name.toLowerCase().includes(lower));
+  if (!col) {
+    const available = columns.map((c) => c.name).join(", ");
+    throw new Error(`Column "${columnName}" not found. Available columns: ${available}`);
+  }
+  return col;
+}
 async function handleToolCall(name, args, deps) {
   const unauthenticatedTools = ["harmony_signup", "harmony_onboard"];
   if (!unauthenticatedTools.includes(name) && !deps.isConfigured()) {
@@ -29623,16 +30744,29 @@ async function handleToolCall(name, args, deps) {
     }
     case "harmony_move_card": {
       const cardId = exports_external.string().uuid().parse(args.cardId);
-      const columnId = exports_external.string().uuid().parse(args.columnId);
       const position = args.position !== undefined ? exports_external.number().int().min(0).parse(args.position) : undefined;
+      let columnId;
+      let resolvedProjectId;
+      if (args.columnId) {
+        columnId = exports_external.string().uuid().parse(args.columnId);
+      } else if (args.columnName) {
+        const columnName = exports_external.string().parse(args.columnName);
+        const { card: cardForProject } = await client3.getCard(cardId);
+        resolvedProjectId = cardForProject?.project_id;
+        if (!resolvedProjectId)
+          throw new Error("Card has no project");
+        const col = await resolveColumnByName(client3, resolvedProjectId, columnName);
+        columnId = col.id;
+      } else {
+        throw new Error("Either columnId or columnName is required");
+      }
       const result = await client3.moveCard(cardId, columnId, position);
       let sessionEnded = false;
       try {
         const { card } = result;
-        if (card?.project_id) {
-          const board = await client3.getBoard(card.project_id, {
-            summary: true
-          });
+        const projectId = card?.project_id || resolvedProjectId;
+        if (projectId) {
+          const board = await client3.getBoard(projectId, { summary: true });
           const columns = board.columns;
           const destCol = columns.find((c) => c.id === columnId);
           const colName = destCol?.name?.toLowerCase() || "";
@@ -29717,6 +30851,11 @@ async function handleToolCall(name, args, deps) {
       const result = await client3.createLabel(projectId, { name: name2, color });
       return { success: true, ...result };
     }
+    case "harmony_delete_label": {
+      const labelId = exports_external.string().uuid().parse(args.labelId);
+      const result = await client3.deleteLabel(labelId);
+      return { success: true, ...result };
+    }
     case "harmony_add_label_to_card": {
       const cardId = exports_external.string().uuid().parse(args.cardId);
       let labelId = args.labelId ? exports_external.string().uuid().parse(args.labelId) : undefined;
@@ -29852,7 +30991,7 @@ async function handleToolCall(name, args, deps) {
       const agentIdentifier = exports_external.string().min(1).max(100).parse(args.agentIdentifier);
       const agentName = exports_external.string().min(1).max(100).parse(args.agentName);
       const moveToColumn = args.moveToColumn;
-      const addLabels = args.addLabels;
+      const addLabels = parseLabelList(args.addLabels);
       let movedTo = null;
       const labelsAdded = [];
       if (moveToColumn || addLabels?.length) {
@@ -29961,12 +31100,20 @@ async function handleToolCall(name, args, deps) {
       const agentIdentifier = exports_external.string().min(1).max(100).parse(args.agentIdentifier);
       const agentName = exports_external.string().min(1).max(100).parse(args.agentName);
       const progressPercent = args.progressPercent !== undefined ? exports_external.number().min(0).max(100).parse(args.progressPercent) : undefined;
-      const callerRecentActions = args.recentActions;
+      const callerActions = args.actions;
+      const now = new Date().toISOString();
+      const callerRecentActions = [
+        ...args.recentActions || [],
+        ...(callerActions || []).map((a) => ({
+          action: a.description,
+          ts: now
+        }))
+      ];
       const memSession = getMemorySession(cardId);
       let mergedRecentActions;
       if (memSession?.dirty) {
-        mergedRecentActions = mergeMemoryActionsInto(cardId, callerRecentActions || []);
-      } else if (callerRecentActions) {
+        mergedRecentActions = mergeMemoryActionsInto(cardId, callerRecentActions);
+      } else if (callerRecentActions.length > 0) {
         mergedRecentActions = callerRecentActions;
       }
       const result = await client3.updateAgentProgress(cardId, {
@@ -30004,27 +31151,21 @@ async function handleToolCall(name, args, deps) {
       const endProgressPercent = args.progressPercent !== undefined ? exports_external.number().min(0).max(100).parse(args.progressPercent) : undefined;
       await flushMemoryActions(client3, cardId);
       cleanupMemorySession(cardId);
-      const result = await client3.endAgentSession(cardId, {
-        status: sessionStatus,
-        progressPercent: endProgressPercent
-      });
+      let result = { session: null };
+      let sessionEndError = null;
+      try {
+        result = await client3.endAgentSession(cardId, {
+          status: sessionStatus,
+          progressPercent: endProgressPercent
+        });
+      } catch (err) {
+        sessionEndError = err instanceof Error ? err.message : "Failed to end session";
+      }
       untrack(cardId);
       let movedTo = null;
-      const _learningsExtracted = 0;
-      let _cardTitle = "";
-      let _cardLabels = [];
-      let _cardDescription = "";
-      let _cardSubtasks = [];
       try {
         const { card } = await client3.getCard(cardId);
         const typedCard = card;
-        _cardTitle = typedCard.title || "";
-        _cardLabels = (typedCard.labels || []).map((l) => l.name);
-        _cardDescription = typedCard.description || "";
-        _cardSubtasks = (typedCard.subtasks || []).map((s) => ({
-          title: s.title,
-          done: s.done
-        }));
         const projectId = typedCard.project_id;
         if (sessionStatus === "completed" && typedCard.labels?.length) {
           const agentLabel = typedCard.labels.find((l) => l.name.toLowerCase() === "agent");
@@ -30033,21 +31174,16 @@ async function handleToolCall(name, args, deps) {
           }
         }
         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;
-          }
+          const col = await resolveColumnByName(client3, projectId, moveToColumn);
+          await client3.moveCard(cardId, col.id);
+          movedTo = col.name;
         }
       } catch {}
       const sessionObj = result.session;
       const pipelineResult = await runEndSessionPipeline(client3, deps, cardId, sessionStatus, endProgressPercent, sessionObj);
       return {
         success: true,
+        ...sessionEndError && { sessionEndError },
         movedTo,
         learningsExtracted: pipelineResult.learningsExtracted,
         feedbackAdjusted: pipelineResult.feedbackAdjusted,
@@ -30789,38 +31925,27 @@ async function handleToolCall(name, args, deps) {
       const projectName = args.projectName || "My First Project";
       const template = args.template || "kanban";
       const keyName = args.keyName || "mcp-agent";
-      const apiUrl = deps.getApiUrl();
-      const signupResult = await signupUser(apiUrl, {
+      const result = await onboardNewUser({
         email: email3,
         password,
-        full_name: fullName
-      });
-      const token = signupResult.session.access_token;
-      const workspaceResult = await requestWithBearer(apiUrl, token, "POST", "/workspaces", {
-        name: workspaceName
+        fullName,
+        workspaceName,
+        projectName,
+        template,
+        keyName,
+        apiUrl: deps.getApiUrl()
       });
-      const projectResult = await requestWithBearer(apiUrl, token, "POST", "/projects", {
-        workspaceId: workspaceResult.workspace.id,
-        name: projectName,
-        template
-      });
-      const keyResult = await requestWithBearer(apiUrl, token, "POST", "/api-keys", {
-        name: keyName
-      });
-      deps.saveConfig({ apiKey: keyResult.rawKey });
-      deps.setActiveWorkspace(workspaceResult.workspace.id);
-      deps.setActiveProject(projectResult.project.id);
+      deps.saveConfig({ apiKey: result.apiKey.rawKey });
+      deps.setActiveWorkspace(result.workspace.id);
+      deps.setActiveProject(result.project.id);
       deps.resetClient();
       return {
         success: true,
-        user: signupResult.user,
-        workspace: workspaceResult.workspace,
-        project: projectResult.project,
-        columns: projectResult.columns,
-        apiKey: {
-          rawKey: keyResult.rawKey,
-          prefix: keyResult.apiKey.prefix
-        },
+        user: result.user,
+        workspace: result.workspace,
+        project: result.project,
+        columns: result.columns,
+        apiKey: result.apiKey,
         message: `Onboarding complete! Account created for ${email3}. Workspace "${workspaceName}" and project "${projectName}" are ready. API key saved to config.`
       };
     }
@@ -30864,6 +31989,105 @@ async function handleToolCall(name, args, deps) {
         message: `Processed ${entitiesProcessed} entities, created ${relationsCreated} new relations.`
       };
     }
+    case "harmony_audit_memories": {
+      const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
+      if (!workspaceId) {
+        throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+      }
+      const projectId = args.projectId || deps.getActiveProjectId() || undefined;
+      const report = await runMemoryAudit(client3, workspaceId, projectId, {
+        dryRun: args.dryRun,
+        archiveBelow: args.archiveBelow,
+        deleteBelow: args.deleteBelow,
+        limit: args.limit,
+        staleDraftAgeDays: args.staleDraftAgeDays
+      });
+      return {
+        success: report.success,
+        dryRun: report.dryRun,
+        summary: report.summary,
+        distribution: report.distribution,
+        legacyBreakdown: report.legacyBreakdown,
+        actionsTaken: report.actionsTaken,
+        lowest: report.lowest,
+        staleDrafts: report.staleDrafts,
+        errors: report.errors,
+        healthReport: report.healthReport
+      };
+    }
+    case "harmony_cleanup_memories": {
+      const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
+      if (!workspaceId) {
+        throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+      }
+      const projectId = args.projectId || deps.getActiveProjectId() || undefined;
+      const validSteps = [
+        "prune",
+        "consolidate",
+        "orphans",
+        "duplicates",
+        "backfill",
+        "audit"
+      ];
+      const rawSteps = args.steps;
+      const steps = rawSteps?.filter((s) => validSteps.includes(s));
+      if (rawSteps && steps && steps.length < rawSteps.length) {
+        const invalid = rawSteps.filter((s) => !validSteps.includes(s));
+        console.warn(`Unknown cleanup steps ignored: ${invalid.join(", ")}`);
+      }
+      const report = await runMemoryCleanup(client3, workspaceId, projectId, {
+        dryRun: args.dryRun,
+        steps,
+        maxAgeDays: args.maxAgeDays,
+        minClusterSize: args.minClusterSize,
+        orphanAgeDays: args.orphanAgeDays,
+        auditArchiveBelow: args.auditArchiveBelow,
+        auditDeleteBelow: args.auditDeleteBelow
+      });
+      return {
+        success: report.success,
+        dryRun: report.dryRun,
+        summary: report.summary,
+        errors: report.errors,
+        healthReport: report.healthReport
+      };
+    }
+    case "harmony_purge_memories": {
+      const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
+      if (!workspaceId) {
+        throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+      }
+      const projectId = args.projectId || deps.getActiveProjectId();
+      if (!projectId) {
+        throw new Error("No project specified. Purge requires a project scope. Use harmony_set_project_context or provide projectId.");
+      }
+      const filters = {};
+      if (args.tier)
+        filters.tier = args.tier;
+      if (args.scope)
+        filters.scope = args.scope;
+      if (args.type)
+        filters.type = args.type;
+      if (args.olderThanDays !== undefined)
+        filters.olderThanDays = args.olderThanDays;
+      if (args.maxConfidence !== undefined)
+        filters.maxConfidence = args.maxConfidence;
+      if (args.tags)
+        filters.tags = args.tags;
+      const report = await purgeMemories(client3, workspaceId, projectId, {
+        dryRun: args.dryRun,
+        filters
+      });
+      return {
+        success: report.success,
+        dryRun: report.dryRun,
+        matched: report.matched,
+        purged: report.purged,
+        items: report.items,
+        errors: report.errors,
+        message: report.dryRun ? `Found ${report.matched} entities matching filters. Run with dryRun=false to delete.` : `Purged ${report.purged} of ${report.matched} matching entities.`
+      };
+    }
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
@@ -30901,15 +32125,26 @@ class HarmonyMCPServer {
       const cv = this.server.getClientVersion();
       return cv ? { name: cv.name, version: cv.version } : null;
     });
+    let exitCode = 0;
     const handleShutdown = async () => {
       try {
         await shutdownAllSessions();
       } catch {}
       destroyAutoSession();
-      process.exit(0);
+      process.exit(exitCode);
     };
     process.on("SIGINT", handleShutdown);
     process.on("SIGTERM", handleShutdown);
+    process.on("uncaughtException", (err) => {
+      console.error("MCP server uncaught exception:", err);
+      exitCode = 1;
+      handleShutdown();
+    });
+    process.on("unhandledRejection", (reason) => {
+      console.error("MCP server unhandled rejection:", reason);
+      exitCode = 1;
+      handleShutdown();
+    });
     try {
       if (isConfigured()) {
         const workspaceId = getActiveWorkspaceId();
@@ -30931,17 +32166,37 @@ class HarmonyMCPServer {
 
 // src/remote.ts
 var HARMONY_API_URL = process.env.HARMONY_API_URL || "https://app.gethmy.com/api";
+var OAUTH_ISSUER = process.env.OAUTH_ISSUER || "https://app.gethmy.com";
+var PUBLIC_MCP_URL = process.env.PUBLIC_MCP_URL || "https://mcp.gethmy.com";
 var PORT = parseInt(process.env.PORT || "3002", 10);
-async function validateApiKey(apiKey) {
+async function validateToken(token) {
+  try {
+    const response = await fetch(`${HARMONY_API_URL}/v1/auth/context`, {
+      headers: { "X-API-Key": token }
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    if (data.source === "jwt")
+      return null;
+    return {
+      userId: data.userId,
+      workspaceId: data.workspaceId,
+      source: data.source
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveWorkspaceForLegacyKey(token) {
   try {
     const response = await fetch(`${HARMONY_API_URL}/v1/workspaces`, {
-      headers: { "X-API-Key": apiKey }
+      headers: { "X-API-Key": token }
     });
     if (!response.ok)
       return null;
     const data = await response.json();
-    const firstWorkspace = data.workspaces?.[0];
-    return { workspaceId: firstWorkspace?.id ?? null };
+    return data.workspaces?.[0]?.id ?? null;
   } catch {
     return null;
   }
@@ -31014,11 +32269,29 @@ app.get("/health", (c) => c.json({
   service: "harmony-mcp-remote",
   sessions: sessions.size
 }));
+app.get("/.well-known/oauth-protected-resource", (c) => c.json({
+  resource: PUBLIC_MCP_URL,
+  authorization_servers: [OAUTH_ISSUER],
+  bearer_methods_supported: ["header"],
+  resource_documentation: `${OAUTH_ISSUER}/docs/mcp`
+}));
+function unauthenticatedResponse() {
+  return new Response(JSON.stringify({
+    error: "unauthorized",
+    error_description: "Missing or invalid access token"
+  }), {
+    status: 401,
+    headers: {
+      "Content-Type": "application/json",
+      "WWW-Authenticate": `Bearer realm="mcp", resource_metadata="${PUBLIC_MCP_URL}/.well-known/oauth-protected-resource"`
+    }
+  });
+}
 app.all("/mcp", async (c) => {
   const method = c.req.method;
   const authHeader = c.req.header("Authorization");
   if (!authHeader?.startsWith("Bearer ")) {
-    return c.json({ error: "Missing Authorization: Bearer <api-key>" }, 401);
+    return unauthenticatedResponse();
   }
   const apiKey = authHeader.slice(7);
   const sessionId = c.req.header("Mcp-Session-Id");
@@ -31027,9 +32300,12 @@ app.all("/mcp", async (c) => {
     return session.transport.handleRequest(c.req.raw);
   }
   if (method === "POST") {
-    const keyInfo = await validateApiKey(apiKey);
+    const keyInfo = await validateToken(apiKey);
     if (!keyInfo) {
-      return c.json({ error: "Invalid API key" }, 401);
+      return unauthenticatedResponse();
+    }
+    if (keyInfo.source === "api_key" && !keyInfo.workspaceId) {
+      keyInfo.workspaceId = await resolveWorkspaceForLegacyKey(apiKey);
     }
     const session = createSession(apiKey, keyInfo);
     await session.server.connect(session.transport);