@gethmy/mcp 2.1.3 → 2.2.1

package/dist/cli.js

@@ -26,6 +26,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/commander/lib/error.js
@@ -2121,204 +2122,781 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
-// ../../node_modules/ajv/dist/compile/codegen/code.js
-var require_code = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = undefined;
+// ../memory/src/schema.ts
+var init_schema = () => {};
 
-  class _CodeOrName {
-  }
-  exports._CodeOrName = _CodeOrName;
-  exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+// ../memory/src/constraints.ts
+var init_constraints = __esm(() => {
+  init_schema();
+});
+// ../memory/src/client.ts
+var init_client = __esm(() => {
+  init_constraints();
+});
 
-  class Name extends _CodeOrName {
-    constructor(s) {
-      super();
-      if (!exports.IDENTIFIER.test(s))
-        throw new Error("CodeGen: name must be a valid identifier");
-      this.str = s;
-    }
-    toString() {
-      return this.str;
-    }
-    emptyStr() {
-      return false;
-    }
-    get names() {
-      return { [this.str]: 1 };
+// ../memory/src/graph-walk.ts
+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
+          });
+        }
+      }
+      for (const raw of related.incoming || []) {
+        const rel = raw;
+        const relConfidence = rel.confidence ?? 1;
+        if (relConfidence < minConfidence)
+          continue;
+        const source = rel.source;
+        const sourceId = source?.id ?? rel.source_id;
+        if (sourceId && !visited.has(sourceId)) {
+          visited.add(sourceId);
+          queue.push([sourceId, depth + 1]);
+          collectedRelations.push({
+            id: rel.id,
+            source_id: sourceId,
+            target_id: entityId,
+            relation_type: rel.relation_type,
+            confidence: relConfidence
+          });
+        }
+      }
+    } catch {}
   }
-  exports.Name = Name;
+  return {
+    entities: collectedEntities,
+    relations: collectedRelations,
+    depth: maxDepth,
+    truncated
+  };
+}
 
-  class _Code extends _CodeOrName {
-    constructor(code) {
-      super();
-      this._items = typeof code === "string" ? [code] : code;
-    }
-    toString() {
-      return this.str;
-    }
-    emptyStr() {
-      if (this._items.length > 1)
-        return false;
-      const item = this._items[0];
-      return item === "" || item === '""';
-    }
-    get str() {
-      var _a2;
-      return (_a2 = this._str) !== null && _a2 !== undefined ? _a2 : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
-    }
-    get names() {
-      var _a2;
-      return (_a2 = this._names) !== null && _a2 !== undefined ? _a2 : this._names = this._items.reduce((names, c) => {
-        if (c instanceof Name)
-          names[c.str] = (names[c.str] || 0) + 1;
-        return names;
-      }, {});
+// ../memory/src/lifecycle.ts
+function computeDecayScore(tier, lastAccessedAt, accessCount) {
+  const halfLife = DECAY_HALF_LIVES[tier];
+  const now = Date.now();
+  let daysSinceAccess = 0;
+  if (lastAccessedAt) {
+    daysSinceAccess = (now - new Date(lastAccessedAt).getTime()) / (1000 * 60 * 60 * 24);
+  }
+  const timeDecay = 0.5 ** (daysSinceAccess / halfLife);
+  const accessBonus = Math.log10(accessCount + 1) * 0.1;
+  const score = Math.min(timeDecay + accessBonus, 1);
+  return { score, daysSinceAccess, halfLife, accessBonus };
+}
+function checkPromotion(currentTier, accessCount, confidence, createdAt) {
+  const ageDays = (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60 * 24);
+  const base = {
+    eligible: false,
+    targetTier: null,
+    reason: null,
+    currentTier,
+    accessCount,
+    confidence,
+    ageDays
+  };
+  if (currentTier === "draft") {
+    const rules = PROMOTION_RULES.draftToEpisode;
+    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
+      return {
+        ...base,
+        eligible: true,
+        targetTier: "episode",
+        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
+      };
     }
   }
-  exports._Code = _Code;
-  exports.nil = new _Code("");
-  function _(strs, ...args) {
-    const code = [strs[0]];
-    let i = 0;
-    while (i < args.length) {
-      addCodeArg(code, args[i]);
-      code.push(strs[++i]);
+  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 new _Code(code);
   }
-  exports._ = _;
-  var plus = new _Code("+");
-  function str(strs, ...args) {
-    const expr = [safeStringify(strs[0])];
-    let i = 0;
-    while (i < args.length) {
-      expr.push(plus);
-      addCodeArg(expr, args[i]);
-      expr.push(plus, safeStringify(strs[++i]));
+  return base;
+}
+function evaluateLifecycle(entity) {
+  const decay = computeDecayScore(entity.memory_tier, entity.last_accessed_at, entity.access_count);
+  const promotion = checkPromotion(entity.memory_tier, entity.access_count, entity.confidence, entity.created_at);
+  const shouldArchive = entity.confidence < ARCHIVE_THRESHOLD;
+  const archiveReason = shouldArchive ? `Confidence ${entity.confidence} below threshold ${ARCHIVE_THRESHOLD}` : undefined;
+  const shouldFlagForReview = decay.daysSinceAccess >= STALE_DAYS && entity.access_count < STALE_MIN_ACCESS;
+  const reviewReason = shouldFlagForReview ? `Not accessed in ${Math.round(decay.daysSinceAccess)} days with only ${entity.access_count} accesses` : undefined;
+  return {
+    decay,
+    promotion,
+    shouldArchive,
+    shouldFlagForReview,
+    archiveReason,
+    reviewReason
+  };
+}
+var DECAY_HALF_LIVES, PROMOTION_RULES, ARCHIVE_THRESHOLD = 0.3, STALE_DAYS = 90, STALE_MIN_ACCESS = 3;
+var init_lifecycle = __esm(() => {
+  DECAY_HALF_LIVES = {
+    draft: 7,
+    episode: 30,
+    reference: 180
+  };
+  PROMOTION_RULES = {
+    draftToEpisode: {
+      minAccessCount: 5,
+      minConfidence: 0.8,
+      minAgeDays: 1
+    },
+    episodeToReference: {
+      minAccessCount: 10,
+      minConfidence: 0.9,
+      minAgeDays: 7
     }
-    optimize(expr);
-    return new _Code(expr);
+  };
+});
+
+// ../memory/src/sync-storage.ts
+function parseSyncMarkdown(markdown) {
+  const trimmed = markdown.trim();
+  let frontmatter = {
+    type: "context",
+    scope: "project",
+    tier: "reference",
+    confidence: 1,
+    tags: []
+  };
+  let body = trimmed;
+  const fmMatch = trimmed.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (fmMatch) {
+    frontmatter = parseSyncYamlFrontmatter(fmMatch[1]);
+    body = fmMatch[2].trim();
   }
-  exports.str = str;
-  function addCodeArg(code, arg) {
-    if (arg instanceof _Code)
-      code.push(...arg._items);
-    else if (arg instanceof Name)
-      code.push(arg);
-    else
-      code.push(interpolate(arg));
+  let title = "";
+  const titleMatch = body.match(/^#\s+(.+)/m);
+  if (titleMatch) {
+    title = titleMatch[1].trim();
+    body = body.replace(/^#\s+.+\n?/, "").trim();
   }
-  exports.addCodeArg = addCodeArg;
-  function optimize(expr) {
-    let i = 1;
-    while (i < expr.length - 1) {
-      if (expr[i] === plus) {
-        const res = mergeExprItems(expr[i - 1], expr[i + 1]);
-        if (res !== undefined) {
-          expr.splice(i - 1, 3, res);
-          continue;
-        }
-        expr[i++] = "+";
-      }
-      i++;
-    }
+  return { frontmatter, title, content: body };
+}
+function serializeSyncMarkdown(entity) {
+  const lines = ["---"];
+  lines.push(`id: ${entity.id}`);
+  lines.push(`workspace_id: ${entity.workspace_id}`);
+  if (entity.project_id) {
+    lines.push(`project_id: ${entity.project_id}`);
   }
-  function mergeExprItems(a, b) {
-    if (b === '""')
-      return a;
-    if (a === '""')
-      return b;
-    if (typeof a == "string") {
-      if (b instanceof Name || a[a.length - 1] !== '"')
-        return;
-      if (typeof b != "string")
-        return `${a.slice(0, -1)}${b}"`;
-      if (b[0] === '"')
-        return a.slice(0, -1) + b.slice(1);
-      return;
-    }
-    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
-      return `"${a}${b.slice(1)}`;
-    return;
+  lines.push(`type: ${entity.type}`);
+  lines.push(`scope: ${entity.scope}`);
+  lines.push(`tier: ${entity.memory_tier || "reference"}`);
+  lines.push(`confidence: ${entity.confidence}`);
+  if (entity.tags.length > 0) {
+    lines.push(`tags: [${entity.tags.join(", ")}]`);
+  } else {
+    lines.push("tags: []");
   }
-  function strConcat(c1, c2) {
-    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
+  if (entity.agent_identifier) {
+    lines.push(`agent: ${entity.agent_identifier}`);
   }
-  exports.strConcat = strConcat;
-  function interpolate(x) {
-    return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
+  lines.push(`created_at: ${entity.created_at}`);
+  lines.push(`updated_at: ${entity.updated_at}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${entity.title}`);
+  lines.push("");
+  lines.push(entity.content);
+  return lines.join(`
+`);
+}
+function parseSyncYamlFrontmatter(yaml) {
+  const result = {
+    type: "context",
+    scope: "project",
+    tier: "reference",
+    confidence: 1,
+    tags: []
+  };
+  for (const line of yaml.split(`
+`)) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "id":
+        result.id = value;
+        break;
+      case "workspace_id":
+        result.workspace_id = value;
+        break;
+      case "project_id":
+        result.project_id = value;
+        break;
+      case "type":
+        result.type = value;
+        break;
+      case "scope":
+        result.scope = value;
+        break;
+      case "tier":
+        result.tier = value;
+        break;
+      case "confidence":
+        result.confidence = parseFloat(value) || 1;
+        break;
+      case "tags":
+        result.tags = parseYamlArray(value);
+        break;
+      case "related":
+        result.related = parseYamlArray(value);
+        break;
+      case "agent":
+        result.agent = value;
+        break;
+      case "created_at":
+        result.created_at = value;
+        break;
+      case "updated_at":
+        result.updated_at = value;
+        break;
+    }
   }
-  function stringify(x) {
-    return new _Code(safeStringify(x));
+  return result;
+}
+function parseYamlArray(value) {
+  const match = value.match(/^\[(.*)]\s*$/);
+  if (!match)
+    return [];
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+// ../memory/src/sync.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+function computeFileHash(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function slugifyTitle(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function entityToFilename(entity) {
+  const slug = slugifyTitle(entity.title);
+  const shortId = entity.id.slice(0, 8);
+  return `${entity.type}--${slug}--${shortId}.md`;
+}
+function entityToDirectoryPath(entity, memoryDir) {
+  const wsDir = join2(memoryDir, entity.workspace_id);
+  if (entity.scope === "private") {
+    return join2(wsDir, "_private");
   }
-  exports.stringify = stringify;
-  function safeStringify(x) {
-    return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  if (entity.scope === "workspace" || !entity.project_id) {
+    return join2(wsDir, "_workspace");
   }
-  exports.safeStringify = safeStringify;
-  function getProperty(key) {
-    return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
+  return join2(wsDir, entity.project_id);
+}
+function emptySyncState() {
+  return { version: 1, lastPullAt: null, entities: {} };
+}
+function loadSyncState(memoryDir) {
+  const statePath = join2(memoryDir, ".sync-state.json");
+  if (!existsSync2(statePath))
+    return emptySyncState();
+  try {
+    return JSON.parse(readFileSync2(statePath, "utf-8"));
+  } catch {
+    return emptySyncState();
   }
-  exports.getProperty = getProperty;
-  function getEsmExportName(key) {
-    if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
-      return new _Code(`${key}`);
-    }
-    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
+}
+function saveSyncState(memoryDir, state) {
+  if (!existsSync2(memoryDir)) {
+    mkdirSync2(memoryDir, { recursive: true });
   }
-  exports.getEsmExportName = getEsmExportName;
-  function regexpCode(rx) {
-    return new _Code(rx.toString());
+  writeFileSync2(join2(memoryDir, ".sync-state.json"), JSON.stringify(state, null, 2));
+}
+function writeEntityFile(entity, memoryDir) {
+  const dir = entityToDirectoryPath(entity, memoryDir);
+  if (!existsSync2(dir))
+    mkdirSync2(dir, { recursive: true });
+  const filename = entityToFilename(entity);
+  const filePath = join2(dir, filename);
+  const markdown = serializeSyncMarkdown(entity);
+  writeFileSync2(filePath, markdown);
+  return relative(memoryDir, filePath);
+}
+function deleteEntityFile(relPath, memoryDir) {
+  const absPath = join2(memoryDir, relPath);
+  if (existsSync2(absPath)) {
+    rmSync(absPath);
   }
-  exports.regexpCode = regexpCode;
-});
-
-// ../../node_modules/ajv/dist/compile/codegen/scope.js
-var require_scope = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = undefined;
-  var code_1 = require_code();
-
-  class ValueError extends Error {
-    constructor(name) {
-      super(`CodeGen: "code" for ${name} not defined`);
-      this.value = name.value;
+}
+function findMarkdownFiles(dir) {
+  const results = [];
+  if (!existsSync2(dir))
+    return results;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findMarkdownFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      results.push(fullPath);
     }
   }
-  var UsedValueState;
-  (function(UsedValueState2) {
-    UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
-    UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
-  })(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
-  exports.varKinds = {
-    const: new code_1.Name("const"),
-    let: new code_1.Name("let"),
-    var: new code_1.Name("var")
+  return results;
+}
+async function syncPull(client, config, workspaceId, projectId) {
+  const { memoryDir } = config;
+  const state = loadSyncState(memoryDir);
+  const result = {
+    pulled: 0,
+    pushed: 0,
+    deleted: 0,
+    conflicts: 0,
+    errors: []
   };
-
-  class Scope {
-    constructor({ prefixes, parent } = {}) {
-      this._names = {};
-      this._prefixes = prefixes;
-      this._parent = parent;
-    }
-    toName(nameOrPrefix) {
-      return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
-    }
-    name(prefix) {
-      return new code_1.Name(this._newName(prefix));
-    }
-    _newName(prefix) {
-      const ng = this._names[prefix] || this._nameGroup(prefix);
-      return `${prefix}${ng.index++}`;
-    }
-    _nameGroup(prefix) {
-      var _a2, _b;
-      if (((_b = (_a2 = this._parent) === null || _a2 === undefined ? undefined : _a2._prefixes) === null || _b === undefined ? undefined : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) {
-        throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
-      }
+  const allEntities = [];
+  let offset = 0;
+  const batchSize = 100;
+  while (true) {
+    try {
+      const resp = await client.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: batchSize,
+        offset
+      });
+      const batch = resp.entities;
+      allEntities.push(...batch);
+      if (batch.length < batchSize)
+        break;
+      offset += batchSize;
+    } catch (err) {
+      result.errors.push(`Failed to fetch entities: ${err}`);
+      return result;
+    }
+  }
+  const remoteIds = new Set(allEntities.map((e) => e.id));
+  for (const entity of allEntities) {
+    const existing = state.entities[entity.id];
+    const markdown = serializeSyncMarkdown(entity);
+    const hash = computeFileHash(markdown);
+    if (!existing) {
+      const relPath = writeEntityFile(entity, memoryDir);
+      state.entities[entity.id] = {
+        filePath: relPath,
+        remoteUpdatedAt: entity.updated_at,
+        lastSyncedHash: hash
+      };
+      result.pulled++;
+    } else {
+      const remoteChanged = entity.updated_at > existing.remoteUpdatedAt;
+      if (!remoteChanged)
+        continue;
+      const absPath = join2(memoryDir, existing.filePath);
+      let localChanged = false;
+      if (existsSync2(absPath)) {
+        const localContent = readFileSync2(absPath, "utf-8");
+        const localHash = computeFileHash(localContent);
+        localChanged = localHash !== existing.lastSyncedHash;
+      }
+      if (localChanged) {
+        result.conflicts++;
+      }
+      const newRelPath = writeEntityFile(entity, memoryDir);
+      if (existing.filePath !== newRelPath) {
+        deleteEntityFile(existing.filePath, memoryDir);
+      }
+      state.entities[entity.id] = {
+        filePath: newRelPath,
+        remoteUpdatedAt: entity.updated_at,
+        lastSyncedHash: hash
+      };
+      result.pulled++;
+    }
+  }
+  for (const [entityId, entry] of Object.entries(state.entities)) {
+    if (!remoteIds.has(entityId)) {
+      deleteEntityFile(entry.filePath, memoryDir);
+      delete state.entities[entityId];
+      result.deleted++;
+    }
+  }
+  state.lastPullAt = new Date().toISOString();
+  saveSyncState(memoryDir, state);
+  return result;
+}
+async function syncPush(client, config, workspaceId) {
+  const { memoryDir } = config;
+  const state = loadSyncState(memoryDir);
+  const result = {
+    pulled: 0,
+    pushed: 0,
+    deleted: 0,
+    conflicts: 0,
+    errors: []
+  };
+  const mdFiles = findMarkdownFiles(memoryDir);
+  for (const absPath of mdFiles) {
+    const content = readFileSync2(absPath, "utf-8");
+    const hash = computeFileHash(content);
+    const parsed = parseSyncMarkdown(content);
+    if (parsed.frontmatter.id) {
+      const entityId = parsed.frontmatter.id;
+      const existing = state.entities[entityId];
+      if (existing && hash === existing.lastSyncedHash)
+        continue;
+      try {
+        const resp = await client.updateMemoryEntity(entityId, {
+          title: parsed.title || "Untitled",
+          content: parsed.content,
+          type: parsed.frontmatter.type,
+          scope: parsed.frontmatter.scope,
+          confidence: parsed.frontmatter.confidence,
+          tags: parsed.frontmatter.tags
+        });
+        const updated = resp.entity;
+        const newMarkdown = serializeSyncMarkdown(updated);
+        writeFileSync2(absPath, newMarkdown);
+        const relPath = relative(memoryDir, absPath);
+        state.entities[entityId] = {
+          filePath: relPath,
+          remoteUpdatedAt: updated.updated_at,
+          lastSyncedHash: computeFileHash(newMarkdown)
+        };
+        result.pushed++;
+      } catch (err) {
+        result.errors.push(`Failed to update ${entityId}: ${err}`);
+      }
+    } else {
+      const relPath = relative(memoryDir, absPath);
+      const parts = relPath.split(sep);
+      const fileWorkspaceId = parts.length >= 2 ? parts[0] : workspaceId;
+      let fileProjectId;
+      if (parts.length >= 3) {
+        const scopeDir = parts[1];
+        if (scopeDir !== "_workspace" && scopeDir !== "_private") {
+          fileProjectId = scopeDir;
+        }
+      }
+      let scope = parsed.frontmatter.scope || "project";
+      if (parts.length >= 3) {
+        const scopeDir = parts[1];
+        if (scopeDir === "_private")
+          scope = "private";
+        else if (scopeDir === "_workspace")
+          scope = "workspace";
+      }
+      try {
+        const resp = await client.createMemoryEntity({
+          workspace_id: fileWorkspaceId,
+          project_id: fileProjectId,
+          type: parsed.frontmatter.type,
+          scope,
+          title: parsed.title || "Untitled",
+          content: parsed.content,
+          confidence: parsed.frontmatter.confidence,
+          tags: parsed.frontmatter.tags,
+          agent_identifier: parsed.frontmatter.agent
+        });
+        const created = resp.entity;
+        const dir = entityToDirectoryPath(created, memoryDir);
+        if (!existsSync2(dir))
+          mkdirSync2(dir, { recursive: true });
+        const newFilename = entityToFilename(created);
+        const newAbsPath = join2(dir, newFilename);
+        const newMarkdown = serializeSyncMarkdown(created);
+        writeFileSync2(newAbsPath, newMarkdown);
+        if (absPath !== newAbsPath && existsSync2(absPath)) {
+          rmSync(absPath);
+        }
+        const newRelPath = relative(memoryDir, newAbsPath);
+        state.entities[created.id] = {
+          filePath: newRelPath,
+          remoteUpdatedAt: created.updated_at,
+          lastSyncedHash: computeFileHash(newMarkdown)
+        };
+        result.pushed++;
+      } catch (err) {
+        result.errors.push(`Failed to create entity from ${relPath}: ${err}`);
+      }
+    }
+  }
+  saveSyncState(memoryDir, state);
+  return result;
+}
+async function syncFull(client, config, workspaceId, projectId) {
+  const pullResult = await syncPull(client, config, workspaceId, projectId);
+  const pushResult = await syncPush(client, config, workspaceId);
+  return {
+    pulled: pullResult.pulled,
+    pushed: pushResult.pushed,
+    deleted: pullResult.deleted,
+    conflicts: pullResult.conflicts,
+    errors: [...pullResult.errors, ...pushResult.errors]
+  };
+}
+var init_sync = () => {};
+
+// ../memory/src/index.ts
+var init_src = __esm(() => {
+  init_client();
+  init_constraints();
+  init_lifecycle();
+  init_schema();
+  init_sync();
+});
+
+// ../../node_modules/ajv/dist/compile/codegen/code.js
+var require_code = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = undefined;
+
+  class _CodeOrName {
+  }
+  exports._CodeOrName = _CodeOrName;
+  exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+
+  class Name extends _CodeOrName {
+    constructor(s) {
+      super();
+      if (!exports.IDENTIFIER.test(s))
+        throw new Error("CodeGen: name must be a valid identifier");
+      this.str = s;
+    }
+    toString() {
+      return this.str;
+    }
+    emptyStr() {
+      return false;
+    }
+    get names() {
+      return { [this.str]: 1 };
+    }
+  }
+  exports.Name = Name;
+
+  class _Code extends _CodeOrName {
+    constructor(code) {
+      super();
+      this._items = typeof code === "string" ? [code] : code;
+    }
+    toString() {
+      return this.str;
+    }
+    emptyStr() {
+      if (this._items.length > 1)
+        return false;
+      const item = this._items[0];
+      return item === "" || item === '""';
+    }
+    get str() {
+      var _a2;
+      return (_a2 = this._str) !== null && _a2 !== undefined ? _a2 : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
+    }
+    get names() {
+      var _a2;
+      return (_a2 = this._names) !== null && _a2 !== undefined ? _a2 : this._names = this._items.reduce((names, c) => {
+        if (c instanceof Name)
+          names[c.str] = (names[c.str] || 0) + 1;
+        return names;
+      }, {});
+    }
+  }
+  exports._Code = _Code;
+  exports.nil = new _Code("");
+  function _(strs, ...args) {
+    const code = [strs[0]];
+    let i = 0;
+    while (i < args.length) {
+      addCodeArg(code, args[i]);
+      code.push(strs[++i]);
+    }
+    return new _Code(code);
+  }
+  exports._ = _;
+  var plus = new _Code("+");
+  function str(strs, ...args) {
+    const expr = [safeStringify(strs[0])];
+    let i = 0;
+    while (i < args.length) {
+      expr.push(plus);
+      addCodeArg(expr, args[i]);
+      expr.push(plus, safeStringify(strs[++i]));
+    }
+    optimize(expr);
+    return new _Code(expr);
+  }
+  exports.str = str;
+  function addCodeArg(code, arg) {
+    if (arg instanceof _Code)
+      code.push(...arg._items);
+    else if (arg instanceof Name)
+      code.push(arg);
+    else
+      code.push(interpolate(arg));
+  }
+  exports.addCodeArg = addCodeArg;
+  function optimize(expr) {
+    let i = 1;
+    while (i < expr.length - 1) {
+      if (expr[i] === plus) {
+        const res = mergeExprItems(expr[i - 1], expr[i + 1]);
+        if (res !== undefined) {
+          expr.splice(i - 1, 3, res);
+          continue;
+        }
+        expr[i++] = "+";
+      }
+      i++;
+    }
+  }
+  function mergeExprItems(a, b) {
+    if (b === '""')
+      return a;
+    if (a === '""')
+      return b;
+    if (typeof a == "string") {
+      if (b instanceof Name || a[a.length - 1] !== '"')
+        return;
+      if (typeof b != "string")
+        return `${a.slice(0, -1)}${b}"`;
+      if (b[0] === '"')
+        return a.slice(0, -1) + b.slice(1);
+      return;
+    }
+    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
+      return `"${a}${b.slice(1)}`;
+    return;
+  }
+  function strConcat(c1, c2) {
+    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
+  }
+  exports.strConcat = strConcat;
+  function interpolate(x) {
+    return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
+  }
+  function stringify(x) {
+    return new _Code(safeStringify(x));
+  }
+  exports.stringify = stringify;
+  function safeStringify(x) {
+    return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  }
+  exports.safeStringify = safeStringify;
+  function getProperty(key) {
+    return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
+  }
+  exports.getProperty = getProperty;
+  function getEsmExportName(key) {
+    if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
+      return new _Code(`${key}`);
+    }
+    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
+  }
+  exports.getEsmExportName = getEsmExportName;
+  function regexpCode(rx) {
+    return new _Code(rx.toString());
+  }
+  exports.regexpCode = regexpCode;
+});
+
+// ../../node_modules/ajv/dist/compile/codegen/scope.js
+var require_scope = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = undefined;
+  var code_1 = require_code();
+
+  class ValueError extends Error {
+    constructor(name) {
+      super(`CodeGen: "code" for ${name} not defined`);
+      this.value = name.value;
+    }
+  }
+  var UsedValueState;
+  (function(UsedValueState2) {
+    UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
+    UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
+  })(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
+  exports.varKinds = {
+    const: new code_1.Name("const"),
+    let: new code_1.Name("let"),
+    var: new code_1.Name("var")
+  };
+
+  class Scope {
+    constructor({ prefixes, parent } = {}) {
+      this._names = {};
+      this._prefixes = prefixes;
+      this._parent = parent;
+    }
+    toName(nameOrPrefix) {
+      return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
+    }
+    name(prefix) {
+      return new code_1.Name(this._newName(prefix));
+    }
+    _newName(prefix) {
+      const ng = this._names[prefix] || this._nameGroup(prefix);
+      return `${prefix}${ng.index++}`;
+    }
+    _nameGroup(prefix) {
+      var _a2, _b;
+      if (((_b = (_a2 = this._parent) === null || _a2 === undefined ? undefined : _a2._prefixes) === null || _b === undefined ? undefined : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) {
+        throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
+      }
       return this._names[prefix] = { prefix, index: 0 };
     }
   }
@@ -8452,136 +9030,1083 @@ var require_formats = __commonJS((exports) => {
     BYTE.lastIndex = 0;
     return BYTE.test(str);
   }
-  var MIN_INT32 = -(2 ** 31);
-  var MAX_INT32 = 2 ** 31 - 1;
-  function validateInt32(value) {
-    return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
+  var MIN_INT32 = -(2 ** 31);
+  var MAX_INT32 = 2 ** 31 - 1;
+  function validateInt32(value) {
+    return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
+  }
+  function validateInt64(value) {
+    return Number.isInteger(value);
+  }
+  function validateNumber() {
+    return true;
+  }
+  var Z_ANCHOR = /[^\\]\\Z/;
+  function regex(str) {
+    if (Z_ANCHOR.test(str))
+      return false;
+    try {
+      new RegExp(str);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+});
+
+// ../../node_modules/ajv-formats/dist/limit.js
+var require_limit = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.formatLimitDefinition = undefined;
+  var ajv_1 = require_ajv();
+  var codegen_1 = require_codegen();
+  var ops = codegen_1.operators;
+  var KWDs = {
+    formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
+    formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
+    formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
+    formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
+  };
+  var error48 = {
+    message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
+    params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
+  };
+  exports.formatLimitDefinition = {
+    keyword: Object.keys(KWDs),
+    type: "string",
+    schemaType: "string",
+    $data: true,
+    error: error48,
+    code(cxt) {
+      const { gen, data, schemaCode, keyword, it } = cxt;
+      const { opts, self } = it;
+      if (!opts.validateFormats)
+        return;
+      const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
+      if (fCxt.$data)
+        validate$DataFormat();
+      else
+        validateFormat();
+      function validate$DataFormat() {
+        const fmts = gen.scopeValue("formats", {
+          ref: self.formats,
+          code: opts.code.formats
+        });
+        const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
+        cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
+      }
+      function validateFormat() {
+        const format = fCxt.schema;
+        const fmtDef = self.formats[format];
+        if (!fmtDef || fmtDef === true)
+          return;
+        if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
+          throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
+        }
+        const fmt = gen.scopeValue("formats", {
+          key: format,
+          ref: fmtDef,
+          code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : undefined
+        });
+        cxt.fail$data(compareCode(fmt));
+      }
+      function compareCode(fmt) {
+        return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
+      }
+    },
+    dependencies: ["format"]
+  };
+  var formatLimitPlugin = (ajv) => {
+    ajv.addKeyword(exports.formatLimitDefinition);
+    return ajv;
+  };
+  exports.default = formatLimitPlugin;
+});
+
+// ../../node_modules/ajv-formats/dist/index.js
+var require_dist = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var formats_1 = require_formats();
+  var limit_1 = require_limit();
+  var codegen_1 = require_codegen();
+  var fullName = new codegen_1.Name("fullFormats");
+  var fastName = new codegen_1.Name("fastFormats");
+  var formatsPlugin = (ajv, opts = { keywords: true }) => {
+    if (Array.isArray(opts)) {
+      addFormats(ajv, opts, formats_1.fullFormats, fullName);
+      return ajv;
+    }
+    const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
+    const list = opts.formats || formats_1.formatNames;
+    addFormats(ajv, list, formats, exportName);
+    if (opts.keywords)
+      (0, limit_1.default)(ajv);
+    return ajv;
+  };
+  formatsPlugin.get = (name, mode = "full") => {
+    const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats;
+    const f = formats[name];
+    if (!f)
+      throw new Error(`Unknown format "${name}"`);
+    return f;
+  };
+  function addFormats(ajv, list, fs, exportName) {
+    var _a2;
+    var _b;
+    (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
+    for (const f of list)
+      ajv.addFormat(f, fs[f]);
+  }
+  module.exports = exports = formatsPlugin;
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.default = formatsPlugin;
+});
+
+// src/context-assembly.ts
+var exports_context_assembly = {};
+__export(exports_context_assembly, {
+  trackSessionAssembly: () => trackSessionAssembly,
+  recordContextFeedback: () => recordContextFeedback,
+  mapToContextEntity: () => mapToContextEntity,
+  getSessionAssemblyId: () => getSessionAssemblyId,
+  getCachedManifest: () => getCachedManifest,
+  computeRelevanceScore: () => computeRelevanceScore,
+  cacheManifest: () => cacheManifest,
+  assembleContext: () => assembleContext
+});
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function generateAssemblyId() {
+  return `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function truncateContent(content, maxTokens) {
+  const currentTokens = 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 computeRelevanceScore(entity, taskContext, cardLabels) {
+  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");
+  }
+  score = 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
+  } = options;
+  const assemblyId = generateAssemblyId();
+  const manifest = {
+    assemblyId,
+    timestamp: new Date().toISOString(),
+    included: [],
+    excluded: [],
+    budgetUsed: 0,
+    budgetTotal: tokenBudget,
+    tierBreakdown: {
+      draft: { count: 0, tokens: 0 },
+      episode: { count: 0, tokens: 0 },
+      reference: { count: 0, tokens: 0 }
+    }
+  };
+  let candidates = [];
+  try {
+    const searchResult = await client2.searchMemoryEntities(workspaceId, taskContext, { project_id: projectId, limit: 30 });
+    if (searchResult.entities?.length > 0) {
+      candidates = searchResult.entities.map(mapToContextEntity);
+    }
+  } catch {}
+  if (candidates.length < 10 && projectId) {
+    try {
+      const listResult = await client2.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: 30
+      });
+      if (listResult.entities?.length > 0) {
+        const existingIds = new Set(candidates.map((c) => c.id));
+        const additional = listResult.entities.map(mapToContextEntity).filter((e) => !existingIds.has(e.id));
+        candidates.push(...additional);
+      }
+    } catch {}
+  }
+  if (candidates.length < 20) {
+    try {
+      const wsResult = await client2.listMemoryEntities({
+        workspace_id: workspaceId,
+        scope: "workspace",
+        limit: 20
+      });
+      if (wsResult.entities?.length > 0) {
+        const existingIds = new Set(candidates.map((c) => c.id));
+        const additional = wsResult.entities.map(mapToContextEntity).filter((e) => !existingIds.has(e.id));
+        candidates.push(...additional);
+      }
+    } catch {}
+  }
+  if (candidates.length === 0) {
+    return {
+      context: "",
+      manifest,
+      memories: []
+    };
+  }
+  const scored = candidates.map((entity) => {
+    const { score, reasons } = computeRelevanceScore(entity, taskContext, cardLabels);
+    return { entity, score, reasons };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const 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"
+        });
+        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"
+        });
+        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 {}
+    }
+  }
+}
+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()
+          }
+        });
+        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()
+          }
+        });
+        adjusted++;
+      }
+    } catch {}
+  }
+  sessionAssemblyMap.delete(cardId);
+  return { adjusted };
+}
+var DEFAULT_TOKEN_BUDGET = 4000, MAX_TOKENS_PER_ENTITY = 500, MIN_RELEVANCE_THRESHOLD = 0.1, TIER_WEIGHTS, PROCEDURE_BUDGET_FRACTION = 0.15, TIER_BUDGET_ALLOCATION, MIN_REFERENCE_SLOTS = 3, manifestCache, MAX_CACHE_SIZE = 50, sessionAssemblyMap, MAX_SESSION_MAP_SIZE = 100;
+var init_context_assembly = __esm(() => {
+  init_src();
+  TIER_WEIGHTS = {
+    reference: 1,
+    episode: 0.7,
+    draft: 0.4
+  };
+  TIER_BUDGET_ALLOCATION = {
+    reference: 0.6,
+    episode: 0.3,
+    draft: 0.1
+  };
+  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:** When you discover important domain knowledge, architectural decisions, or infrastructure details, store them via \`harmony_remember\`. Focus on durable knowledge that future agents would benefit from — not ephemeral task details (those are auto-extracted from your 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).`;
+    }
   }
-  function validateInt64(value) {
-    return Number.isInteger(value);
+  if (session?.procedureNextStep) {
+    return `Follow procedure: ${session.procedureNextStep}`;
   }
-  function validateNumber() {
-    return true;
+  if (session?.lastSessionStatus === "completed" && session.lastSessionTask) {
+    return `Previous session completed ("${session.lastSessionTask}"). Review results and continue with remaining work.`;
   }
-  var Z_ANCHOR = /[^\\]\\Z/;
-  function regex(str) {
-    if (Z_ANCHOR.test(str))
-      return false;
-    try {
-      new RegExp(str);
-      return true;
-    } catch (e) {
-      return false;
-    }
+  if (card.due_date && (card.priority === "urgent" || card.priority === "high")) {
+    return `High-priority task with deadline ${card.due_date}. Start implementation immediately.`;
   }
-});
-
-// ../../node_modules/ajv-formats/dist/limit.js
-var require_limit = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.formatLimitDefinition = undefined;
-  var ajv_1 = require_ajv();
-  var codegen_1 = require_codegen();
-  var ops = codegen_1.operators;
-  var KWDs = {
-    formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
-    formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
-    formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
-    formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
-  };
-  var error48 = {
-    message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
-    params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
-  };
-  exports.formatLimitDefinition = {
-    keyword: Object.keys(KWDs),
-    type: "string",
-    schemaType: "string",
-    $data: true,
-    error: error48,
-    code(cxt) {
-      const { gen, data, schemaCode, keyword, it } = cxt;
-      const { opts, self } = it;
-      if (!opts.validateFormats)
-        return;
-      const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
-      if (fCxt.$data)
-        validate$DataFormat();
-      else
-        validateFormat();
-      function validate$DataFormat() {
-        const fmts = gen.scopeValue("formats", {
-          ref: self.formats,
-          code: opts.code.formats
-        });
-        const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
-        cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
-      }
-      function validateFormat() {
-        const format = fCxt.schema;
-        const fmtDef = self.formats[format];
-        if (!fmtDef || fmtDef === true)
-          return;
-        if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
-          throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
-        }
-        const fmt = gen.scopeValue("formats", {
-          key: format,
-          ref: fmtDef,
-          code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : undefined
-        });
-        cxt.fail$data(compareCode(fmt));
-      }
-      function compareCode(fmt) {
-        return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
-      }
+  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"
+      ]
     },
-    dependencies: ["format"]
-  };
-  var formatLimitPlugin = (ajv) => {
-    ajv.addKeyword(exports.formatLimitDefinition);
-    return ajv;
-  };
-  exports.default = formatLimitPlugin;
-});
-
-// ../../node_modules/ajv-formats/dist/index.js
-var require_dist = __commonJS((exports, module) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  var formats_1 = require_formats();
-  var limit_1 = require_limit();
-  var codegen_1 = require_codegen();
-  var fullName = new codegen_1.Name("fullFormats");
-  var fastName = new codegen_1.Name("fastFormats");
-  var formatsPlugin = (ajv, opts = { keywords: true }) => {
-    if (Array.isArray(opts)) {
-      addFormats(ajv, opts, formats_1.fullFormats, fullName);
-      return ajv;
+    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"
+      ]
     }
-    const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
-    const list = opts.formats || formats_1.formatNames;
-    addFormats(ajv, list, formats, exportName);
-    if (opts.keywords)
-      (0, limit_1.default)(ajv);
-    return ajv;
   };
-  formatsPlugin.get = (name, mode = "full") => {
-    const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats;
-    const f = formats[name];
-    if (!f)
-      throw new Error(`Unknown format "${name}"`);
-    return f;
+  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.`
   };
-  function addFormats(ajv, list, fs, exportName) {
-    var _a2;
-    var _b;
-    (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
-    for (const f of list)
-      ajv.addFormat(f, fs[f]);
-  }
-  module.exports = exports = formatsPlugin;
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.default = formatsPlugin;
 });
 
 // ../../node_modules/sisteransi/src/index.js
@@ -8724,751 +10249,201 @@ var {
   createOption,
   CommanderError,
   InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
-
-// 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://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 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");
-}
-// ../memory/src/graph-walk.ts
-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
-          });
-        }
-      }
-      for (const raw of related.incoming || []) {
-        const rel = raw;
-        const relConfidence = rel.confidence ?? 1;
-        if (relConfidence < minConfidence)
-          continue;
-        const source = rel.source;
-        const sourceId = source?.id ?? rel.source_id;
-        if (sourceId && !visited.has(sourceId)) {
-          visited.add(sourceId);
-          queue.push([sourceId, depth + 1]);
-          collectedRelations.push({
-            id: rel.id,
-            source_id: sourceId,
-            target_id: entityId,
-            relation_type: rel.relation_type,
-            confidence: relConfidence
-          });
-        }
-      }
-    } catch {}
-  }
-  return {
-    entities: collectedEntities,
-    relations: collectedRelations,
-    depth: maxDepth,
-    truncated
-  };
-}
-// ../memory/src/lifecycle.ts
-var DECAY_HALF_LIVES = {
-  draft: 7,
-  episode: 30,
-  reference: 180
-};
-var PROMOTION_RULES = {
-  draftToEpisode: {
-    minAccessCount: 5,
-    minConfidence: 0.8,
-    minAgeDays: 1
-  },
-  episodeToReference: {
-    minAccessCount: 10,
-    minConfidence: 0.9,
-    minAgeDays: 7
-  }
-};
-var ARCHIVE_THRESHOLD = 0.3;
-var STALE_DAYS = 90;
-var STALE_MIN_ACCESS = 3;
-function computeDecayScore(tier, lastAccessedAt, accessCount) {
-  const halfLife = DECAY_HALF_LIVES[tier];
-  const now = Date.now();
-  let daysSinceAccess = 0;
-  if (lastAccessedAt) {
-    daysSinceAccess = (now - new Date(lastAccessedAt).getTime()) / (1000 * 60 * 60 * 24);
-  }
-  const timeDecay = 0.5 ** (daysSinceAccess / halfLife);
-  const accessBonus = Math.log10(accessCount + 1) * 0.1;
-  const score = Math.min(timeDecay + accessBonus, 1);
-  return { score, daysSinceAccess, halfLife, accessBonus };
-}
-function checkPromotion(currentTier, accessCount, confidence, createdAt) {
-  const ageDays = (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60 * 24);
-  const base = {
-    eligible: false,
-    targetTier: null,
-    reason: null,
-    currentTier,
-    accessCount,
-    confidence,
-    ageDays
-  };
-  if (currentTier === "draft") {
-    const rules = PROMOTION_RULES.draftToEpisode;
-    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
-      return {
-        ...base,
-        eligible: true,
-        targetTier: "episode",
-        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
-      };
-    }
-  }
-  if (currentTier === "episode") {
-    const rules = PROMOTION_RULES.episodeToReference;
-    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
-      return {
-        ...base,
-        eligible: true,
-        targetTier: "reference",
-        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
-      };
-    }
-  }
-  return base;
-}
-function evaluateLifecycle(entity) {
-  const decay = computeDecayScore(entity.memory_tier, entity.last_accessed_at, entity.access_count);
-  const promotion = checkPromotion(entity.memory_tier, entity.access_count, entity.confidence, entity.created_at);
-  const shouldArchive = entity.confidence < ARCHIVE_THRESHOLD;
-  const archiveReason = shouldArchive ? `Confidence ${entity.confidence} below threshold ${ARCHIVE_THRESHOLD}` : undefined;
-  const shouldFlagForReview = decay.daysSinceAccess >= STALE_DAYS && entity.access_count < STALE_MIN_ACCESS;
-  const reviewReason = shouldFlagForReview ? `Not accessed in ${Math.round(decay.daysSinceAccess)} days with only ${entity.access_count} accesses` : undefined;
-  return {
-    decay,
-    promotion,
-    shouldArchive,
-    shouldFlagForReview,
-    archiveReason,
-    reviewReason
-  };
-}
-// ../memory/src/sync.ts
-import { createHash } from "node:crypto";
-import {
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  readFileSync as readFileSync2,
-  rmSync,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import { join as join2, relative, sep } from "node:path";
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import__.default;
 
-// ../memory/src/sync-storage.ts
-function parseSyncMarkdown(markdown) {
-  const trimmed = markdown.trim();
-  let frontmatter = {
-    type: "context",
-    scope: "project",
-    tier: "reference",
-    confidence: 1,
-    tags: []
-  };
-  let body = trimmed;
-  const fmMatch = trimmed.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (fmMatch) {
-    frontmatter = parseSyncYamlFrontmatter(fmMatch[1]);
-    body = fmMatch[2].trim();
+// 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
+    };
   }
-  let title = "";
-  const titleMatch = body.match(/^#\s+(.+)/m);
-  if (titleMatch) {
-    title = titleMatch[1].trim();
-    body = body.replace(/^#\s+.+\n?/, "").trim();
+  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
+    };
   }
-  return { frontmatter, title, content: body };
 }
-function serializeSyncMarkdown(entity) {
-  const lines = ["---"];
-  lines.push(`id: ${entity.id}`);
-  lines.push(`workspace_id: ${entity.workspace_id}`);
-  if (entity.project_id) {
-    lines.push(`project_id: ${entity.project_id}`);
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 448 });
   }
-  lines.push(`type: ${entity.type}`);
-  lines.push(`scope: ${entity.scope}`);
-  lines.push(`tier: ${entity.memory_tier || "reference"}`);
-  lines.push(`confidence: ${entity.confidence}`);
-  if (entity.tags.length > 0) {
-    lines.push(`tags: [${entity.tags.join(", ")}]`);
-  } else {
-    lines.push("tags: []");
+  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;
   }
-  if (entity.agent_identifier) {
-    lines.push(`agent: ${entity.agent_identifier}`);
+  try {
+    const data = readFileSync(localConfigPath, "utf-8");
+    const config = JSON.parse(data);
+    return {
+      workspaceId: config.workspaceId || null,
+      projectId: config.projectId || null
+    };
+  } catch {
+    return null;
   }
-  lines.push(`created_at: ${entity.created_at}`);
-  lines.push(`updated_at: ${entity.updated_at}`);
-  lines.push("---");
-  lines.push("");
-  lines.push(`# ${entity.title}`);
-  lines.push("");
-  lines.push(entity.content);
-  return lines.join(`
-`);
 }
-function parseSyncYamlFrontmatter(yaml) {
-  const result = {
-    type: "context",
-    scope: "project",
-    tier: "reference",
-    confidence: 1,
-    tags: []
+function saveLocalConfig(config, cwd) {
+  const localConfigPath = getLocalConfigPath(cwd);
+  const existingConfig = loadLocalConfig(cwd) || {
+    workspaceId: null,
+    projectId: null
   };
-  for (const line of yaml.split(`
-`)) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1)
-      continue;
-    const key = line.slice(0, colonIndex).trim();
-    const value = line.slice(colonIndex + 1).trim();
-    switch (key) {
-      case "id":
-        result.id = value;
-        break;
-      case "workspace_id":
-        result.workspace_id = value;
-        break;
-      case "project_id":
-        result.project_id = value;
-        break;
-      case "type":
-        result.type = value;
-        break;
-      case "scope":
-        result.scope = value;
-        break;
-      case "tier":
-        result.tier = value;
-        break;
-      case "confidence":
-        result.confidence = parseFloat(value) || 1;
-        break;
-      case "tags":
-        result.tags = parseYamlArray(value);
-        break;
-      case "related":
-        result.related = parseYamlArray(value);
-        break;
-      case "agent":
-        result.agent = value;
-        break;
-      case "created_at":
-        result.created_at = value;
-        break;
-      case "updated_at":
-        result.updated_at = value;
-        break;
-    }
-  }
-  return result;
+  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 parseYamlArray(value) {
-  const match = value.match(/^\[(.*)]\s*$/);
-  if (!match)
-    return [];
-  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+function hasLocalConfig(cwd) {
+  return existsSync(getLocalConfigPath(cwd));
 }
-
-// ../memory/src/sync.ts
-function computeFileHash(content) {
-  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+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 slugifyTitle(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+function getApiUrl() {
+  const config = loadConfig();
+  return config.apiUrl;
 }
-function entityToFilename(entity) {
-  const slug = slugifyTitle(entity.title);
-  const shortId = entity.id.slice(0, 8);
-  return `${entity.type}--${slug}--${shortId}.md`;
+function getUserEmail() {
+  const config = loadConfig();
+  return config.userEmail;
 }
-function entityToDirectoryPath(entity, memoryDir) {
-  const wsDir = join2(memoryDir, entity.workspace_id);
-  if (entity.scope === "private") {
-    return join2(wsDir, "_private");
-  }
-  if (entity.scope === "workspace" || !entity.project_id) {
-    return join2(wsDir, "_workspace");
+function setActiveWorkspace(workspaceId, options) {
+  if (options?.local) {
+    saveLocalConfig({ workspaceId }, options.cwd);
+  } else {
+    saveConfig({ activeWorkspaceId: workspaceId });
   }
-  return join2(wsDir, entity.project_id);
 }
-function emptySyncState() {
-  return { version: 1, lastPullAt: null, entities: {} };
+function setActiveProject(projectId, options) {
+  if (options?.local) {
+    saveLocalConfig({ projectId }, options.cwd);
+  } else {
+    saveConfig({ activeProjectId: projectId });
+  }
 }
-function loadSyncState(memoryDir) {
-  const statePath = join2(memoryDir, ".sync-state.json");
-  if (!existsSync2(statePath))
-    return emptySyncState();
-  try {
-    return JSON.parse(readFileSync2(statePath, "utf-8"));
-  } catch {
-    return emptySyncState();
+function getActiveWorkspaceId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.workspaceId) {
+    return localConfig.workspaceId;
   }
+  return loadConfig().activeWorkspaceId;
 }
-function saveSyncState(memoryDir, state) {
-  if (!existsSync2(memoryDir)) {
-    mkdirSync2(memoryDir, { recursive: true });
+function getActiveProjectId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.projectId) {
+    return localConfig.projectId;
   }
-  writeFileSync2(join2(memoryDir, ".sync-state.json"), JSON.stringify(state, null, 2));
+  return loadConfig().activeProjectId;
 }
-function writeEntityFile(entity, memoryDir) {
-  const dir = entityToDirectoryPath(entity, memoryDir);
-  if (!existsSync2(dir))
-    mkdirSync2(dir, { recursive: true });
-  const filename = entityToFilename(entity);
-  const filePath = join2(dir, filename);
-  const markdown = serializeSyncMarkdown(entity);
-  writeFileSync2(filePath, markdown);
-  return relative(memoryDir, filePath);
+function isConfigured() {
+  const config = loadConfig();
+  return !!config.apiKey;
 }
-function deleteEntityFile(relPath, memoryDir) {
-  const absPath = join2(memoryDir, relPath);
-  if (existsSync2(absPath)) {
-    rmSync(absPath);
+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 };
   }
-}
-function findMarkdownFiles(dir) {
-  const results = [];
-  if (!existsSync2(dir))
-    return results;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...findMarkdownFiles(fullPath));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      results.push(fullPath);
-    }
+  const claudeGlobalSkill = join(home, ".claude", "skills", "hmy.md");
+  if (existsSync(claudeGlobalSkill)) {
+    foundPaths.push(claudeGlobalSkill);
+    return { installed: true, location: "global", paths: foundPaths };
   }
-  return results;
-}
-async function syncPull(client, config, workspaceId, projectId) {
-  const { memoryDir } = config;
-  const state = loadSyncState(memoryDir);
-  const result = {
-    pulled: 0,
-    pushed: 0,
-    deleted: 0,
-    conflicts: 0,
-    errors: []
-  };
-  const allEntities = [];
-  let offset = 0;
-  const batchSize = 100;
-  while (true) {
-    try {
-      const resp = await client.listMemoryEntities({
-        workspace_id: workspaceId,
-        project_id: projectId,
-        limit: batchSize,
-        offset
-      });
-      const batch = resp.entities;
-      allEntities.push(...batch);
-      if (batch.length < batchSize)
-        break;
-      offset += batchSize;
-    } catch (err) {
-      result.errors.push(`Failed to fetch entities: ${err}`);
-      return result;
-    }
+  const claudeGlobalSkillAlt = join(home, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(claudeGlobalSkillAlt)) {
+    foundPaths.push(claudeGlobalSkillAlt);
+    return { installed: true, location: "global", paths: foundPaths };
   }
-  const remoteIds = new Set(allEntities.map((e) => e.id));
-  for (const entity of allEntities) {
-    const existing = state.entities[entity.id];
-    const markdown = serializeSyncMarkdown(entity);
-    const hash = computeFileHash(markdown);
-    if (!existing) {
-      const relPath = writeEntityFile(entity, memoryDir);
-      state.entities[entity.id] = {
-        filePath: relPath,
-        remoteUpdatedAt: entity.updated_at,
-        lastSyncedHash: hash
-      };
-      result.pulled++;
-    } else {
-      const remoteChanged = entity.updated_at > existing.remoteUpdatedAt;
-      if (!remoteChanged)
-        continue;
-      const absPath = join2(memoryDir, existing.filePath);
-      let localChanged = false;
-      if (existsSync2(absPath)) {
-        const localContent = readFileSync2(absPath, "utf-8");
-        const localHash = computeFileHash(localContent);
-        localChanged = localHash !== existing.lastSyncedHash;
-      }
-      if (localChanged) {
-        result.conflicts++;
-      }
-      const newRelPath = writeEntityFile(entity, memoryDir);
-      if (existing.filePath !== newRelPath) {
-        deleteEntityFile(existing.filePath, memoryDir);
-      }
-      state.entities[entity.id] = {
-        filePath: newRelPath,
-        remoteUpdatedAt: entity.updated_at,
-        lastSyncedHash: hash
-      };
-      result.pulled++;
-    }
+  const localSkillPath = join(workingDir, ".claude", "skills", "hmy.md");
+  if (existsSync(localSkillPath)) {
+    foundPaths.push(localSkillPath);
+    return { installed: true, location: "local", paths: foundPaths };
   }
-  for (const [entityId, entry] of Object.entries(state.entities)) {
-    if (!remoteIds.has(entityId)) {
-      deleteEntityFile(entry.filePath, memoryDir);
-      delete state.entities[entityId];
-      result.deleted++;
-    }
+  const localSkillPathAlt = join(workingDir, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(localSkillPathAlt)) {
+    foundPaths.push(localSkillPathAlt);
+    return { installed: true, location: "local", paths: foundPaths };
   }
-  state.lastPullAt = new Date().toISOString();
-  saveSyncState(memoryDir, state);
-  return result;
+  return { installed: false, location: null, paths: [] };
 }
-async function syncPush(client, config, workspaceId) {
-  const { memoryDir } = config;
-  const state = loadSyncState(memoryDir);
-  const result = {
-    pulled: 0,
-    pushed: 0,
-    deleted: 0,
-    conflicts: 0,
-    errors: []
-  };
-  const mdFiles = findMarkdownFiles(memoryDir);
-  for (const absPath of mdFiles) {
-    const content = readFileSync2(absPath, "utf-8");
-    const hash = computeFileHash(content);
-    const parsed = parseSyncMarkdown(content);
-    if (parsed.frontmatter.id) {
-      const entityId = parsed.frontmatter.id;
-      const existing = state.entities[entityId];
-      if (existing && hash === existing.lastSyncedHash)
-        continue;
-      try {
-        const resp = await client.updateMemoryEntity(entityId, {
-          title: parsed.title || "Untitled",
-          content: parsed.content,
-          type: parsed.frontmatter.type,
-          scope: parsed.frontmatter.scope,
-          confidence: parsed.frontmatter.confidence,
-          tags: parsed.frontmatter.tags
-        });
-        const updated = resp.entity;
-        const newMarkdown = serializeSyncMarkdown(updated);
-        writeFileSync2(absPath, newMarkdown);
-        const relPath = relative(memoryDir, absPath);
-        state.entities[entityId] = {
-          filePath: relPath,
-          remoteUpdatedAt: updated.updated_at,
-          lastSyncedHash: computeFileHash(newMarkdown)
-        };
-        result.pushed++;
-      } catch (err) {
-        result.errors.push(`Failed to update ${entityId}: ${err}`);
-      }
-    } else {
-      const relPath = relative(memoryDir, absPath);
-      const parts = relPath.split(sep);
-      const fileWorkspaceId = parts.length >= 2 ? parts[0] : workspaceId;
-      let fileProjectId;
-      if (parts.length >= 3) {
-        const scopeDir = parts[1];
-        if (scopeDir !== "_workspace" && scopeDir !== "_private") {
-          fileProjectId = scopeDir;
-        }
-      }
-      let scope = parsed.frontmatter.scope || "project";
-      if (parts.length >= 3) {
-        const scopeDir = parts[1];
-        if (scopeDir === "_private")
-          scope = "private";
-        else if (scopeDir === "_workspace")
-          scope = "workspace";
-      }
-      try {
-        const resp = await client.createMemoryEntity({
-          workspace_id: fileWorkspaceId,
-          project_id: fileProjectId,
-          type: parsed.frontmatter.type,
-          scope,
-          title: parsed.title || "Untitled",
-          content: parsed.content,
-          confidence: parsed.frontmatter.confidence,
-          tags: parsed.frontmatter.tags,
-          agent_identifier: parsed.frontmatter.agent
-        });
-        const created = resp.entity;
-        const dir = entityToDirectoryPath(created, memoryDir);
-        if (!existsSync2(dir))
-          mkdirSync2(dir, { recursive: true });
-        const newFilename = entityToFilename(created);
-        const newAbsPath = join2(dir, newFilename);
-        const newMarkdown = serializeSyncMarkdown(created);
-        writeFileSync2(newAbsPath, newMarkdown);
-        if (absPath !== newAbsPath && existsSync2(absPath)) {
-          rmSync(absPath);
-        }
-        const newRelPath = relative(memoryDir, newAbsPath);
-        state.entities[created.id] = {
-          filePath: newRelPath,
-          remoteUpdatedAt: created.updated_at,
-          lastSyncedHash: computeFileHash(newMarkdown)
-        };
-        result.pushed++;
-      } catch (err) {
-        result.errors.push(`Failed to create entity from ${relPath}: ${err}`);
-      }
-    }
-  }
-  saveSyncState(memoryDir, state);
-  return result;
+function hasProjectContext(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  return !!(localConfig?.workspaceId || localConfig?.projectId);
 }
-async function syncFull(client, config, workspaceId, projectId) {
-  const pullResult = await syncPull(client, config, workspaceId, projectId);
-  const pushResult = await syncPush(client, config, workspaceId);
-  return {
-    pulled: pullResult.pulled,
-    pushed: pushResult.pushed,
-    deleted: pullResult.deleted,
-    conflicts: pullResult.conflicts,
-    errors: [...pullResult.errors, ...pushResult.errors]
-  };
+function getMemoryDir() {
+  const config = loadConfig();
+  if (config.memoryDir)
+    return config.memoryDir;
+  return join(homedir(), ".harmony", "memory");
 }
+
+// src/server.ts
+init_src();
+
 // ../../node_modules/zod/v4/core/index.js
 var exports_core2 = {};
 __export(exports_core2, {
@@ -26600,6 +27575,100 @@ class HarmonyApiClient {
   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 };
+        }
+      } 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
+        });
+        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
+    };
+  }
+}
+var _promptModules = null;
+async function loadPromptModules() {
+  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() {
@@ -26613,6 +27682,28 @@ function resetClient() {
 }
 
 // src/auto-session.ts
+var CLIENT_DISPLAY_NAMES = {
+  "claude-code": "Claude Code",
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  windsurf: "Windsurf",
+  cline: "Cline",
+  continue: "Continue",
+  "codex-cli": "OpenAI Codex",
+  zed: "Zed",
+  "gemini-cli": "Gemini CLI"
+};
+function toIdentifier(name) {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+function resolveAgentIdentity(info) {
+  if (!info?.name) {
+    return { agentIdentifier: "unknown", agentName: "Unknown Agent" };
+  }
+  const key = toIdentifier(info.name);
+  const displayName = CLIENT_DISPLAY_NAMES[key] ?? info.name;
+  return { agentIdentifier: key, agentName: displayName };
+}
 var AUTO_START_TRIGGERS = new Set([
   "harmony_generate_prompt",
   "harmony_update_card",
@@ -26628,9 +27719,11 @@ var activeSessions = new Map;
 var inactivityTimer = null;
 var endCallback = null;
 var clientGetter = null;
-function initAutoSession(callback, getClient2) {
+var clientInfoGetter = null;
+function initAutoSession(callback, getClient2, getClientInfo) {
   endCallback = callback;
   clientGetter = getClient2;
+  clientInfoGetter = getClientInfo ?? null;
   if (inactivityTimer)
     clearInterval(inactivityTimer);
   inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
@@ -26656,10 +27749,12 @@ async function trackActivity(cardId, options) {
   for (const otherCardId of toEnd) {
     await autoEndSession(client3, otherCardId, "completed");
   }
+  const info = clientInfoGetter?.() ?? null;
+  const { agentIdentifier, agentName } = resolveAgentIdentity(info);
   try {
     await client3.startAgentSession(cardId, {
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
+      agentIdentifier,
+      agentName,
       status: "working"
     });
   } catch {}
@@ -26668,22 +27763,26 @@ async function trackActivity(cardId, options) {
     startedAt: now,
     lastActivityAt: now,
     isExplicit: false,
-    agentIdentifier: "auto",
-    agentName: "Auto-detected Agent"
+    agentIdentifier,
+    agentName
   });
 }
-function markExplicit(cardId) {
+function markExplicit(cardId, options) {
   const existing = activeSessions.get(cardId);
   if (existing) {
     existing.isExplicit = true;
+    if (options?.agentIdentifier)
+      existing.agentIdentifier = options.agentIdentifier;
+    if (options?.agentName)
+      existing.agentName = options.agentName;
   } else {
     activeSessions.set(cardId, {
       cardId,
       startedAt: Date.now(),
       lastActivityAt: Date.now(),
       isExplicit: true,
-      agentIdentifier: "explicit",
-      agentName: "Explicit Agent"
+      agentIdentifier: options?.agentIdentifier ?? "explicit",
+      agentName: options?.agentName ?? "Explicit Agent"
     });
   }
 }
@@ -26706,6 +27805,7 @@ function destroyAutoSession() {
   activeSessions.clear();
   endCallback = null;
   clientGetter = null;
+  clientInfoGetter = null;
 }
 function checkInactivity() {
   const now = Date.now();
@@ -26925,504 +28025,11 @@ function deriveClusterTitle(cluster, type) {
   return `Consolidated ${type}: ${suffix}`;
 }
 
-// src/context-assembly.ts
-var DEFAULT_TOKEN_BUDGET = 4000;
-var MAX_TOKENS_PER_ENTITY = 500;
-var MIN_RELEVANCE_THRESHOLD = 0.1;
-var TIER_WEIGHTS = {
-  reference: 1,
-  episode: 0.7,
-  draft: 0.4
-};
-var PROCEDURE_BUDGET_FRACTION = 0.15;
-var TIER_BUDGET_ALLOCATION = {
-  reference: 0.6,
-  episode: 0.3,
-  draft: 0.1
-};
-var MIN_REFERENCE_SLOTS = 3;
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function generateAssemblyId() {
-  return `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function truncateContent(content, maxTokens) {
-  const currentTokens = 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 computeRelevanceScore(entity, taskContext, cardLabels) {
-  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");
-  }
-  score = 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: client3
-  } = options;
-  const assemblyId = generateAssemblyId();
-  const manifest = {
-    assemblyId,
-    timestamp: new Date().toISOString(),
-    included: [],
-    excluded: [],
-    budgetUsed: 0,
-    budgetTotal: tokenBudget,
-    tierBreakdown: {
-      draft: { count: 0, tokens: 0 },
-      episode: { count: 0, tokens: 0 },
-      reference: { count: 0, tokens: 0 }
-    }
-  };
-  let candidates = [];
-  try {
-    const searchResult = await client3.searchMemoryEntities(workspaceId, taskContext, { project_id: projectId, limit: 30 });
-    if (searchResult.entities?.length > 0) {
-      candidates = searchResult.entities.map(mapToContextEntity);
-    }
-  } catch {}
-  if (candidates.length < 10 && projectId) {
-    try {
-      const listResult = await client3.listMemoryEntities({
-        workspace_id: workspaceId,
-        project_id: projectId,
-        limit: 30
-      });
-      if (listResult.entities?.length > 0) {
-        const existingIds = new Set(candidates.map((c) => c.id));
-        const additional = listResult.entities.map(mapToContextEntity).filter((e) => !existingIds.has(e.id));
-        candidates.push(...additional);
-      }
-    } catch {}
-  }
-  if (candidates.length < 20) {
-    try {
-      const wsResult = await client3.listMemoryEntities({
-        workspace_id: workspaceId,
-        scope: "workspace",
-        limit: 20
-      });
-      if (wsResult.entities?.length > 0) {
-        const existingIds = new Set(candidates.map((c) => c.id));
-        const additional = wsResult.entities.map(mapToContextEntity).filter((e) => !existingIds.has(e.id));
-        candidates.push(...additional);
-      }
-    } catch {}
-  }
-  if (candidates.length === 0) {
-    return {
-      context: "",
-      manifest,
-      memories: []
-    };
-  }
-  const scored = candidates.map((entity) => {
-    const { score, reasons } = computeRelevanceScore(entity, taskContext, cardLabels);
-    return { entity, score, reasons };
-  });
-  scored.sort((a, b) => b.score - a.score);
-  const 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"
-        });
-        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"
-        });
-        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(client3, included.map((i) => i.entity.id)).catch(() => {});
-  promoteEligibleEntities(client3, 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(client3, entityIds) {
-  if (entityIds.length === 0)
-    return;
-  try {
-    await client3.batchTouchMemoryEntities(entityIds);
-  } catch {
-    await Promise.allSettled(entityIds.map((id) => client3.touchMemoryEntity(id)));
-  }
-}
-async function promoteEligibleEntities(client3, 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 client3.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 {}
-    }
-  }
-}
-var manifestCache = new Map;
-var MAX_CACHE_SIZE = 50;
-function cacheManifest(manifest) {
-  if (manifestCache.size >= MAX_CACHE_SIZE) {
-    const firstKey = manifestCache.keys().next().value;
-    if (firstKey)
-      manifestCache.delete(firstKey);
-  }
-  manifestCache.set(manifest.assemblyId, manifest);
-}
-function getCachedManifest(assemblyId) {
-  return manifestCache.get(assemblyId);
-}
-var sessionAssemblyMap = new Map;
-var MAX_SESSION_MAP_SIZE = 100;
-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);
-}
-async function recordContextFeedback(client3, 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 client3.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 client3.updateMemoryEntity(entry.entityId, {
-          confidence: newConfidence,
-          metadata: {
-            usefulness_score: currentUsefulness + 1,
-            last_feedback_at: new Date().toISOString()
-          }
-        });
-        adjusted++;
-      } else if (hadBlockers) {
-        const { entity } = await client3.getMemoryEntity(entry.entityId);
-        const e = entity;
-        const newConfidence = Math.max((e.confidence ?? 0.5) - 0.02, 0.1);
-        await client3.updateMemoryEntity(entry.entityId, {
-          confidence: newConfidence,
-          metadata: {
-            last_feedback_at: new Date().toISOString()
-          }
-        });
-        adjusted++;
-      }
-    } catch {}
-  }
-  sessionAssemblyMap.delete(cardId);
-  return { adjusted };
-}
+// src/server.ts
+init_context_assembly();
 
 // src/lifecycle-maintenance.ts
+init_src();
 async function runLifecycleMaintenance(client3, workspaceId, projectId) {
   const result = {
     archived: 0,
@@ -27491,428 +28098,97 @@ async function runLifecycleMaintenance(client3, workspaceId, projectId) {
   return result;
 }
 
-// src/prompt-builder.ts
-var 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"
-};
-var 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"
-    ]
-  }
-};
-var 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.`
-};
-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})`;
+// src/server.ts
+var memorySessions = new Map;
+function initMemorySession(cardId, agentIdentifier, agentName) {
+  memorySessions.set(cardId, {
+    cardId,
+    agentIdentifier,
+    agentName,
+    memoryReadCount: 0,
+    pendingActions: [],
+    allActions: [],
+    dirty: false
   });
-  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(`
-## 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 getMemorySession(cardId) {
+  return memorySessions.get(cardId);
 }
-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 appendMemoryAction(cardId, action) {
+  const session = memorySessions.get(cardId);
+  if (!session)
+    return;
+  const truncated = action.length > 512 ? action.slice(0, 509) + "..." : action;
+  const entry = { action: truncated, ts: new Date().toISOString() };
+  session.pendingActions.push(entry);
+  session.dirty = true;
+}
+function incrementMemoryReads(cardId) {
+  const session = memorySessions.get(cardId);
+  if (!session)
+    return;
+  session.memoryReadCount++;
+  session.dirty = true;
 }
-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.";
+async function flushMemoryActions(client3, cardId) {
+  const session = memorySessions.get(cardId);
+  if (!session || !session.dirty)
+    return;
+  try {
+    if (session.memoryReadCount > 0) {
+      session.allActions.push({
+        action: `Recalled ${session.memoryReadCount} memor${session.memoryReadCount === 1 ? "y" : "ies"}`,
+        ts: new Date().toISOString()
+      });
+      session.memoryReadCount = 0;
     }
-    const nextSubtask = subtasks.find((s) => !s.completed);
-    if (nextSubtask) {
-      return `Work on next subtask: "${nextSubtask.title}" (${completed}/${subtasks.length} done).`;
+    if (session.pendingActions.length > 0) {
+      session.allActions.push(...session.pendingActions);
+      session.pendingActions = [];
     }
+    if (session.allActions.length > 10) {
+      session.allActions = session.allActions.slice(-10);
+    }
+    await client3.updateAgentProgress(cardId, {
+      agentIdentifier: session.agentIdentifier,
+      agentName: session.agentName,
+      recentActions: session.allActions
+    });
+    session.dirty = false;
+  } catch (err) {
+    console.error("[memory-session] flush failed:", err);
+  }
+}
+function mergeMemoryActionsInto(cardId, callerActions) {
+  const session = memorySessions.get(cardId);
+  if (!session)
+    return callerActions;
+  if (session.memoryReadCount > 0) {
+    session.allActions.push({
+      action: `Recalled ${session.memoryReadCount} memor${session.memoryReadCount === 1 ? "y" : "ies"}`,
+      ts: new Date().toISOString()
+    });
+    session.memoryReadCount = 0;
   }
-  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 (session.pendingActions.length > 0) {
+    session.allActions.push(...session.pendingActions);
+    session.pendingActions = [];
   }
-  if (card.description) {
-    return "Analyze the description, identify the approach, and begin implementation.";
+  const merged = [...callerActions, ...session.allActions];
+  const trimmed = merged.length > 10 ? merged.slice(-10) : merged;
+  session.allActions = trimmed;
+  session.dirty = false;
+  return trimmed;
+}
+function getActiveMemorySession() {
+  for (const session of memorySessions.values()) {
+    return session;
   }
-  return null;
+  return;
+}
+function cleanupMemorySession(cardId) {
+  memorySessions.delete(cardId);
 }
-
-// src/server.ts
 var TOOLS = {
   harmony_create_card: {
     description: "Create a new card in a Kanban column",
@@ -29426,7 +29702,7 @@ async function handleToolCall(name, args, deps) {
   const unauthenticatedTools = ["harmony_signup", "harmony_onboard"];
   if (!unauthenticatedTools.includes(name) && !deps.isConfigured()) {
     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.
+` + `You can generate an API key at https://app.gethmy.com → Settings → API Keys.
 ` + 'Or use "harmony_onboard" to create an account and configure automatically.');
   }
   const client3 = deps.isConfigured() ? deps.getClient() : null;
@@ -29729,7 +30005,8 @@ async function handleToolCall(name, args, deps) {
         currentTask: args.currentTask,
         estimatedMinutesRemaining: args.estimatedMinutesRemaining
       });
-      markExplicit(cardId);
+      markExplicit(cardId, { agentIdentifier, agentName });
+      initMemorySession(cardId, agentIdentifier, agentName);
       let prefetchedMemoryIds = [];
       try {
         const workspaceId = deps.getActiveWorkspaceId();
@@ -29776,6 +30053,14 @@ async function handleToolCall(name, args, deps) {
       const agentIdentifier = exports_external.string().min(1).max(100).parse(args.agentIdentifier);
       const agentName = exports_external.string().min(1).max(100).parse(args.agentName);
       const progressPercent = args.progressPercent !== undefined ? exports_external.number().min(0).max(100).parse(args.progressPercent) : undefined;
+      const callerRecentActions = args.recentActions;
+      const memSession = getMemorySession(cardId);
+      let mergedRecentActions;
+      if (memSession?.dirty) {
+        mergedRecentActions = mergeMemoryActionsInto(cardId, callerRecentActions || []);
+      } else if (callerRecentActions) {
+        mergedRecentActions = callerRecentActions;
+      }
       const result = await client3.updateAgentProgress(cardId, {
         agentIdentifier,
         agentName,
@@ -29783,7 +30068,8 @@ async function handleToolCall(name, args, deps) {
         progressPercent,
         currentTask: args.currentTask,
         blockers: args.blockers,
-        estimatedMinutesRemaining: args.estimatedMinutesRemaining
+        estimatedMinutesRemaining: args.estimatedMinutesRemaining,
+        ...mergedRecentActions && { recentActions: mergedRecentActions }
       });
       let midSessionLearnings = 0;
       try {
@@ -29808,6 +30094,8 @@ async function handleToolCall(name, args, deps) {
       const moveToColumn = args.moveToColumn;
       const sessionStatus = args.status || "completed";
       const endProgressPercent = args.progressPercent !== undefined ? exports_external.number().min(0).max(100).parse(args.progressPercent) : undefined;
+      await flushMemoryActions(client3, cardId);
+      cleanupMemorySession(cardId);
       const result = await client3.endAgentSession(cardId, {
         status: sessionStatus,
         progressPercent: endProgressPercent
@@ -29881,12 +30169,9 @@ async function handleToolCall(name, args, deps) {
       return { success: true, ...result };
     }
     case "harmony_generate_prompt": {
-      let cardData;
-      let columnData = null;
+      let cardId;
       if (args.cardId) {
-        const cardId = exports_external.string().uuid().parse(args.cardId);
-        const cardResult = await client3.getCard(cardId);
-        cardData = cardResult.card;
+        cardId = exports_external.string().uuid().parse(args.cardId);
       } else if (args.shortId !== undefined) {
         const shortId = exports_external.number().int().positive().parse(args.shortId);
         const projectId = args.projectId || deps.getActiveProjectId();
@@ -29894,24 +30179,10 @@ async function handleToolCall(name, args, deps) {
           throw new Error("Project ID required when using shortId. Use harmony_set_project_context or provide projectId.");
         }
         const cardResult = await client3.getCardByShortId(projectId, shortId);
-        cardData = cardResult.card;
+        cardId = cardResult.card.id;
       } else {
         throw new Error("Either cardId or shortId must be provided");
       }
-      const projectIdForBoard = args.projectId || getActiveProjectId() || cardData.project_id;
-      if (projectIdForBoard) {
-        try {
-          const board = await client3.getBoard(projectIdForBoard, {
-            summary: true
-          });
-          const columnId = cardData.column_id;
-          const column = board.columns.find((col) => col.id === columnId);
-          if (column) {
-            columnData = { name: column.name };
-          }
-        } catch {}
-      }
-      const variant = args.variant || "execute";
       const contextOptions = {};
       if (args.includeSubtasks !== undefined) {
         contextOptions.includeSubtasks = args.includeSubtasks === true || args.includeSubtasks === "true";
@@ -29922,67 +30193,19 @@ async function handleToolCall(name, args, deps) {
       if (args.includeDescription !== undefined) {
         contextOptions.includeDescription = args.includeDescription === true || args.includeDescription === "true";
       }
-      let assembledContextStr;
-      let assemblyId;
-      let memories;
-      try {
-        const workspaceId = deps.getActiveWorkspaceId();
-        if (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,
-            projectId: getActiveProjectId() || undefined,
-            taskContext,
-            cardLabels,
-            cardId: cardData.id,
-            client: client3
-          });
-          if (assembled.context) {
-            assembledContextStr = assembled.context;
-            assemblyId = assembled.manifest.assemblyId;
-            cacheManifest(assembled.manifest);
-          }
-        }
-      } catch {
-        try {
-          const workspaceId = deps.getActiveWorkspaceId();
-          if (workspaceId && cardData.title) {
-            const memoryResult = await client3.searchMemoryEntities(workspaceId, cardData.title, {
-              project_id: getActiveProjectId() || undefined,
-              limit: 5
-            });
-            if (memoryResult.entities?.length > 0) {
-              memories = memoryResult.entities.map((e) => {
-                const entity = e;
-                return {
-                  id: entity.id,
-                  type: entity.type,
-                  title: entity.title,
-                  content: entity.content,
-                  confidence: entity.confidence,
-                  tags: entity.tags || []
-                };
-              });
-            }
-          }
-        } catch {}
-      }
-      const result = generatePrompt({
-        card: cardData,
-        column: columnData,
-        variant,
-        contextOptions,
+      const result = await client3.generateCardPrompt({
+        cardId,
+        workspaceId: deps.getActiveWorkspaceId() || "",
+        projectId: args.projectId || getActiveProjectId() || undefined,
+        variant: args.variant || "execute",
         customConstraints: args.customConstraints,
-        memories,
-        assembledContext: assembledContextStr,
-        assemblyId
+        contextOptions
       });
+      if (result.assemblyId) {
+        trackSessionAssembly(cardId, result.assemblyId);
+      }
       return {
         success: true,
-        cardId: cardData.id,
-        shortId: cardData.short_id,
-        title: cardData.title,
         ...result
       };
     }
@@ -29995,6 +30218,7 @@ async function handleToolCall(name, args, deps) {
       }
       const entityType = args.type || "context";
       const entityTags = args.tags || [];
+      const activeMemSession = getActiveMemorySession();
       const result = await client3.createMemoryEntity({
         workspace_id: workspaceId,
         project_id: args.projectId || deps.getActiveProjectId() || undefined,
@@ -30006,7 +30230,7 @@ async function handleToolCall(name, args, deps) {
         metadata: args.metadata,
         confidence: args.confidence !== undefined ? exports_external.number().min(0).max(1).parse(args.confidence) : undefined,
         tags: entityTags.length > 0 ? entityTags : undefined,
-        agent_identifier: "claude-code"
+        agent_identifier: activeMemSession?.agentIdentifier || undefined
       });
       const newEntityIdForGraph = result.entity?.id;
       if (newEntityIdForGraph) {
@@ -30019,6 +30243,10 @@ async function handleToolCall(name, args, deps) {
           potentialContradictions = await detectContradictions(client3, newEntityId, entityType, title, content, entityTags, workspaceId, args.projectId || deps.getActiveProjectId() || undefined);
         } catch {}
       }
+      if (activeMemSession) {
+        appendMemoryAction(activeMemSession.cardId, `Stored memory: ${title}`);
+        flushMemoryActions(client3, activeMemSession.cardId).catch(() => {});
+      }
       return {
         success: true,
         ...result,
@@ -30082,6 +30310,10 @@ async function handleToolCall(name, args, deps) {
           } catch (_) {}
         })).catch(() => {});
       }
+      const recallMemSession = getActiveMemorySession();
+      if (recallMemSession) {
+        incrementMemoryReads(recallMemSession.cardId);
+      }
       return markdown || "No memories found.";
     }
     case "harmony_update_memory": {
@@ -30102,11 +30334,29 @@ async function handleToolCall(name, args, deps) {
       if (args.metadata !== undefined)
         updates.metadata = args.metadata;
       const result = await client3.updateMemoryEntity(entityId, updates);
+      const updateMemSession = getActiveMemorySession();
+      if (updateMemSession) {
+        const updateTitle = updates.title || entityId.slice(0, 8);
+        appendMemoryAction(updateMemSession.cardId, `Updated memory: ${updateTitle}`);
+        flushMemoryActions(client3, updateMemSession.cardId).catch(() => {});
+      }
       return { success: true, ...result };
     }
     case "harmony_forget": {
       const entityId = exports_external.string().uuid().parse(args.entityId);
+      let forgetTitle = null;
+      const forgetMemSession = getActiveMemorySession();
+      if (forgetMemSession) {
+        try {
+          const { entity } = await client3.getMemoryEntity(entityId);
+          forgetTitle = entity?.title || null;
+        } catch {}
+      }
       await client3.deleteMemoryEntity(entityId);
+      if (forgetMemSession) {
+        appendMemoryAction(forgetMemSession.cardId, `Removed memory: ${forgetTitle || entityId.slice(0, 8)}`);
+        flushMemoryActions(client3, forgetMemSession.cardId).catch(() => {});
+      }
       return { success: true };
     }
     case "harmony_relate": {
@@ -30128,6 +30378,11 @@ async function handleToolCall(name, args, deps) {
         relation_type: relationType,
         confidence: args.confidence !== undefined ? exports_external.number().min(0).max(1).parse(args.confidence) : undefined
       });
+      const relateMemSession = getActiveMemorySession();
+      if (relateMemSession) {
+        appendMemoryAction(relateMemSession.cardId, `Linked memories: ${relationType}`);
+        flushMemoryActions(client3, relateMemSession.cardId).catch(() => {});
+      }
       return { success: true, ...result };
     }
     case "harmony_memory_search": {
@@ -30141,6 +30396,10 @@ async function handleToolCall(name, args, deps) {
         type: args.type,
         limit: args.limit
       });
+      const searchMemSession = getActiveMemorySession();
+      if (searchMemSession) {
+        incrementMemoryReads(searchMemSession.cardId);
+      }
       return markdown || "No memories found.";
     }
     case "harmony_vault_index": {
@@ -30235,7 +30494,7 @@ async function handleToolCall(name, args, deps) {
         source: args.source || "agent",
         tasks: args.tasks
       });
-      const planUrl = `https://gethmy.com/plans/${result.plan.id}`;
+      const planUrl = `https://app.gethmy.com/plans/${result.plan.id}`;
       return {
         success: true,
         planId: result.plan.id,
@@ -30730,7 +30989,10 @@ class HarmonyMCPServer {
     const configDeps = createConfigDeps();
     initAutoSession(async (client3, cardId, status) => {
       await runEndSessionPipeline(client3, configDeps, cardId, status);
-    }, () => getClient());
+    }, () => getClient(), () => {
+      const cv = this.server.getClientVersion();
+      return cv ? { name: cv.name, version: cv.version } : null;
+    });
     const handleShutdown = async () => {
       try {
         await shutdownAllSessions();
@@ -31000,7 +31262,7 @@ Once you have the plan ID, call \`harmony_get_plan\` to fetch the full plan with
 ## [Plan Title]
 **Status:** draft/active/archived | **Phase:** plan/execute/verify/done
 **Tasks:** N total (X pending, Y in_progress, Z completed)
-**URL:** https://gethmy.com/plans/{id}
+**URL:** https://app.gethmy.com/plans/{id}
 \\\`\\\`\\\`
 
 If plan is in execute phase and tasks already have linked cards, note which tasks have cards and which don't.
@@ -31034,7 +31296,7 @@ Only offer **(A) Single card**, **(C) Analyze only**, or **(D) Skip**.
 #### Option A — Single card
 1. Call \`harmony_create_card\` with:
    - \`title\`: Plan title
-   - \`description\`: Brief 2-3 sentence summary of the plan + \`\\n\\n[View plan](https://gethmy.com/plans/{planId})\`
+   - \`description\`: Brief 2-3 sentence summary of the plan + \`\\n\\n[View plan](https://app.gethmy.com/plans/{planId})\`
    - \`priority\`: based on plan task priorities (use highest)
 2. Call \`harmony_update_plan\` to set \`status: "active"\`, \`workflowPhase: "execute"\`
 
@@ -31156,7 +31418,7 @@ Call \`harmony_create_plan\` with:
 ### 2B.5 — User Approval
 
 Show the user:
-- Plan URL: \`https://gethmy.com/plans/{id}\`
+- Plan URL: \`https://app.gethmy.com/plans/{id}\`
 - Number of tasks created
 - Brief summary
 
@@ -32936,7 +33198,7 @@ function getWriteSummary(files, options = {}) {
 
 // src/tui/setup.ts
 var GLOBAL_SKILLS_DIR = join5(homedir4(), ".agents", "skills");
-var API_URL = "https://gethmy.com/api";
+var API_URL = "https://app.gethmy.com/api";
 async function registerMcpServer() {
   try {
     const { execSync } = await import("node:child_process");
@@ -33286,7 +33548,7 @@ async function runSetup(options = {}) {
   if (!validation.valid) {
     spinner.stop(colors.error("API key validation failed"));
     M2.error(validation.error || "Could not connect to Harmony API");
-    M2.info("Get an API key at: https://gethmy.com/user/keys");
+    M2.info("Get an API key at: https://app.gethmy.com/user/keys");
     process.exit(1);
   }
   if (!userEmail) {
@@ -33586,7 +33848,7 @@ async function runSetup(options = {}) {
   }
   console.log("");
   console.log(`  ${colors.dim("Add to new project: npx @gethmy/mcp setup")}`);
-  console.log(`  ${colors.dim("Need help? Visit https://gethmy.com/docs/mcp")}`);
+  console.log(`  ${colors.dim("Need help? Visit https://app.gethmy.com/docs/mcp")}`);
   console.log("");
 }
 
@@ -33650,7 +33912,7 @@ Context:`);
     console.log(`Status: Not configured
 `);
     console.log("Run: npx @gethmy/mcp setup");
-    console.log("Get an API key at: https://gethmy.com/user/keys");
+    console.log("Get an API key at: https://app.gethmy.com/user/keys");
   }
 });
 program.command("reset").description("Remove stored configuration").action(() => {