@gethmy/mcp 2.3.1 → 2.3.3

package/dist/lib/api-client.js

@@ -1,672 +1,2123 @@
-import { getApiKey, getApiUrl } from "./config.js";
-// Retry configuration
-const RETRY_CONFIG = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    maxDelayMs: 10000,
-    retryableStatusCodes: [408, 429, 500, 502, 503, 504],
-};
-// Check if error is retryable
-function isRetryableError(error, status) {
-    if (status && RETRY_CONFIG.retryableStatusCodes.includes(status)) {
-        return true;
-    }
-    if (error instanceof TypeError)
-        return true; // Network errors
-    const msg = error instanceof Error ? error.message : String(error);
-    return (msg.includes("ECONNRESET") ||
-        msg.includes("ETIMEDOUT") ||
-        msg.includes("fetch failed"));
-}
-// Exponential backoff with jitter
-function getRetryDelay(attempt) {
-    const delay = Math.min(RETRY_CONFIG.baseDelayMs * 2 ** attempt, RETRY_CONFIG.maxDelayMs);
-    return Math.round(delay + delay * 0.25 * (Math.random() * 2 - 1));
-}
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-// Semaphore for concurrency control
-class Semaphore {
-    permits;
-    queue = [];
-    constructor(permits) {
-        this.permits = permits;
-    }
-    async acquire() {
-        if (this.permits > 0) {
-            this.permits--;
-            return;
-        }
-        return new Promise((resolve) => this.queue.push(resolve));
-    }
-    release() {
-        const next = this.queue.shift();
-        if (next)
-            next();
-        else
-            this.permits++;
-    }
-}
-// Limit concurrent requests to 3
-const requestSemaphore = new Semaphore(3);
-// ============ PRE-AUTH FREE FUNCTIONS ============
-// These bypass the singleton + semaphore for unauthenticated/JWT-based requests
-export async function signupUser(apiUrl, data) {
-    const url = `${apiUrl}/v1/auth/signup`;
-    const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(data),
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
     });
-    const result = await response.json();
-    if (!response.ok) {
-        throw new Error(result.error || `Signup failed: ${response.status}`);
-    }
-    return result;
-}
-export async function requestWithBearer(apiUrl, bearerToken, method, path, body) {
-    const url = `${apiUrl}/v1${path}`;
-    const response = await fetch(url, {
-        method,
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${bearerToken}`,
-        },
-        body: body ? JSON.stringify(body) : undefined,
-    });
-    const result = await response.json();
-    if (!response.ok) {
-        throw new Error(result.error || `API error: ${response.status}`);
-    }
-    return result;
-}
-export class HarmonyApiClient {
-    apiKey;
-    apiUrl;
-    constructor(options) {
-        this.apiKey = options?.apiKey ?? getApiKey();
-        this.apiUrl = options?.apiUrl ?? getApiUrl();
-    }
-    getApiUrl() {
-        return this.apiUrl;
-    }
-    async request(method, path, body, options) {
-        await requestSemaphore.acquire();
-        try {
-            return await this.requestWithRetry(method, path, body, options);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../memory/dist/schema.js
+var init_schema = () => {};
+
+// ../memory/dist/constraints.js
+var init_constraints = __esm(() => {
+  init_schema();
+});
+// ../memory/dist/client.js
+var init_client = __esm(() => {
+  init_constraints();
+});
+
+// ../memory/dist/graph-walk.js
+async function discoverRelatedContext(client, startIds, maxDepth = 2, maxEntities = 20, minConfidence = 0.5) {
+  const visited = new Set;
+  const collectedEntities = [];
+  const collectedRelations = [];
+  let truncated = false;
+  const queue = startIds.map((id) => [id, 0]);
+  for (const id of startIds) {
+    visited.add(id);
+  }
+  while (queue.length > 0) {
+    const [entityId, depth] = queue.shift();
+    if (collectedEntities.length >= maxEntities) {
+      truncated = true;
+      break;
+    }
+    if (depth > maxDepth)
+      continue;
+    try {
+      const entityResult = await client.getMemoryEntity(entityId);
+      const entity = entityResult.entity;
+      if (entity) {
+        collectedEntities.push({
+          id: entity.id,
+          type: entity.type,
+          title: entity.title,
+          confidence: entity.confidence ?? 1,
+          memory_tier: entity.memory_tier || "reference"
+        });
+      }
+      if (depth >= maxDepth)
+        continue;
+      const related = await client.getRelatedEntities(entityId);
+      for (const raw of related.outgoing || []) {
+        const rel = raw;
+        const relConfidence = rel.confidence ?? 1;
+        if (relConfidence < minConfidence)
+          continue;
+        const target = rel.target;
+        const targetId = target?.id ?? rel.target_id;
+        if (targetId && !visited.has(targetId)) {
+          visited.add(targetId);
+          queue.push([targetId, depth + 1]);
+          collectedRelations.push({
+            id: rel.id,
+            source_id: entityId,
+            target_id: targetId,
+            relation_type: rel.relation_type,
+            confidence: relConfidence
+          });
         }
-        finally {
-            requestSemaphore.release();
+      }
+      for (const raw of related.incoming || []) {
+        const rel = raw;
+        const relConfidence = rel.confidence ?? 1;
+        if (relConfidence < minConfidence)
+          continue;
+        const source = rel.source;
+        const sourceId = source?.id ?? rel.source_id;
+        if (sourceId && !visited.has(sourceId)) {
+          visited.add(sourceId);
+          queue.push([sourceId, depth + 1]);
+          collectedRelations.push({
+            id: rel.id,
+            source_id: sourceId,
+            target_id: entityId,
+            relation_type: rel.relation_type,
+            confidence: relConfidence
+          });
         }
-    }
-    async requestRaw(method, path, body, options) {
-        await requestSemaphore.acquire();
-        try {
-            return await this.requestRawWithRetry(method, path, body, options);
+      }
+    } catch {}
+  }
+  return {
+    entities: collectedEntities,
+    relations: collectedRelations,
+    depth: maxDepth,
+    truncated
+  };
+}
+
+// ../memory/dist/lifecycle.js
+function checkPromotion(currentTier, accessCount, confidence, createdAt) {
+  const ageDays = (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60 * 24);
+  const base = {
+    eligible: false,
+    targetTier: null,
+    reason: null,
+    currentTier,
+    accessCount,
+    confidence,
+    ageDays
+  };
+  if (currentTier === "draft") {
+    const rules = PROMOTION_RULES.draftToEpisode;
+    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
+      return {
+        ...base,
+        eligible: true,
+        targetTier: "episode",
+        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
+      };
+    }
+  }
+  if (currentTier === "episode") {
+    const rules = PROMOTION_RULES.episodeToReference;
+    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
+      return {
+        ...base,
+        eligible: true,
+        targetTier: "reference",
+        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
+      };
+    }
+  }
+  return base;
+}
+var PROMOTION_RULES;
+var init_lifecycle = __esm(() => {
+  PROMOTION_RULES = {
+    draftToEpisode: {
+      minAccessCount: 5,
+      minConfidence: 0.8,
+      minAgeDays: 1
+    },
+    episodeToReference: {
+      minAccessCount: 10,
+      minConfidence: 0.9,
+      minAgeDays: 7
+    }
+  };
+});
+// ../memory/dist/sync.js
+var init_sync = () => {};
+
+// ../memory/dist/index.js
+var init_dist = __esm(() => {
+  init_client();
+  init_constraints();
+  init_lifecycle();
+  init_schema();
+  init_sync();
+});
+
+// src/context-assembly.ts
+var exports_context_assembly = {};
+__export(exports_context_assembly, {
+  trackSessionAssembly: () => trackSessionAssembly,
+  recordContextFeedback: () => recordContextFeedback,
+  mapToContextEntity: () => mapToContextEntity,
+  getSessionAssemblyId: () => getSessionAssemblyId,
+  getCachedManifest: () => getCachedManifest,
+  expandQuery: () => expandQuery,
+  computeRelevanceScore: () => computeRelevanceScore,
+  cacheManifest: () => cacheManifest,
+  assembleContext: () => assembleContext
+});
+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)}`;
+}
+function truncateContent(content, maxTokens) {
+  const currentTokens = estimateTokens(content);
+  if (currentTokens <= maxTokens) {
+    return { text: content, truncated: false };
+  }
+  const paragraphs = content.split(/\n\n+/);
+  let result = paragraphs[0];
+  for (let i = 1;i < paragraphs.length; i++) {
+    const lines = paragraphs[i].split(`
+`).filter((l) => l.startsWith("- ") || l.startsWith("* "));
+    if (lines.length > 0) {
+      const bulletSection = lines.join(`
+`);
+      if (estimateTokens(result + `
+
+` + bulletSection) <= maxTokens) {
+        result += `
+
+` + bulletSection;
+      }
+    }
+  }
+  if (estimateTokens(result) > maxTokens) {
+    const maxChars = maxTokens * 4;
+    result = result.slice(0, maxChars - 3) + "...";
+  }
+  return { text: result, truncated: true };
+}
+function escapeRegex(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${escapeRegex(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;
+  if (hasRrfScore) {
+    const normalizedRrf = Math.min(entity.rrf_score / 0.04, 1);
+    const rrfContribution = normalizedRrf * 0.3;
+    score += rrfContribution;
+    reasons.push(`hybrid_search(rrf=${entity.rrf_score.toFixed(4)})`);
+  }
+  const textMatchWeight = hasRrfScore ? 0.15 : 0.4;
+  const taskWords = new Set(taskContext.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+  const entityWords = new Set(`${entity.title} ${entity.content}`.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+  const overlap = [...taskWords].filter((w) => entityWords.has(w));
+  if (overlap.length > 0) {
+    const textScore = Math.min(overlap.length / Math.max(taskWords.size, 1), 1) * textMatchWeight;
+    score += textScore;
+    reasons.push(`text_match(${overlap.length} words)`);
+  }
+  if (cardLabels.length > 0 && entity.tags.length > 0) {
+    const labelSet = new Set(cardLabels.map((l) => l.toLowerCase()));
+    const tagOverlap = entity.tags.filter((t) => labelSet.has(t.toLowerCase()));
+    if (tagOverlap.length > 0) {
+      const tagScore = tagOverlap.length / cardLabels.length * 0.3;
+      score += tagScore;
+      reasons.push(`tag_match(${tagOverlap.join(",")})`);
+    }
+  }
+  score += entity.confidence * 0.15;
+  if (entity.confidence >= 0.9) {
+    reasons.push("high_confidence");
+  }
+  if (entity.last_accessed_at) {
+    const daysSinceAccess = (Date.now() - new Date(entity.last_accessed_at).getTime()) / (1000 * 60 * 60 * 24);
+    const halfLife = { draft: 7, episode: 30, reference: 180 }[entity.memory_tier];
+    const recencyScore = 0.5 ** (daysSinceAccess / halfLife) * 0.1;
+    score += recencyScore;
+    if (daysSinceAccess < 7)
+      reasons.push("recently_accessed");
+  }
+  if (entity.access_count > 0) {
+    const freqScore = Math.log10(entity.access_count + 1) * 0.05;
+    score += Math.min(freqScore, 0.1);
+    if (entity.access_count >= 5)
+      reasons.push(`frequently_used(${entity.access_count})`);
+  }
+  const usefulnessScore = entity.metadata?.usefulness_score ?? 0;
+  if (usefulnessScore >= 3) {
+    const usefulnessBoost = Math.min(usefulnessScore / 20, 0.15);
+    score += usefulnessBoost;
+    reasons.push(`useful(${usefulnessScore})`);
+  } else if (usefulnessScore === 0 && entity.access_count >= 5) {
+    score -= 0.02;
+    reasons.push("low_usefulness");
+  }
+  if (entity.type === "procedure") {
+    score += 0.1;
+    reasons.push("procedure_boost");
+  }
+  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;
         }
-        finally {
-            requestSemaphore.release();
+      }
+      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 };
+}
+async function assembleContext(options) {
+  const {
+    workspaceId,
+    projectId,
+    taskContext,
+    cardLabels = [],
+    tokenBudget = DEFAULT_TOKEN_BUDGET,
+    client: client2,
+    graphWalkEnabled = true,
+    queryExpansionEnabled = true,
+    enableLlmReranking = false,
+    rerankFn
+  } = options;
+  const assemblyId = generateAssemblyId();
+  const manifest = {
+    assemblyId,
+    timestamp: new Date().toISOString(),
+    included: [],
+    excluded: [],
+    budgetUsed: 0,
+    budgetTotal: tokenBudget,
+    tierBreakdown: {
+      draft: { count: 0, tokens: 0 },
+      episode: { count: 0, tokens: 0 },
+      reference: { count: 0, tokens: 0 }
+    }
+  };
+  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 raw of result.value.entities) {
+        const entity = mapToContextEntity(raw);
+        if (!candidateIds.has(entity.id)) {
+          candidateIds.add(entity.id);
+          candidates.push(entity);
         }
-    }
-    async requestWithRetry(method, path, body, options) {
-        const url = `${this.apiUrl}/v1${path}`;
-        let lastError = null;
-        const contentType = options?.contentType || "application/json";
-        const accept = options?.accept || "application/json";
-        for (let attempt = 0; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
-            try {
-                const response = await fetch(url, {
-                    method,
-                    headers: {
-                        "Content-Type": contentType,
-                        Accept: accept,
-                        "X-API-Key": this.apiKey,
-                    },
-                    body: options?.rawBody ?? (body ? JSON.stringify(body) : undefined),
-                });
-                const data = await response.json();
-                if (!response.ok) {
-                    const errorMsg = data.error || `API error: ${response.status}`;
-                    if (!isRetryableError(null, response.status)) {
-                        throw new Error(errorMsg);
-                    }
-                    lastError = new Error(errorMsg);
-                    if (attempt < RETRY_CONFIG.maxRetries) {
-                        await sleep(getRetryDelay(attempt));
-                        continue;
-                    }
-                    throw lastError;
-                }
-                return data;
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (!isRetryableError(error))
-                    throw lastError;
-                if (attempt < RETRY_CONFIG.maxRetries) {
-                    await sleep(getRetryDelay(attempt));
-                }
-            }
+      }
+    }
+  }
+  if (candidates.length < 10 && projectId) {
+    try {
+      const listResult = await client2.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: 30
+      });
+      if (listResult.entities?.length > 0) {
+        for (const raw of listResult.entities) {
+          const entity = mapToContextEntity(raw);
+          if (!candidateIds.has(entity.id)) {
+            candidateIds.add(entity.id);
+            candidates.push(entity);
+          }
         }
-        throw lastError || new Error("Request failed after retries");
-    }
-    async requestRawWithRetry(method, path, body, options) {
-        const url = `${this.apiUrl}/v1${path}`;
-        let lastError = null;
-        const contentType = options?.contentType || "application/json";
-        const accept = options?.accept || "text/markdown";
-        for (let attempt = 0; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
-            try {
-                const response = await fetch(url, {
-                    method,
-                    headers: {
-                        "Content-Type": contentType,
-                        Accept: accept,
-                        "X-API-Key": this.apiKey,
-                    },
-                    body: options?.rawBody ?? (body ? JSON.stringify(body) : undefined),
-                });
-                if (!response.ok) {
-                    const text = await response.text();
-                    let errorMsg;
-                    try {
-                        errorMsg =
-                            JSON.parse(text).error || `API error: ${response.status}`;
-                    }
-                    catch {
-                        errorMsg = text || `API error: ${response.status}`;
-                    }
-                    if (!isRetryableError(null, response.status)) {
-                        throw new Error(errorMsg);
-                    }
-                    lastError = new Error(errorMsg);
-                    if (attempt < RETRY_CONFIG.maxRetries) {
-                        await sleep(getRetryDelay(attempt));
-                        continue;
-                    }
-                    throw lastError;
-                }
-                return await response.text();
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (!isRetryableError(error))
-                    throw lastError;
-                if (attempt < RETRY_CONFIG.maxRetries) {
-                    await sleep(getRetryDelay(attempt));
-                }
-            }
+      }
+    } catch {}
+  }
+  if (candidates.length < 20) {
+    try {
+      const wsResult = await client2.listMemoryEntities({
+        workspace_id: workspaceId,
+        scope: "workspace",
+        limit: 20
+      });
+      if (wsResult.entities?.length > 0) {
+        for (const raw of wsResult.entities) {
+          const entity = mapToContextEntity(raw);
+          if (!candidateIds.has(entity.id)) {
+            candidateIds.add(entity.id);
+            candidates.push(entity);
+          }
         }
-        throw lastError || new Error("Request failed after retries");
-    }
-    // ============ WORKSPACE OPERATIONS ============
-    async listWorkspaces() {
-        return this.request("GET", "/workspaces");
-    }
-    async getWorkspaceMembers(workspaceId) {
-        return this.request("GET", `/workspaces/${workspaceId}/members`);
-    }
-    // ============ PROJECT OPERATIONS ============
-    async listProjects(workspaceId) {
-        return this.request("GET", `/workspaces/${workspaceId}/projects`);
-    }
-    async getBoard(projectId, options) {
-        const params = new URLSearchParams();
-        if (options?.limit !== undefined)
-            params.set("limit", String(options.limit));
-        if (options?.offset !== undefined)
-            params.set("offset", String(options.offset));
-        if (options?.columnId)
-            params.set("column_id", options.columnId);
-        if (options?.summary)
-            params.set("summary", "true");
-        if (options?.includeArchived)
-            params.set("include_archived", "true");
-        if (options?.labelName)
-            params.set("label_name", options.labelName);
-        const query = params.toString() ? `?${params.toString()}` : "";
-        return this.request("GET", `/board/${projectId}${query}`);
-    }
-    // ============ CARD OPERATIONS ============
-    async createCard(projectId, data) {
-        return this.request("POST", "/cards", { projectId, ...data });
-    }
-    async updateCard(cardId, updates) {
-        return this.request("PATCH", `/cards/${cardId}`, updates);
-    }
-    async moveCard(cardId, columnId, position) {
-        return this.request("POST", `/cards/${cardId}/move`, {
-            columnId,
-            position,
-        });
-    }
-    async archiveCard(cardId) {
-        return this.updateCard(cardId, { archivedAt: new Date().toISOString() });
-    }
-    async unarchiveCard(cardId) {
-        return this.updateCard(cardId, { archivedAt: null });
-    }
-    async deleteCard(cardId) {
-        return this.request("DELETE", `/cards/${cardId}`);
-    }
-    async getCard(cardId) {
-        return this.request("GET", `/cards/${cardId}`);
-    }
-    async getCardByShortId(projectId, shortId) {
-        return this.request("GET", `/projects/${projectId}/cards/${shortId}`);
-    }
-    async searchCards(query, options) {
-        const params = new URLSearchParams({ q: query });
-        if (options?.projectId) {
-            params.set("project_id", options.projectId);
+      }
+    } 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);
         }
-        return this.request("GET", `/search?${params.toString()}`);
-    }
-    async addLabelToCard(cardId, labelId) {
-        return this.request("POST", `/cards/${cardId}/labels`, { labelId });
-    }
-    async removeLabelFromCard(cardId, labelId) {
-        return this.request("DELETE", `/cards/${cardId}/labels/${labelId}`);
-    }
-    // ============ CARD LINK OPERATIONS ============
-    async addLinkToCard(sourceCardId, targetCardId, linkType) {
-        return this.request("POST", `/cards/${sourceCardId}/links`, {
-            targetCardId,
-            linkType,
-        });
-    }
-    async removeLinkFromCard(linkId) {
-        return this.request("DELETE", `/card-links/${linkId}`);
-    }
-    async getCardLinks(cardId) {
-        return this.request("GET", `/cards/${cardId}/links`);
-    }
-    // ============ COLUMN OPERATIONS ============
-    async createColumn(projectId, name) {
-        return this.request("POST", "/columns", { projectId, name });
-    }
-    async updateColumn(columnId, name) {
-        return this.request("PATCH", `/columns/${columnId}`, { name });
-    }
-    async deleteColumn(columnId) {
-        return this.request("DELETE", `/columns/${columnId}`);
-    }
-    // ============ LABEL OPERATIONS ============
-    async createLabel(projectId, data) {
-        return this.request("POST", "/labels", { projectId, ...data });
-    }
-    // ============ SUBTASK OPERATIONS ============
-    async createSubtask(cardId, title) {
-        return this.request("POST", "/subtasks", { cardId, title });
-    }
-    async toggleSubtask(subtaskId) {
-        return this.request("POST", `/subtasks/${subtaskId}/toggle`);
-    }
-    async deleteSubtask(subtaskId) {
-        return this.request("DELETE", `/subtasks/${subtaskId}`);
-    }
-    // ============ AGENT CONTEXT OPERATIONS ============
-    async startAgentSession(cardId, data) {
-        return this.request("POST", `/cards/${cardId}/agent-context`, data);
-    }
-    async updateAgentProgress(cardId, data) {
-        return this.request("POST", `/cards/${cardId}/agent-context`, data);
-    }
-    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)
-            params.set("include_ended", "true");
-        const query = params.toString() ? `?${params.toString()}` : "";
-        return this.request("GET", `/cards/${cardId}/agent-context${query}`);
-    }
-    // ============ AGENT PERFORMANCE PROFILES ============
-    async getAgentProfile(workspaceId, agentIdentifier) {
-        const params = new URLSearchParams({
-            workspace_id: workspaceId,
-            agent_identifier: agentIdentifier,
+      }
+    } catch {}
+  }
+  if (candidates.length === 0) {
+    return {
+      context: "",
+      manifest,
+      memories: []
+    };
+  }
+  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;
         });
-        return this.request("GET", `/agent-profiles?${params.toString()}`);
-    }
-    async listAgentProfiles(workspaceId) {
-        const params = new URLSearchParams({ workspace_id: workspaceId });
-        return this.request("GET", `/agent-profiles?${params.toString()}`);
-    }
-    async refreshAgentProfiles(workspaceId) {
-        return this.request("POST", "/agent-profiles/refresh", {
-            workspace_id: workspaceId,
+        scored.splice(0, topN.length, ...topN);
+      } catch {}
+    }
+  }
+  const procedureBudget = Math.floor(tokenBudget * PROCEDURE_BUDGET_FRACTION);
+  const remainingBudget = tokenBudget - procedureBudget;
+  const tierBudgets = {
+    reference: Math.floor(remainingBudget * TIER_BUDGET_ALLOCATION.reference),
+    episode: Math.floor(remainingBudget * TIER_BUDGET_ALLOCATION.episode),
+    draft: Math.floor(remainingBudget * TIER_BUDGET_ALLOCATION.draft)
+  };
+  const tierUsed = {
+    reference: 0,
+    episode: 0,
+    draft: 0
+  };
+  let procedureUsed = 0;
+  const included = [];
+  let totalUsed = 0;
+  let referenceCount = 0;
+  for (const item of scored) {
+    if (item.entity.memory_tier === "reference" && item.entity.type !== "procedure" && referenceCount < MIN_REFERENCE_SLOTS) {
+      const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
+      const tokens = estimateTokens(`### ${item.entity.title}
+${text}`);
+      if (totalUsed + tokens <= tokenBudget) {
+        included.push({ ...item, tokens, truncated });
+        item.entity.content = text;
+        totalUsed += tokens;
+        tierUsed.reference += tokens;
+        referenceCount++;
+      }
+    }
+  }
+  const includedIds = new Set(included.map((i) => i.entity.id));
+  const procedureCandidates = scored.filter((item) => item.entity.type === "procedure" && !includedIds.has(item.entity.id));
+  for (const item of procedureCandidates) {
+    if (item.score < MIN_RELEVANCE_THRESHOLD) {
+      manifest.excluded.push({
+        entityId: item.entity.id,
+        title: item.entity.title,
+        type: item.entity.type,
+        tier: item.entity.memory_tier,
+        relevanceScore: item.score,
+        reason: "below_relevance_threshold"
+      });
+      continue;
+    }
+    const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
+    const tokens = estimateTokens(`### ${item.entity.title}
+${text}`);
+    if (procedureUsed + tokens > procedureBudget) {
+      const totalRemaining = tokenBudget - totalUsed;
+      if (tokens > totalRemaining) {
+        manifest.excluded.push({
+          entityId: item.entity.id,
+          title: item.entity.title,
+          type: item.entity.type,
+          tier: item.entity.memory_tier,
+          relevanceScore: item.score,
+          reason: "procedure_budget_exceeded"
         });
-    }
-    // ============ MEMORY OPERATIONS ============
-    async createMemoryEntity(data) {
-        return this.request("POST", "/memory/entities", data);
-    }
-    async listMemoryEntities(options) {
-        const params = new URLSearchParams();
-        params.set("workspace_id", options.workspace_id);
-        if (options.project_id)
-            params.set("project_id", options.project_id);
-        if (options.type)
-            params.set("type", options.type);
-        if (options.scope)
-            params.set("scope", options.scope);
-        if (options.tags?.length)
-            params.set("tags", options.tags.join(","));
-        if (options.agent_identifier)
-            params.set("agent_identifier", options.agent_identifier);
-        if (options.min_confidence !== undefined)
-            params.set("min_confidence", String(options.min_confidence));
-        if (options.q)
-            params.set("q", options.q);
-        if (options.limit !== undefined)
-            params.set("limit", String(options.limit));
-        if (options.offset !== undefined)
-            params.set("offset", String(options.offset));
-        return this.request("GET", `/memory/entities?${params.toString()}`);
-    }
-    async getMemoryEntity(entityId) {
-        return this.request("GET", `/memory/entities/${entityId}`);
-    }
-    async updateMemoryEntity(entityId, updates) {
-        return this.request("PUT", `/memory/entities/${entityId}`, updates);
-    }
-    async deleteMemoryEntity(entityId) {
-        return this.request("DELETE", `/memory/entities/${entityId}`);
-    }
-    async touchMemoryEntity(entityId) {
-        return this.request("POST", `/memory/entities/${entityId}/touch`);
-    }
-    async batchTouchMemoryEntities(entityIds) {
-        return this.request("POST", "/memory/entities/batch-touch", {
-            entity_ids: entityIds,
+        continue;
+      }
+    }
+    if (totalUsed + tokens > tokenBudget) {
+      manifest.excluded.push({
+        entityId: item.entity.id,
+        title: item.entity.title,
+        type: item.entity.type,
+        tier: item.entity.memory_tier,
+        relevanceScore: item.score,
+        reason: "total_budget_exceeded"
+      });
+      continue;
+    }
+    included.push({ ...item, tokens, truncated });
+    item.entity.content = text;
+    totalUsed += tokens;
+    procedureUsed += tokens;
+    includedIds.add(item.entity.id);
+  }
+  for (const item of scored) {
+    if (includedIds.has(item.entity.id))
+      continue;
+    if (item.entity.type === "procedure")
+      continue;
+    if (item.score < MIN_RELEVANCE_THRESHOLD) {
+      manifest.excluded.push({
+        entityId: item.entity.id,
+        title: item.entity.title,
+        type: item.entity.type,
+        tier: item.entity.memory_tier,
+        relevanceScore: item.score,
+        reason: "below_relevance_threshold"
+      });
+      continue;
+    }
+    const tier = item.entity.memory_tier;
+    const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
+    const tokens = estimateTokens(`### ${item.entity.title}
+${text}`);
+    if (tierUsed[tier] + tokens > tierBudgets[tier]) {
+      const totalRemaining = tokenBudget - totalUsed;
+      if (tokens > totalRemaining) {
+        manifest.excluded.push({
+          entityId: item.entity.id,
+          title: item.entity.title,
+          type: item.entity.type,
+          tier,
+          relevanceScore: item.score,
+          reason: "budget_exceeded"
         });
-    }
-    async createMemoryRelation(data) {
-        return this.request("POST", "/memory/relations", data);
-    }
-    async deleteMemoryRelation(relationId) {
-        return this.request("DELETE", `/memory/relations/${relationId}`);
-    }
-    async getRelatedEntities(entityId) {
-        return this.request("GET", `/memory/entities/${entityId}/related`);
-    }
-    async searchMemoryEntities(workspaceId, query, options) {
-        const params = new URLSearchParams();
-        params.set("workspace_id", workspaceId);
-        params.set("q", query);
-        if (options?.project_id)
-            params.set("project_id", options.project_id);
-        if (options?.type)
-            params.set("type", options.type);
-        if (options?.limit !== undefined)
-            params.set("limit", String(options.limit));
-        return this.request("GET", `/memory/search?${params.toString()}`);
-    }
-    // ============ VAULT INDEX ============
-    async getVaultIndex(options) {
-        const params = new URLSearchParams();
-        params.set("workspace_id", options.workspace_id);
-        if (options.project_id)
-            params.set("project_id", options.project_id);
-        if (options.type)
-            params.set("type", options.type);
-        if (options.limit !== undefined)
-            params.set("limit", String(options.limit));
-        return this.request("GET", `/memory/index?${params.toString()}`);
-    }
-    async getVaultIndexMarkdown(options) {
-        const params = new URLSearchParams();
-        params.set("workspace_id", options.workspace_id);
-        if (options.project_id)
-            params.set("project_id", options.project_id);
-        if (options.type)
-            params.set("type", options.type);
-        if (options.limit !== undefined)
-            params.set("limit", String(options.limit));
-        return this.requestRaw("GET", `/memory/index?${params.toString()}`, undefined, {
-            accept: "text/markdown",
+        continue;
+      }
+    }
+    if (totalUsed + tokens > tokenBudget) {
+      manifest.excluded.push({
+        entityId: item.entity.id,
+        title: item.entity.title,
+        type: item.entity.type,
+        tier,
+        relevanceScore: item.score,
+        reason: "total_budget_exceeded"
+      });
+      continue;
+    }
+    included.push({ ...item, tokens, truncated });
+    item.entity.content = text;
+    totalUsed += tokens;
+    tierUsed[tier] += tokens;
+    includedIds.add(item.entity.id);
+  }
+  manifest.budgetUsed = totalUsed;
+  const procedureItems = included.filter((i) => i.entity.type === "procedure");
+  manifest.tierBreakdown = {
+    reference: {
+      count: included.filter((i) => i.entity.memory_tier === "reference" && i.entity.type !== "procedure").length,
+      tokens: tierUsed.reference
+    },
+    episode: {
+      count: included.filter((i) => i.entity.memory_tier === "episode" && i.entity.type !== "procedure").length,
+      tokens: tierUsed.episode
+    },
+    draft: {
+      count: included.filter((i) => i.entity.memory_tier === "draft" && i.entity.type !== "procedure").length,
+      tokens: tierUsed.draft
+    }
+  };
+  manifest.procedureBreakdown = {
+    count: procedureItems.length,
+    tokens: procedureUsed,
+    budget: procedureBudget
+  };
+  for (const item of included) {
+    manifest.included.push({
+      entityId: item.entity.id,
+      title: item.entity.title,
+      type: item.entity.type,
+      tier: item.entity.memory_tier,
+      relevanceScore: item.score,
+      reasons: item.reasons,
+      tokenCount: item.tokens,
+      truncated: item.truncated
+    });
+  }
+  const contextSections = [];
+  const nonProcedureItems = included.filter((i) => i.entity.type !== "procedure");
+  if (included.length > 0) {
+    if (procedureItems.length > 0) {
+      contextSections.push(`## Procedures (${procedureItems.length} loaded, ${procedureUsed}/${procedureBudget} tokens)`);
+      for (const item of procedureItems) {
+        const tags = item.entity.tags.length > 0 ? ` [${item.entity.tags.join(", ")}]` : "";
+        const tierLabel = item.entity.memory_tier !== "reference" ? ` (${item.entity.memory_tier})` : "";
+        contextSections.push(`
+### ${item.entity.title} (confidence: ${item.entity.confidence})${tierLabel}${tags}`);
+        contextSections.push(item.entity.content);
+      }
+    }
+    if (nonProcedureItems.length > 0) {
+      contextSections.push(`
+## Relevant Memories (${nonProcedureItems.length} loaded, ${manifest.excluded.length} excluded)`);
+      contextSections.push(`*Assembly: ${assemblyId} | Budget: ${totalUsed}/${tokenBudget} tokens*`);
+      for (const item of nonProcedureItems) {
+        const tags = item.entity.tags.length > 0 ? ` [${item.entity.tags.join(", ")}]` : "";
+        const tierLabel = item.entity.memory_tier !== "reference" ? ` (${item.entity.memory_tier})` : "";
+        contextSections.push(`
+### ${item.entity.title} (${item.entity.type}, confidence: ${item.entity.confidence})${tierLabel}${tags}`);
+        contextSections.push(item.entity.content);
+      }
+    }
+  }
+  incrementAccessCounts(client2, included.map((i) => i.entity.id)).catch(() => {});
+  promoteEligibleEntities(client2, included.map((i) => i.entity)).catch(() => {});
+  return {
+    context: contextSections.join(`
+`),
+    manifest,
+    memories: included.map((i) => i.entity)
+  };
+}
+function mapToContextEntity(raw) {
+  const e = raw;
+  return {
+    id: e.id,
+    type: e.type,
+    title: e.title,
+    content: e.content,
+    confidence: e.confidence ?? 1,
+    tags: e.tags || [],
+    memory_tier: e.memory_tier || "reference",
+    access_count: e.access_count || 0,
+    last_accessed_at: e.last_accessed_at || null,
+    created_at: e.created_at || "",
+    updated_at: e.updated_at || "",
+    metadata: e.metadata ?? undefined,
+    rrf_score: e.rrf_score ?? undefined,
+    fts_rank: e.fts_rank ?? undefined,
+    semantic_rank: e.semantic_rank ?? undefined
+  };
+}
+async function incrementAccessCounts(client2, entityIds) {
+  if (entityIds.length === 0)
+    return;
+  try {
+    await client2.batchTouchMemoryEntities(entityIds);
+  } catch {
+    await Promise.allSettled(entityIds.map((id) => client2.touchMemoryEntity(id)));
+  }
+}
+async function promoteEligibleEntities(client2, entities) {
+  for (const entity of entities) {
+    if (entity.memory_tier === "reference")
+      continue;
+    if (!entity.created_at)
+      continue;
+    const promotion = checkPromotion(entity.memory_tier, entity.access_count + 1, entity.confidence, entity.created_at);
+    if (promotion.eligible && promotion.targetTier) {
+      try {
+        await client2.updateMemoryEntity(entity.id, {
+          memory_tier: promotion.targetTier,
+          metadata: {
+            ...entity.metadata || {},
+            promoted_at: new Date().toISOString(),
+            promotion_reason: promotion.reason,
+            promoted_from: entity.memory_tier
+          }
         });
+      } catch {}
     }
-    // ============ ENTITY STATS (materialized view) ============
-    async getMemoryStats(options) {
-        const params = new URLSearchParams();
-        params.set("workspace_id", options.workspace_id);
-        if (options.project_id)
-            params.set("project_id", options.project_id);
-        return this.request("GET", `/memory/stats?${params.toString()}`);
-    }
-    async refreshMemoryStats(workspaceId) {
-        return this.request("POST", "/memory/stats", { workspace_id: workspaceId });
-    }
-    // ============ WIKI-LINK RESOLUTION ============
-    async resolveLinks(options) {
-        return this.request("POST", "/memory/resolve-links", options);
-    }
-    // ============ MARKDOWN MEMORY OPERATIONS ============
-    async listMemoryEntitiesMarkdown(options) {
-        const params = new URLSearchParams();
-        params.set("workspace_id", options.workspace_id);
-        if (options.project_id)
-            params.set("project_id", options.project_id);
-        if (options.type)
-            params.set("type", options.type);
-        if (options.scope)
-            params.set("scope", options.scope);
-        if (options.tags?.length)
-            params.set("tags", options.tags.join(","));
-        if (options.agent_identifier)
-            params.set("agent_identifier", options.agent_identifier);
-        if (options.min_confidence !== undefined)
-            params.set("min_confidence", String(options.min_confidence));
-        if (options.q)
-            params.set("q", options.q);
-        if (options.limit !== undefined)
-            params.set("limit", String(options.limit));
-        if (options.offset !== undefined)
-            params.set("offset", String(options.offset));
-        return this.requestRaw("GET", `/memory/entities?${params.toString()}`, undefined, {
-            accept: "text/markdown",
+  }
+}
+function cacheManifest(manifest) {
+  if (manifestCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = manifestCache.keys().next().value;
+    if (firstKey)
+      manifestCache.delete(firstKey);
+  }
+  manifestCache.set(manifest.assemblyId, manifest);
+}
+function getCachedManifest(assemblyId) {
+  return manifestCache.get(assemblyId);
+}
+function trackSessionAssembly(cardId, assemblyId) {
+  if (sessionAssemblyMap.size >= MAX_SESSION_MAP_SIZE) {
+    const firstKey = sessionAssemblyMap.keys().next().value;
+    if (firstKey)
+      sessionAssemblyMap.delete(firstKey);
+  }
+  sessionAssemblyMap.set(cardId, assemblyId);
+}
+function getSessionAssemblyId(cardId) {
+  return sessionAssemblyMap.get(cardId);
+}
+async function recordContextFeedback(client2, cardId, sessionStatus, progressPercent, hadBlockers) {
+  const assemblyId = sessionAssemblyMap.get(cardId);
+  if (!assemblyId)
+    return { adjusted: 0 };
+  const manifest = manifestCache.get(assemblyId);
+  if (!manifest || manifest.included.length === 0)
+    return { adjusted: 0 };
+  let adjusted = 0;
+  const isSuccess = sessionStatus === "completed" && (progressPercent ?? 0) >= 100;
+  for (const entry of manifest.included) {
+    try {
+      if (isSuccess) {
+        const { entity } = await client2.getMemoryEntity(entry.entityId);
+        const e = entity;
+        const currentUsefulness = e.metadata?.usefulness_score ?? 0;
+        const newConfidence = Math.min((e.confidence ?? 0.5) + 0.05, 1);
+        await client2.updateMemoryEntity(entry.entityId, {
+          confidence: newConfidence,
+          metadata: {
+            usefulness_score: currentUsefulness + 1,
+            last_feedback_at: new Date().toISOString()
+          }
         });
-    }
-    async getMemoryEntityMarkdown(entityId) {
-        return this.requestRaw("GET", `/memory/entities/${entityId}`, undefined, {
-            accept: "text/markdown",
+        adjusted++;
+      } else if (hadBlockers) {
+        const { entity } = await client2.getMemoryEntity(entry.entityId);
+        const e = entity;
+        const newConfidence = Math.max((e.confidence ?? 0.5) - 0.02, 0.1);
+        await client2.updateMemoryEntity(entry.entityId, {
+          confidence: newConfidence,
+          metadata: {
+            last_feedback_at: new Date().toISOString()
+          }
         });
-    }
-    async searchMemoryEntitiesMarkdown(workspaceId, query, options) {
-        const params = new URLSearchParams();
-        params.set("workspace_id", workspaceId);
-        params.set("q", query);
-        if (options?.project_id)
-            params.set("project_id", options.project_id);
-        if (options?.type)
-            params.set("type", options.type);
-        if (options?.limit !== undefined)
-            params.set("limit", String(options.limit));
-        return this.requestRaw("GET", `/memory/search?${params.toString()}`, undefined, {
-            accept: "text/markdown",
+        adjusted++;
+      }
+    } catch {}
+  }
+  sessionAssemblyMap.delete(cardId);
+  return { adjusted };
+}
+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 = {
+    reference: 1,
+    episode: 0.7,
+    draft: 0.4
+  };
+  TIER_BUDGET_ALLOCATION = {
+    reference: 0.6,
+    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;
+});
+
+// src/prompt-builder.ts
+var exports_prompt_builder = {};
+__export(exports_prompt_builder, {
+  inferCategoryFromLabels: () => inferCategoryFromLabels,
+  getRoleFraming: () => getRoleFraming,
+  getAvailableVariants: () => getAvailableVariants,
+  getAvailableCategories: () => getAvailableCategories,
+  generatePrompt: () => generatePrompt
+});
+function inferCategoryFromLabels(labels) {
+  for (const label of labels) {
+    const normalizedName = label.name.toLowerCase().trim();
+    if (LABEL_CATEGORY_MAP[normalizedName]) {
+      return LABEL_CATEGORY_MAP[normalizedName];
+    }
+    for (const [key, category] of Object.entries(LABEL_CATEGORY_MAP)) {
+      if (normalizedName.includes(key) || key.includes(normalizedName)) {
+        return category;
+      }
+    }
+  }
+  return "custom";
+}
+function getRoleFraming(category) {
+  return DEFAULT_ROLE_FRAMINGS[category];
+}
+function estimateTokens2(text) {
+  return Math.ceil(text.length / 4);
+}
+function formatSubtasks(subtasks) {
+  if (subtasks.length === 0)
+    return "";
+  const completed = subtasks.filter((s) => s.completed).length;
+  const lines = subtasks.map((s) => `  ${s.completed ? "[x]" : "[ ]"} ${s.title}`);
+  return `
+## Subtasks (${completed}/${subtasks.length} completed)
+${lines.join(`
+`)}`;
+}
+function formatLabels(labels) {
+  if (labels.length === 0)
+    return "";
+  return `
+**Labels:** ${labels.map((l) => l.name).join(", ")}`;
+}
+function formatLinkedCards(links) {
+  if (!links || links.length === 0)
+    return "";
+  const lines = links.map((link) => {
+    const prefix = link.direction === "outgoing" ? "->" : "<-";
+    return `  ${prefix} #${link.target_card.short_id}: ${link.target_card.title} (${link.display_type})`;
+  });
+  return `
+## Related Cards
+${lines.join(`
+`)}`;
+}
+function generatePrompt(options) {
+  const {
+    card,
+    column,
+    variant,
+    customConstraints,
+    memories,
+    assembledContext,
+    assemblyId
+  } = options;
+  const contextOpts = {
+    includeTitle: true,
+    includeDescription: true,
+    includeLabels: true,
+    includeSubtasks: true,
+    includeActivity: false,
+    includeAssignee: true,
+    includeDueDate: true,
+    includePriority: true,
+    includeLinks: true,
+    includeColumn: true,
+    ...options.contextOptions
+  };
+  const labels = card.labels || [];
+  const subtasks = card.subtasks || [];
+  const links = card.links || [];
+  const category = inferCategoryFromLabels(labels);
+  const roleFraming = getRoleFraming(category);
+  const sections = [];
+  sections.push(`# Role: ${roleFraming.role}
+`);
+  sections.push(roleFraming.perspective);
+  sections.push("");
+  sections.push(VARIANT_INSTRUCTIONS[variant]);
+  sections.push("");
+  sections.push(`# Task: ${card.title}`);
+  if (contextOpts.includeColumn && column) {
+    sections.push(`**Status:** ${column.name}`);
+  }
+  if (contextOpts.includePriority) {
+    sections.push(`**Priority:** ${card.priority}`);
+  }
+  if (contextOpts.includeDueDate && card.due_date) {
+    sections.push(`**Due:** ${card.due_date}`);
+  }
+  if (contextOpts.includeAssignee && card.assignee) {
+    sections.push(`**Assignee:** ${card.assignee.full_name || card.assignee.email}`);
+  }
+  if (contextOpts.includeLabels && labels.length > 0) {
+    sections.push(formatLabels(labels));
+  }
+  if (contextOpts.includeDescription && card.description) {
+    sections.push(`
+## Description
+${card.description}`);
+  }
+  if (contextOpts.includeSubtasks && subtasks.length > 0) {
+    sections.push(formatSubtasks(subtasks));
+  }
+  if (contextOpts.includeLinks && links.length > 0) {
+    sections.push(formatLinkedCards(links));
+  }
+  sections.push(`
+## Focus Areas`);
+  roleFraming.focus.forEach((f) => {
+    sections.push(`- ${f}`);
+  });
+  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 — optimistic updates depend on action ordering"`);
+  sections.push(`  - GOOD: "Mobile bottom bar is 64px, overlaps fixed-position drawers — always add pb-16 to drawer content"`);
+  sections.push(`  - BAD: "Fixed the login button" (no reusable knowledge — 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) => {
+    sections.push(`- ${s}`);
+  });
+  if (assembledContext) {
+    sections.push(`
+${assembledContext}`);
+  } else if (memories && memories.length > 0) {
+    sections.push(`
+## Relevant Memories`);
+    sections.push(`*${memories.length} memories recalled from knowledge graph:*`);
+    for (const memory of memories) {
+      const tags = memory.tags.length > 0 ? ` [${memory.tags.join(", ")}]` : "";
+      sections.push(`
+### ${memory.title} (${memory.type}, confidence: ${memory.confidence})${tags}`);
+      sections.push(memory.content);
+    }
+  }
+  const oneThingLine = synthesizeOneThing(card, subtasks, links, assembledContext);
+  if (oneThingLine) {
+    sections.push(`
+## Recommended Next Step
+${oneThingLine}`);
+  }
+  if (variant === "execute") {
+    sections.push(`
+## Progress Tracking
+Update your progress by calling \`harmony_update_agent_progress\` with \`currentTask\` describing what you're doing now:
+- After exploring the codebase and understanding requirements (~20%)
+- When you start implementing changes (~50%)
+- When you move to testing or verification (~80%)
+- When done, before ending the session (100%)
+
+Keep \`currentTask\` specific (e.g., "Refactoring auth middleware" not "Working on card").`);
+  }
+  if (customConstraints) {
+    sections.push(`
+## Additional Instructions
+${customConstraints}`);
+  }
+  sections.push(`
+---
+*Card #${card.short_id} | Generated for ${variant} mode*`);
+  const prompt = sections.join(`
+`);
+  const memoryCount = assembledContext ? (assembledContext.match(/^### /gm) || []).length : memories?.length || 0;
+  return {
+    prompt,
+    variant,
+    category,
+    role: roleFraming.role,
+    contextSummary: {
+      hasDescription: !!card.description,
+      labelCount: labels.length,
+      subtaskCount: subtasks.length,
+      completedSubtasks: subtasks.filter((s) => s.completed).length,
+      linkedCardCount: links.length,
+      memoryCount
+    },
+    tokenEstimate: estimateTokens2(prompt),
+    ...assemblyId && { assemblyId }
+  };
+}
+function extractSessionInsights(assembledContext) {
+  const result = {
+    lastSessionStatus: null,
+    lastSessionTask: null,
+    lastSessionProgress: null,
+    blockers: [],
+    procedureNextStep: null
+  };
+  const sessionMatches = assembledContext.match(/### Session:.*?\n([\s\S]*?)(?=\n###|\n## |\n---|\n\*Assembly|$)/g);
+  if (sessionMatches && sessionMatches.length > 0) {
+    const latest = sessionMatches[0];
+    if (/Completed work on/i.test(latest)) {
+      result.lastSessionStatus = "completed";
+    } else if (/Paused work on|status:\s*paused/i.test(latest)) {
+      result.lastSessionStatus = "paused";
+    }
+    const taskMatch = latest.match(/Final task:\s*(.+)/);
+    if (taskMatch)
+      result.lastSessionTask = taskMatch[1].trim();
+    const progressMatch = latest.match(/Progress:\s*(\d+)%/);
+    if (progressMatch)
+      result.lastSessionProgress = parseInt(progressMatch[1], 10);
+  }
+  const blockerMatches = assembledContext.match(/(?:blocker|blocked by|blocking):\s*(.+)/gi);
+  if (blockerMatches) {
+    result.blockers = blockerMatches.map((m) => m.replace(/(?:blocker|blocked by|blocking):\s*/i, "").trim());
+  }
+  const stepMatches = assembledContext.match(/^\d+\.\s+(?!.*\*\*\[key step\]\*\*.*✓)(.+?)(?:\s*\*\*\[key step\]\*\*)?$/gm);
+  if (stepMatches && stepMatches.length > 0) {
+    result.procedureNextStep = stepMatches[0].replace(/^\d+\.\s+/, "").replace(/\s*\*\*\[key step\]\*\*.*$/, "").trim();
+  }
+  return result;
+}
+function synthesizeOneThing(card, subtasks, links, assembledContext) {
+  if (card.done)
+    return null;
+  const blockers = links.filter((l) => l.display_type === "is_blocked_by" && l.direction === "incoming");
+  if (blockers.length > 0) {
+    const blocker = blockers[0];
+    return `Unblock first: resolve #${blocker.target_card.short_id} "${blocker.target_card.title}" which is blocking this card.`;
+  }
+  const session = assembledContext ? extractSessionInsights(assembledContext) : null;
+  if (session?.blockers && session.blockers.length > 0) {
+    return `Resolve blocker: ${session.blockers[0]}`;
+  }
+  if (session?.lastSessionStatus === "paused" && session.lastSessionTask) {
+    const progress = session.lastSessionProgress ? ` (was ${session.lastSessionProgress}% complete)` : "";
+    return `Resume previous session${progress}: "${session.lastSessionTask}".`;
+  }
+  if (subtasks.length > 0) {
+    const completed = subtasks.filter((s) => s.completed).length;
+    if (completed === subtasks.length) {
+      return "All subtasks completed. Review the work and mark the card as done.";
+    }
+    const nextSubtask = subtasks.find((s) => !s.completed);
+    if (nextSubtask) {
+      return `Work on next subtask: "${nextSubtask.title}" (${completed}/${subtasks.length} done).`;
+    }
+  }
+  if (session?.procedureNextStep) {
+    return `Follow procedure: ${session.procedureNextStep}`;
+  }
+  if (session?.lastSessionStatus === "completed" && session.lastSessionTask) {
+    return `Previous session completed ("${session.lastSessionTask}"). Review results and continue with remaining work.`;
+  }
+  if (card.due_date && (card.priority === "urgent" || card.priority === "high")) {
+    return `High-priority task with deadline ${card.due_date}. Start implementation immediately.`;
+  }
+  if (card.description) {
+    return "Analyze the description, identify the approach, and begin implementation.";
+  }
+  return null;
+}
+function getAvailableCategories() {
+  return ["bug", "feature", "design", "review", "onboarding", "epic", "custom"];
+}
+function getAvailableVariants() {
+  return ["analysis", "draft", "execute"];
+}
+var LABEL_CATEGORY_MAP, DEFAULT_ROLE_FRAMINGS, VARIANT_INSTRUCTIONS;
+var init_prompt_builder = __esm(() => {
+  LABEL_CATEGORY_MAP = {
+    bug: "bug",
+    fix: "bug",
+    hotfix: "bug",
+    defect: "bug",
+    issue: "bug",
+    error: "bug",
+    feature: "feature",
+    enhancement: "feature",
+    improvement: "feature",
+    new: "feature",
+    design: "design",
+    ui: "design",
+    ux: "design",
+    frontend: "design",
+    styling: "design",
+    review: "review",
+    "code review": "review",
+    pr: "review",
+    feedback: "review",
+    onboarding: "onboarding",
+    documentation: "onboarding",
+    docs: "onboarding",
+    guide: "onboarding",
+    tutorial: "onboarding",
+    epic: "epic",
+    initiative: "epic",
+    project: "epic",
+    milestone: "epic"
+  };
+  DEFAULT_ROLE_FRAMINGS = {
+    bug: {
+      category: "bug",
+      role: "Senior QA Engineer and Software Developer",
+      perspective: "You are investigating and fixing a bug report.",
+      focus: [
+        "Root cause analysis",
+        "Steps to reproduce",
+        "Impact assessment",
+        "Fix implementation",
+        "Regression prevention",
+        "Test cases to prevent recurrence"
+      ],
+      outputSuggestions: [
+        "Bug triage summary",
+        "Root cause explanation",
+        "Fix implementation plan",
+        "Test cases"
+      ]
+    },
+    feature: {
+      category: "feature",
+      role: "Product Engineer",
+      perspective: "You are implementing a new feature or enhancement.",
+      focus: [
+        "User requirements",
+        "Technical specification",
+        "Implementation approach",
+        "Edge cases",
+        "Acceptance criteria",
+        "Integration points"
+      ],
+      outputSuggestions: [
+        "Technical specification",
+        "Implementation tasks",
+        "Acceptance criteria checklist",
+        "API design"
+      ]
+    },
+    design: {
+      category: "design",
+      role: "UX Designer and Frontend Developer",
+      perspective: "You are designing and implementing a user interface.",
+      focus: [
+        "User experience flow",
+        "Visual design consistency",
+        "Accessibility (WCAG)",
+        "Responsive behavior",
+        "Component architecture",
+        "Interaction patterns"
+      ],
+      outputSuggestions: [
+        "User flow diagram",
+        "Component specifications",
+        "Accessibility checklist",
+        "Responsive breakpoints"
+      ]
+    },
+    review: {
+      category: "review",
+      role: "Code Reviewer and Technical Lead",
+      perspective: "You are reviewing code for quality, correctness, and maintainability.",
+      focus: [
+        "Code correctness",
+        "Performance implications",
+        "Security considerations",
+        "Testing coverage",
+        "Documentation",
+        "Best practices adherence"
+      ],
+      outputSuggestions: [
+        "Review checklist",
+        "Suggested improvements",
+        "Test scenarios",
+        "Security audit"
+      ]
+    },
+    onboarding: {
+      category: "onboarding",
+      role: "Technical Writer and Developer Advocate",
+      perspective: "You are creating documentation or onboarding materials.",
+      focus: [
+        "Clear step-by-step instructions",
+        "Prerequisites and setup",
+        "Common pitfalls",
+        "Examples and use cases",
+        "Troubleshooting guide",
+        "Related resources"
+      ],
+      outputSuggestions: [
+        "Getting started guide",
+        "Step-by-step tutorial",
+        "FAQ section",
+        "Troubleshooting guide"
+      ]
+    },
+    epic: {
+      category: "epic",
+      role: "Technical Project Manager and Architect",
+      perspective: "You are planning and coordinating a large initiative.",
+      focus: [
+        "Scope definition",
+        "Task breakdown",
+        "Dependencies",
+        "Risk assessment",
+        "Timeline considerations",
+        "Success metrics"
+      ],
+      outputSuggestions: [
+        "Epic breakdown into stories",
+        "Dependency graph",
+        "Risk mitigation plan",
+        "Success criteria"
+      ]
+    },
+    custom: {
+      category: "custom",
+      role: "Software Engineer",
+      perspective: "You are working on a software task.",
+      focus: [
+        "Understanding requirements",
+        "Implementation approach",
+        "Quality considerations",
+        "Testing strategy"
+      ],
+      outputSuggestions: [
+        "Implementation plan",
+        "Technical notes",
+        "Task checklist"
+      ]
+    }
+  };
+  VARIANT_INSTRUCTIONS = {
+    analysis: `ANALYSIS MODE: Analyze this task thoroughly. Identify requirements, constraints, edge cases, and potential challenges. Do NOT implement anything yet - focus on understanding and planning.`,
+    draft: `DRAFT MODE: Create a detailed implementation plan with code structure, key decisions, and approach. Include pseudocode or skeleton code where helpful. This is for review before full implementation.`,
+    execute: `EXECUTE MODE: Implement this task completely. Write production-ready code following best practices. Include necessary tests and documentation.`
+  };
+});
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_API_URL = "https://app.gethmy.com/api";
+var LOCAL_CONFIG_FILENAME = ".harmony-mcp.json";
+function getConfigDir() {
+  return join(homedir(), ".harmony-mcp");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function getLocalConfigPath(cwd) {
+  return join(cwd || process.cwd(), LOCAL_CONFIG_FILENAME);
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return {
+      apiKey: null,
+      apiUrl: DEFAULT_API_URL,
+      activeWorkspaceId: null,
+      activeProjectId: null,
+      userEmail: null,
+      memoryDir: null
+    };
+  }
+  try {
+    const data = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(data);
+    return {
+      apiKey: config.apiKey || null,
+      apiUrl: config.apiUrl || DEFAULT_API_URL,
+      activeWorkspaceId: config.activeWorkspaceId || null,
+      activeProjectId: config.activeProjectId || null,
+      userEmail: config.userEmail || null,
+      memoryDir: config.memoryDir || null
+    };
+  } catch {
+    return {
+      apiKey: null,
+      apiUrl: DEFAULT_API_URL,
+      activeWorkspaceId: null,
+      activeProjectId: null,
+      userEmail: null,
+      memoryDir: null
+    };
+  }
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 448 });
+  }
+  const existingConfig = loadConfig();
+  const newConfig = { ...existingConfig, ...config };
+  writeFileSync(configPath, JSON.stringify(newConfig, null, 2), {
+    mode: 384
+  });
+}
+function loadLocalConfig(cwd) {
+  const localConfigPath = getLocalConfigPath(cwd);
+  if (!existsSync(localConfigPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(localConfigPath, "utf-8");
+    const config = JSON.parse(data);
+    return {
+      workspaceId: config.workspaceId || null,
+      projectId: config.projectId || null
+    };
+  } catch {
+    return null;
+  }
+}
+function saveLocalConfig(config, cwd) {
+  const localConfigPath = getLocalConfigPath(cwd);
+  const existingConfig = loadLocalConfig(cwd) || {
+    workspaceId: null,
+    projectId: null
+  };
+  const newConfig = { ...existingConfig, ...config };
+  const cleanConfig = {};
+  if (newConfig.workspaceId)
+    cleanConfig.workspaceId = newConfig.workspaceId;
+  if (newConfig.projectId)
+    cleanConfig.projectId = newConfig.projectId;
+  writeFileSync(localConfigPath, JSON.stringify(cleanConfig, null, 2));
+}
+function hasLocalConfig(cwd) {
+  return existsSync(getLocalConfigPath(cwd));
+}
+function getApiKey() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    throw new Error(`Not configured. Run "npx @gethmy/mcp setup" to set your API key.
+` + "You can generate an API key at https://gethmy.com → Settings → API Keys.");
+  }
+  return config.apiKey;
+}
+function getApiUrl() {
+  const config = loadConfig();
+  return config.apiUrl;
+}
+function getUserEmail() {
+  const config = loadConfig();
+  return config.userEmail;
+}
+function setUserEmail(email) {
+  saveConfig({ userEmail: email });
+}
+function setActiveWorkspace(workspaceId, options) {
+  if (options?.local) {
+    saveLocalConfig({ workspaceId }, options.cwd);
+  } else {
+    saveConfig({ activeWorkspaceId: workspaceId });
+  }
+}
+function setActiveProject(projectId, options) {
+  if (options?.local) {
+    saveLocalConfig({ projectId }, options.cwd);
+  } else {
+    saveConfig({ activeProjectId: projectId });
+  }
+}
+function getActiveWorkspaceId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.workspaceId) {
+    return localConfig.workspaceId;
+  }
+  return loadConfig().activeWorkspaceId;
+}
+function getActiveProjectId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.projectId) {
+    return localConfig.projectId;
+  }
+  return loadConfig().activeProjectId;
+}
+function isConfigured() {
+  const config = loadConfig();
+  return !!config.apiKey;
+}
+function areSkillsInstalled(cwd) {
+  const home = homedir();
+  const workingDir = cwd || process.cwd();
+  const foundPaths = [];
+  const globalSkillsDir = join(home, ".agents", "skills");
+  const globalSkillPath = join(globalSkillsDir, "hmy", "SKILL.md");
+  if (existsSync(globalSkillPath)) {
+    foundPaths.push(globalSkillPath);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const claudeGlobalSkill = join(home, ".claude", "skills", "hmy.md");
+  if (existsSync(claudeGlobalSkill)) {
+    foundPaths.push(claudeGlobalSkill);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const claudeGlobalSkillAlt = join(home, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(claudeGlobalSkillAlt)) {
+    foundPaths.push(claudeGlobalSkillAlt);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const localSkillPath = join(workingDir, ".claude", "skills", "hmy.md");
+  if (existsSync(localSkillPath)) {
+    foundPaths.push(localSkillPath);
+    return { installed: true, location: "local", paths: foundPaths };
+  }
+  const localSkillPathAlt = join(workingDir, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(localSkillPathAlt)) {
+    foundPaths.push(localSkillPathAlt);
+    return { installed: true, location: "local", paths: foundPaths };
+  }
+  return { installed: false, location: null, paths: [] };
+}
+function hasProjectContext(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  return !!(localConfig?.workspaceId || localConfig?.projectId);
+}
+function getMemoryDir() {
+  const config = loadConfig();
+  if (config.memoryDir)
+    return config.memoryDir;
+  return join(homedir(), ".harmony", "memory");
+}
+
+// src/api-client.ts
+var RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 1e4,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
+};
+function isRetryableError(error, status) {
+  if (status && RETRY_CONFIG.retryableStatusCodes.includes(status)) {
+    return true;
+  }
+  if (error instanceof TypeError)
+    return true;
+  const msg = error instanceof Error ? error.message : String(error);
+  return msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT") || msg.includes("fetch failed");
+}
+function getRetryDelay(attempt) {
+  const delay = Math.min(RETRY_CONFIG.baseDelayMs * 2 ** attempt, RETRY_CONFIG.maxDelayMs);
+  return Math.round(delay + delay * 0.25 * (Math.random() * 2 - 1));
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class Semaphore {
+  permits;
+  queue = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve) => this.queue.push(resolve));
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next)
+      next();
+    else
+      this.permits++;
+  }
+}
+var requestSemaphore = new Semaphore(3);
+async function signupUser(apiUrl, data) {
+  const url = `${apiUrl}/v1/auth/signup`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data)
+  });
+  const result = await response.json();
+  if (!response.ok) {
+    throw new Error(result.error || `Signup failed: ${response.status}`);
+  }
+  return result;
+}
+async function requestWithBearer(apiUrl, bearerToken, method, path, body) {
+  const url = `${apiUrl}/v1${path}`;
+  const response = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${bearerToken}`
+    },
+    body: body ? JSON.stringify(body) : undefined
+  });
+  const result = await response.json();
+  if (!response.ok) {
+    throw new Error(result.error || `API error: ${response.status}`);
+  }
+  return result;
+}
+
+class HarmonyApiClient {
+  apiKey;
+  apiUrl;
+  constructor(options) {
+    this.apiKey = options?.apiKey ?? getApiKey();
+    this.apiUrl = options?.apiUrl ?? getApiUrl();
+  }
+  getApiUrl() {
+    return this.apiUrl;
+  }
+  async request(method, path, body, options) {
+    await requestSemaphore.acquire();
+    try {
+      return await this.requestWithRetry(method, path, body, options);
+    } finally {
+      requestSemaphore.release();
+    }
+  }
+  async requestRaw(method, path, body, options) {
+    await requestSemaphore.acquire();
+    try {
+      return await this.requestRawWithRetry(method, path, body, options);
+    } finally {
+      requestSemaphore.release();
+    }
+  }
+  async requestWithRetry(method, path, body, options) {
+    const url = `${this.apiUrl}/v1${path}`;
+    let lastError = null;
+    const contentType = options?.contentType || "application/json";
+    const accept = options?.accept || "application/json";
+    for (let attempt = 0;attempt <= RETRY_CONFIG.maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": contentType,
+            Accept: accept,
+            "X-API-Key": this.apiKey
+          },
+          body: options?.rawBody ?? (body ? JSON.stringify(body) : undefined)
         });
-    }
-    // ============ EMBEDDING OPERATIONS ============
-    async backfillEmbeddings(workspaceId, batchSize) {
-        return this.request("POST", "/memory/backfill-embeddings", {
-            workspace_id: workspaceId,
-            batch_size: batchSize || 50,
+        const data = await response.json();
+        if (!response.ok) {
+          const errorMsg = data.error || `API error: ${response.status}`;
+          if (!isRetryableError(null, response.status)) {
+            throw new Error(errorMsg);
+          }
+          lastError = new Error(errorMsg);
+          if (attempt < RETRY_CONFIG.maxRetries) {
+            await sleep(getRetryDelay(attempt));
+            continue;
+          }
+          throw lastError;
+        }
+        return data;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (!isRetryableError(error))
+          throw lastError;
+        if (attempt < RETRY_CONFIG.maxRetries) {
+          await sleep(getRetryDelay(attempt));
+        }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  async requestRawWithRetry(method, path, body, options) {
+    const url = `${this.apiUrl}/v1${path}`;
+    let lastError = null;
+    const contentType = options?.contentType || "application/json";
+    const accept = options?.accept || "text/markdown";
+    for (let attempt = 0;attempt <= RETRY_CONFIG.maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": contentType,
+            Accept: accept,
+            "X-API-Key": this.apiKey
+          },
+          body: options?.rawBody ?? (body ? JSON.stringify(body) : undefined)
         });
-    }
-    // ============ NLU OPERATIONS ============
-    async processNLU(data) {
-        return this.request("POST", "/nlu", data);
-    }
-    // ============ PLAN OPERATIONS ============
-    async createPlan(projectId, data) {
-        return this.request("POST", "/plans", { projectId, ...data });
-    }
-    async listPlans(projectId, options) {
-        const params = new URLSearchParams({ projectId });
-        if (options?.search)
-            params.set("search", options.search);
-        if (options?.status)
-            params.set("status", options.status);
-        return this.request("GET", `/plans?${params.toString()}`);
-    }
-    async getPlan(planId) {
-        return this.request("GET", `/plans/${planId}`);
-    }
-    async getPlanByCardId(cardId) {
-        return this.request("GET", `/cards/${cardId}/plan`);
-    }
-    async updatePlan(planId, updates) {
-        return this.request("PATCH", `/plans/${planId}`, updates);
-    }
-    async updatePlanTask(planId, taskId, updates) {
-        return this.request("PATCH", `/plans/${planId}/tasks/${taskId}`, updates);
-    }
-    // ============ ONBOARDING OPERATIONS ============
-    async createWorkspace(data) {
-        return this.request("POST", "/workspaces", data);
-    }
-    async createProject(data) {
-        return this.request("POST", "/projects", data);
-    }
-    async sendInvitations(data) {
-        return this.request("POST", "/invitations", data);
-    }
-    async generateApiKey(name) {
-        return this.request("POST", "/api-keys", { name });
-    }
-    // ============ PROMPT GENERATION ============
-    /**
-     * Generate a prompt for a card with full memory context assembly.
-     *
-     * This is the shared entry point for prompt generation — used by the MCP
-     * server tool handler and the agent daemon. It fetches the card, assembles
-     * relevant memories, and produces a role-framed prompt.
-     */
-    async generateCardPrompt(options) {
-        const { assembleContext, cacheManifest, generatePrompt } = await loadPromptModules();
-        // Fetch card data
-        const cardResult = await this.getCard(options.cardId);
-        const cardData = cardResult.card;
-        // Try to get column info
-        let columnData = null;
-        const projectIdForBoard = options.projectId || cardData.project_id;
-        if (projectIdForBoard) {
-            try {
-                const board = await this.getBoard(projectIdForBoard, { summary: true });
-                const column = board.columns.find((col) => col.id === cardData.column_id);
-                if (column) {
-                    columnData = { name: column.name };
-                }
-            }
-            catch {
-                // Column info not available, continue without it
-            }
+        if (!response.ok) {
+          const text = await response.text();
+          let errorMsg;
+          try {
+            errorMsg = JSON.parse(text).error || `API error: ${response.status}`;
+          } catch {
+            errorMsg = text || `API error: ${response.status}`;
+          }
+          if (!isRetryableError(null, response.status)) {
+            throw new Error(errorMsg);
+          }
+          lastError = new Error(errorMsg);
+          if (attempt < RETRY_CONFIG.maxRetries) {
+            await sleep(getRetryDelay(attempt));
+            continue;
+          }
+          throw lastError;
         }
-        const variant = options.variant || "execute";
-        // Assemble memory context
-        let assembledContextStr;
-        let assemblyId;
-        let memories;
-        try {
-            if (options.workspaceId && cardData.title) {
-                const cardLabels = (cardData.labels || []).map((l) => l.name);
-                const taskContext = [cardData.title, cardData.description || ""]
-                    .filter(Boolean)
-                    .join(" ");
-                const assembled = await assembleContext({
-                    workspaceId: options.workspaceId,
-                    projectId: options.projectId,
-                    taskContext,
-                    cardLabels,
-                    cardId: cardData.id,
-                    client: this,
-                });
-                if (assembled.context) {
-                    assembledContextStr = assembled.context;
-                    assemblyId = assembled.manifest.assemblyId;
-                    cacheManifest(assembled.manifest);
-                }
-            }
+        return await response.text();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (!isRetryableError(error))
+          throw lastError;
+        if (attempt < RETRY_CONFIG.maxRetries) {
+          await sleep(getRetryDelay(attempt));
         }
-        catch (err) {
-            // Context assembly failed, try legacy fallback
-            const msg = err instanceof Error ? err.message : String(err);
-            console.debug(`[generateCardPrompt] Context assembly failed: ${msg}`);
-            try {
-                if (options.workspaceId && cardData.title) {
-                    const memoryResult = await this.searchMemoryEntities(options.workspaceId, cardData.title, {
-                        project_id: options.projectId,
-                        limit: 5,
-                    });
-                    if (memoryResult.entities?.length > 0) {
-                        memories = memoryResult.entities.map((e) => ({
-                            id: e.id,
-                            type: e.type,
-                            title: e.title,
-                            content: e.content,
-                            confidence: e.confidence,
-                            tags: e.tags || [],
-                        }));
-                    }
-                }
-            }
-            catch (fallbackErr) {
-                const fallbackMsg = fallbackErr instanceof Error
-                    ? fallbackErr.message
-                    : String(fallbackErr);
-                console.debug(`[generateCardPrompt] Memory fallback also failed: ${fallbackMsg}`);
-            }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  async listWorkspaces() {
+    return this.request("GET", "/workspaces");
+  }
+  async getWorkspaceMembers(workspaceId) {
+    return this.request("GET", `/workspaces/${workspaceId}/members`);
+  }
+  async listProjects(workspaceId) {
+    return this.request("GET", `/workspaces/${workspaceId}/projects`);
+  }
+  async getBoard(projectId, options) {
+    const params = new URLSearchParams;
+    if (options?.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options?.offset !== undefined)
+      params.set("offset", String(options.offset));
+    if (options?.columnId)
+      params.set("column_id", options.columnId);
+    if (options?.summary)
+      params.set("summary", "true");
+    if (options?.includeArchived)
+      params.set("include_archived", "true");
+    if (options?.labelName)
+      params.set("label_name", options.labelName);
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.request("GET", `/board/${projectId}${query}`);
+  }
+  async createCard(projectId, data) {
+    return this.request("POST", "/cards", { projectId, ...data });
+  }
+  async updateCard(cardId, updates) {
+    return this.request("PATCH", `/cards/${cardId}`, updates);
+  }
+  async moveCard(cardId, columnId, position) {
+    return this.request("POST", `/cards/${cardId}/move`, {
+      columnId,
+      position
+    });
+  }
+  async archiveCard(cardId) {
+    return this.updateCard(cardId, { archivedAt: new Date().toISOString() });
+  }
+  async unarchiveCard(cardId) {
+    return this.updateCard(cardId, { archivedAt: null });
+  }
+  async deleteCard(cardId) {
+    return this.request("DELETE", `/cards/${cardId}`);
+  }
+  async getCard(cardId) {
+    return this.request("GET", `/cards/${cardId}`);
+  }
+  async getCardByShortId(projectId, shortId) {
+    return this.request("GET", `/projects/${projectId}/cards/${shortId}`);
+  }
+  async searchCards(query, options) {
+    const params = new URLSearchParams({ q: query });
+    if (options?.projectId) {
+      params.set("project_id", options.projectId);
+    }
+    return this.request("GET", `/search?${params.toString()}`);
+  }
+  async addLabelToCard(cardId, labelId) {
+    return this.request("POST", `/cards/${cardId}/labels`, { labelId });
+  }
+  async removeLabelFromCard(cardId, labelId) {
+    return this.request("DELETE", `/cards/${cardId}/labels/${labelId}`);
+  }
+  async addLinkToCard(sourceCardId, targetCardId, linkType) {
+    return this.request("POST", `/cards/${sourceCardId}/links`, {
+      targetCardId,
+      linkType
+    });
+  }
+  async removeLinkFromCard(linkId) {
+    return this.request("DELETE", `/card-links/${linkId}`);
+  }
+  async getCardLinks(cardId) {
+    return this.request("GET", `/cards/${cardId}/links`);
+  }
+  async createColumn(projectId, name) {
+    return this.request("POST", "/columns", { projectId, name });
+  }
+  async updateColumn(columnId, name) {
+    return this.request("PATCH", `/columns/${columnId}`, { name });
+  }
+  async deleteColumn(columnId) {
+    return this.request("DELETE", `/columns/${columnId}`);
+  }
+  async createLabel(projectId, data) {
+    return this.request("POST", "/labels", { projectId, ...data });
+  }
+  async createSubtask(cardId, title) {
+    return this.request("POST", "/subtasks", { cardId, title });
+  }
+  async toggleSubtask(subtaskId) {
+    return this.request("POST", `/subtasks/${subtaskId}/toggle`);
+  }
+  async deleteSubtask(subtaskId) {
+    return this.request("DELETE", `/subtasks/${subtaskId}`);
+  }
+  async startAgentSession(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/agent-context`, data);
+  }
+  async updateAgentProgress(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/agent-context`, data);
+  }
+  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)
+      params.set("include_ended", "true");
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.request("GET", `/cards/${cardId}/agent-context${query}`);
+  }
+  async getAgentProfile(workspaceId, agentIdentifier) {
+    const params = new URLSearchParams({
+      workspace_id: workspaceId,
+      agent_identifier: agentIdentifier
+    });
+    return this.request("GET", `/agent-profiles?${params.toString()}`);
+  }
+  async listAgentProfiles(workspaceId) {
+    const params = new URLSearchParams({ workspace_id: workspaceId });
+    return this.request("GET", `/agent-profiles?${params.toString()}`);
+  }
+  async refreshAgentProfiles(workspaceId) {
+    return this.request("POST", "/agent-profiles/refresh", {
+      workspace_id: workspaceId
+    });
+  }
+  async createMemoryEntity(data) {
+    return this.request("POST", "/memory/entities", data);
+  }
+  async listMemoryEntities(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.scope)
+      params.set("scope", options.scope);
+    if (options.tags?.length)
+      params.set("tags", options.tags.join(","));
+    if (options.agent_identifier)
+      params.set("agent_identifier", options.agent_identifier);
+    if (options.min_confidence !== undefined)
+      params.set("min_confidence", String(options.min_confidence));
+    if (options.q)
+      params.set("q", options.q);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options.offset !== undefined)
+      params.set("offset", String(options.offset));
+    return this.request("GET", `/memory/entities?${params.toString()}`);
+  }
+  async getMemoryEntity(entityId) {
+    return this.request("GET", `/memory/entities/${entityId}`);
+  }
+  async updateMemoryEntity(entityId, updates) {
+    return this.request("PUT", `/memory/entities/${entityId}`, updates);
+  }
+  async deleteMemoryEntity(entityId) {
+    return this.request("DELETE", `/memory/entities/${entityId}`);
+  }
+  async touchMemoryEntity(entityId) {
+    return this.request("POST", `/memory/entities/${entityId}/touch`);
+  }
+  async batchTouchMemoryEntities(entityIds) {
+    return this.request("POST", "/memory/entities/batch-touch", {
+      entity_ids: entityIds
+    });
+  }
+  async createMemoryRelation(data) {
+    return this.request("POST", "/memory/relations", data);
+  }
+  async deleteMemoryRelation(relationId) {
+    return this.request("DELETE", `/memory/relations/${relationId}`);
+  }
+  async getRelatedEntities(entityId) {
+    return this.request("GET", `/memory/entities/${entityId}/related`);
+  }
+  async searchMemoryEntities(workspaceId, query, options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", workspaceId);
+    params.set("q", query);
+    if (options?.project_id)
+      params.set("project_id", options.project_id);
+    if (options?.type)
+      params.set("type", options.type);
+    if (options?.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.request("GET", `/memory/search?${params.toString()}`);
+  }
+  async getVaultIndex(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.request("GET", `/memory/index?${params.toString()}`);
+  }
+  async getVaultIndexMarkdown(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.requestRaw("GET", `/memory/index?${params.toString()}`, undefined, {
+      accept: "text/markdown"
+    });
+  }
+  async getMemoryStats(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    return this.request("GET", `/memory/stats?${params.toString()}`);
+  }
+  async refreshMemoryStats(workspaceId) {
+    return this.request("POST", "/memory/stats", { workspace_id: workspaceId });
+  }
+  async resolveLinks(options) {
+    return this.request("POST", "/memory/resolve-links", options);
+  }
+  async listMemoryEntitiesMarkdown(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.scope)
+      params.set("scope", options.scope);
+    if (options.tags?.length)
+      params.set("tags", options.tags.join(","));
+    if (options.agent_identifier)
+      params.set("agent_identifier", options.agent_identifier);
+    if (options.min_confidence !== undefined)
+      params.set("min_confidence", String(options.min_confidence));
+    if (options.q)
+      params.set("q", options.q);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options.offset !== undefined)
+      params.set("offset", String(options.offset));
+    return this.requestRaw("GET", `/memory/entities?${params.toString()}`, undefined, {
+      accept: "text/markdown"
+    });
+  }
+  async getMemoryEntityMarkdown(entityId) {
+    return this.requestRaw("GET", `/memory/entities/${entityId}`, undefined, {
+      accept: "text/markdown"
+    });
+  }
+  async searchMemoryEntitiesMarkdown(workspaceId, query, options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", workspaceId);
+    params.set("q", query);
+    if (options?.project_id)
+      params.set("project_id", options.project_id);
+    if (options?.type)
+      params.set("type", options.type);
+    if (options?.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.requestRaw("GET", `/memory/search?${params.toString()}`, undefined, {
+      accept: "text/markdown"
+    });
+  }
+  async backfillEmbeddings(workspaceId, batchSize) {
+    return this.request("POST", "/memory/backfill-embeddings", {
+      workspace_id: workspaceId,
+      batch_size: batchSize || 50
+    });
+  }
+  async processNLU(data) {
+    return this.request("POST", "/nlu", data);
+  }
+  async createPlan(projectId, data) {
+    return this.request("POST", "/plans", { projectId, ...data });
+  }
+  async listPlans(projectId, options) {
+    const params = new URLSearchParams({ projectId });
+    if (options?.search)
+      params.set("search", options.search);
+    if (options?.status)
+      params.set("status", options.status);
+    return this.request("GET", `/plans?${params.toString()}`);
+  }
+  async getPlan(planId) {
+    return this.request("GET", `/plans/${planId}`);
+  }
+  async getPlanByCardId(cardId) {
+    return this.request("GET", `/cards/${cardId}/plan`);
+  }
+  async updatePlan(planId, updates) {
+    return this.request("PATCH", `/plans/${planId}`, updates);
+  }
+  async updatePlanTask(planId, taskId, updates) {
+    return this.request("PATCH", `/plans/${planId}/tasks/${taskId}`, updates);
+  }
+  async createWorkspace(data) {
+    return this.request("POST", "/workspaces", data);
+  }
+  async createProject(data) {
+    return this.request("POST", "/projects", data);
+  }
+  async sendInvitations(data) {
+    return this.request("POST", "/invitations", data);
+  }
+  async generateApiKey(name) {
+    return this.request("POST", "/api-keys", { name });
+  }
+  async generateCardPrompt(options) {
+    const { assembleContext: assembleContext2, cacheManifest: cacheManifest2, generatePrompt: generatePrompt2 } = await loadPromptModules();
+    const cardResult = await this.getCard(options.cardId);
+    const cardData = cardResult.card;
+    let columnData = null;
+    const projectIdForBoard = options.projectId || cardData.project_id;
+    if (projectIdForBoard) {
+      try {
+        const board = await this.getBoard(projectIdForBoard, { summary: true });
+        const column = board.columns.find((col) => col.id === cardData.column_id);
+        if (column) {
+          columnData = { name: column.name };
         }
-        const result = generatePrompt({
-            card: cardData,
-            column: columnData,
-            variant,
-            contextOptions: options.contextOptions,
-            customConstraints: options.customConstraints,
-            memories,
-            assembledContext: assembledContextStr,
-            assemblyId,
+      } catch {}
+    }
+    const variant = options.variant || "execute";
+    let assembledContextStr;
+    let assemblyId;
+    let memories;
+    try {
+      if (options.workspaceId && cardData.title) {
+        const cardLabels = (cardData.labels || []).map((l) => l.name);
+        const taskContext = [cardData.title, cardData.description || ""].filter(Boolean).join(" ");
+        const assembled = await assembleContext2({
+          workspaceId: options.workspaceId,
+          projectId: options.projectId,
+          taskContext,
+          cardLabels,
+          cardId: cardData.id,
+          client: this
         });
-        return {
-            ...result,
-            cardId: cardData.id,
-            shortId: cardData.short_id,
-            title: cardData.title,
-        };
-    }
+        if (assembled.context) {
+          assembledContextStr = assembled.context;
+          assemblyId = assembled.manifest.assemblyId;
+          cacheManifest2(assembled.manifest);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.debug(`[generateCardPrompt] Context assembly failed: ${msg}`);
+      try {
+        if (options.workspaceId && cardData.title) {
+          const memoryResult = await this.searchMemoryEntities(options.workspaceId, cardData.title, {
+            project_id: options.projectId,
+            limit: 5
+          });
+          if (memoryResult.entities?.length > 0) {
+            memories = memoryResult.entities.map((e) => ({
+              id: e.id,
+              type: e.type,
+              title: e.title,
+              content: e.content,
+              confidence: e.confidence,
+              tags: e.tags || []
+            }));
+          }
+        }
+      } catch (fallbackErr) {
+        const fallbackMsg = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+        console.debug(`[generateCardPrompt] Memory fallback also failed: ${fallbackMsg}`);
+      }
+    }
+    const result = generatePrompt2({
+      card: cardData,
+      column: columnData,
+      variant,
+      contextOptions: options.contextOptions,
+      customConstraints: options.customConstraints,
+      memories,
+      assembledContext: assembledContextStr,
+      assemblyId
+    });
+    return {
+      ...result,
+      cardId: cardData.id,
+      shortId: cardData.short_id,
+      title: cardData.title
+    };
+  }
 }
-// Cached dynamic imports for context-assembly and prompt-builder
-let _promptModules = null;
+var _promptModules = null;
 async function loadPromptModules() {
-    if (!_promptModules) {
-        const [ca, pb] = await Promise.all([
-            import("./context-assembly.js"),
-            import("./prompt-builder.js"),
-        ]);
-        _promptModules = {
-            assembleContext: ca.assembleContext,
-            cacheManifest: ca.cacheManifest,
-            generatePrompt: pb.generatePrompt,
-        };
-    }
-    return _promptModules;
-}
-// Singleton instance
-let client = null;
-export function getClient() {
-    if (!client) {
-        client = new HarmonyApiClient();
-    }
-    return client;
-}
-export function resetClient() {
-    client = null;
+  if (!_promptModules) {
+    const [ca, pb] = await Promise.all([
+      Promise.resolve().then(() => (init_context_assembly(), exports_context_assembly)),
+      Promise.resolve().then(() => (init_prompt_builder(), exports_prompt_builder))
+    ]);
+    _promptModules = {
+      assembleContext: ca.assembleContext,
+      cacheManifest: ca.cacheManifest,
+      generatePrompt: pb.generatePrompt
+    };
+  }
+  return _promptModules;
 }
+var client2 = null;
+function getClient() {
+  if (!client2) {
+    client2 = new HarmonyApiClient;
+  }
+  return client2;
+}
+function resetClient() {
+  client2 = null;
+}
+export {
+  signupUser,
+  resetClient,
+  requestWithBearer,
+  getClient,
+  HarmonyApiClient
+};