@memoraone/mcp 0.1.37 → 0.1.39

package/dist/index.cjs

@@ -78,7 +78,7 @@ var EnvSchema = import_v4.z.object({
   MEMORAONE_AGENT_NAME: import_v4.z.string().min(1).optional(),
   MEMORAONE_AGENT_TYPE: import_v4.z.string().min(1).optional(),
   MEMORAONE_SOURCE: import_v4.z.string().min(1).optional(),
-  MEMORAONE_IDE_TYPE: import_v4.z.enum(["cursor", "copilot-vscode", "jetbrains"]).optional(),
+  MEMORAONE_IDE_TYPE: import_v4.z.enum(["cursor", "copilot-vscode", "jetbrains", "claude-code", "windsurf", "opencode", "codex"]).optional(),
   MEMORAONE_WORKLOG: import_v4.z.string().min(1).optional(),
   MEMORAONE_HEARTBEAT: import_v4.z.string().min(1).optional(),
   MEMORAONE_HEARTBEAT_INTERVAL_MS: import_v4.z.string().min(1).optional()
@@ -127,7 +127,9 @@ var config2 = {
   devMode: parseBooleanFlag(parsed.data.MEMORAONE_DEV_MODE, false),
   worklogEnabled: parseBooleanFlag(parsed.data.MEMORAONE_WORKLOG, true),
   heartbeatEnabled: parseBooleanFlag(parsed.data.MEMORAONE_HEARTBEAT, true),
-  heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? "30000", 10)
+  // Cadence is owned by LOCAL_MCP_HEARTBEAT_INTERVAL_MS in heartbeat.ts (1_000).
+  // Env override is accepted for forward-compat but the timer path ignores it.
+  heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? "1000", 10)
 };
 
 // src/client/memoraClient.ts
@@ -1431,7 +1433,15 @@ var HASH_SOCKET_FILENAME_RE = new RegExp(
   `^mcp-[0-9a-f]{${BINDING_SOCKET_HASH_LENGTH}}\\.sock$`,
   "i"
 );
-var IDE_TYPES = ["cursor", "copilot-vscode", "jetbrains"];
+var IDE_TYPES = [
+  "cursor",
+  "copilot-vscode",
+  "jetbrains",
+  "claude-code",
+  "windsurf",
+  "opencode",
+  "codex"
+];
 var IDE_TYPE_SET = new Set(IDE_TYPES);
 function parseIdeType(value) {
   if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
@@ -1442,16 +1452,19 @@ function parseIdeType(value) {
 function resolveIdeTypeFromEnv(env2 = process.env) {
   return parseIdeType(env2.MEMORAONE_IDE_TYPE);
 }
-function resolveBindingIdeType(env2 = process.env) {
+function resolveBindingIdeType(env2 = process.env, ideTypeOverride) {
+  if (ideTypeOverride !== void 0) {
+    return ideTypeOverride;
+  }
   return resolveIdeTypeFromEnv(env2) ?? "";
 }
-function getBindingSocketFilename(binding, env2 = process.env) {
-  const ideType = resolveBindingIdeType(env2);
+function getBindingSocketFilename(binding, env2 = process.env, ideTypeOverride) {
+  const ideType = resolveBindingIdeType(env2, ideTypeOverride);
   const hash = hashBindingIdentity(binding.repositoryBindingId, binding.workspaceRoot, ideType);
   return `mcp-${hash}.sock`;
 }
-function getBindingSocketPath(binding, env2 = process.env) {
-  return path10.join(BASE_DIR, getBindingSocketFilename(binding, env2));
+function getBindingSocketPath(binding, env2 = process.env, ideTypeOverride) {
+  return path10.join(BASE_DIR, getBindingSocketFilename(binding, env2, ideTypeOverride));
 }
 
 // src/initializeBinding.ts
@@ -1770,8 +1783,79 @@ var logCommandShape = {
 // src/tools/bindingStatus.ts
 var bindingStatusShape = {};
 
-// src/tools/handlers/postEvent.ts
+// src/tools/listTimeline.ts
 var import_v411 = require("zod/v4");
+var listTimelineDescription = "List timeline events for the project bound to this Local MCP installation.";
+var listTimelineInputSchema = import_v411.z.object({
+  since: import_v411.z.string().optional(),
+  concept: import_v411.z.string().optional(),
+  kind: import_v411.z.union([import_v411.z.string(), import_v411.z.array(import_v411.z.string())]).optional(),
+  sort: import_v411.z.enum(["newest", "oldest"]).optional(),
+  limit: import_v411.z.number().int().min(1).max(200).optional(),
+  cursor: import_v411.z.string().optional()
+}).strict();
+
+// src/tools/listConcepts.ts
+var import_v412 = require("zod/v4");
+var listConceptsDescription = "List concepts for the project bound to this Local MCP installation.";
+var listConceptsInputSchema = import_v412.z.object({
+  q: import_v412.z.string().min(1).optional(),
+  tag: import_v412.z.string().min(1).optional(),
+  parent_id: import_v412.z.string().min(1).optional(),
+  limit: import_v412.z.number().int().min(1).max(200).optional(),
+  cursor: import_v412.z.string().min(1).optional()
+}).strict();
+
+// src/tools/getConcept.ts
+var import_v413 = require("zod/v4");
+var getConceptDescription = "Get one concept by ID from the project bound to this Local MCP installation.";
+var getConceptInputSchema = import_v413.z.object({
+  id: import_v413.z.string().trim().min(1)
+}).strict();
+
+// src/tools/createConceptVersion.ts
+var import_v414 = require("zod/v4");
+var createConceptVersionDescription = "Create a version of a concept in the project bound to this Local MCP installation.";
+var createConceptVersionInputSchema = import_v414.z.object({
+  id: import_v414.z.string().trim().min(1),
+  value: import_v414.z.unknown(),
+  reason: import_v414.z.string().optional(),
+  confidence: import_v414.z.number().finite().min(0).max(1).optional(),
+  source_ref: import_v414.z.string().optional(),
+  tags: import_v414.z.array(import_v414.z.string()).optional(),
+  parent_id: import_v414.z.union([import_v414.z.string(), import_v414.z.null()]).optional()
+}).strict();
+function isJsonValue(value) {
+  if (value === null) return true;
+  if (typeof value === "boolean" || typeof value === "string") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  return Object.values(value).every(isJsonValue);
+}
+
+// src/tools/toolInventory.ts
+var LOCAL_MCP_TOOL_NAMES = [
+  "memora_ask_with_memory",
+  "memora_post_event",
+  "memora_create_fact",
+  "memora_add_personal_context",
+  "memora_get_personal_context",
+  "memora_log_intent",
+  "memora_log_change_summary",
+  "memora_log_tool_result",
+  "memora_log_command",
+  "memora_status",
+  "memora_list_timeline",
+  "memora_list_concepts",
+  "memora_get_concept",
+  "memora_create_concept_version"
+];
+
+// src/tools/handlers/postEvent.ts
+var import_v415 = require("zod/v4");
 var crypto4 = __toESM(require("crypto"), 1);
 
 // src/runContext.ts
@@ -1827,14 +1911,14 @@ function generateRunId() {
 }
 
 // src/tools/handlers/postEvent.ts
-var postEventInputSchema = import_v411.z.object({
-  kind: import_v411.z.string().min(1),
-  actor: import_v411.z.object({
-    identifier: import_v411.z.string().min(1),
-    id: import_v411.z.string().min(1).optional()
+var postEventInputSchema = import_v415.z.object({
+  kind: import_v415.z.string().min(1),
+  actor: import_v415.z.object({
+    identifier: import_v415.z.string().min(1),
+    id: import_v415.z.string().min(1).optional()
   }),
-  content: import_v411.z.record(import_v411.z.string(), import_v411.z.any()),
-  metadata: import_v411.z.record(import_v411.z.string(), import_v411.z.any()).optional()
+  content: import_v415.z.record(import_v415.z.string(), import_v415.z.any()),
+  metadata: import_v415.z.record(import_v415.z.string(), import_v415.z.any()).optional()
 });
 function buildPostEventContentFields(content) {
   if (typeof content.message === "string") {
@@ -1906,10 +1990,10 @@ async function handlePostEvent(client, args) {
 }
 
 // src/tools/handlers/createFact.ts
-var import_v412 = require("zod/v4");
-var createFactInputSchema = import_v412.z.object({
-  content: import_v412.z.string().min(1),
-  metadata: import_v412.z.record(import_v412.z.string(), import_v412.z.any()).optional()
+var import_v416 = require("zod/v4");
+var createFactInputSchema = import_v416.z.object({
+  content: import_v416.z.string().min(1),
+  metadata: import_v416.z.record(import_v416.z.string(), import_v416.z.any()).optional()
 });
 async function handleCreateFact(client, args) {
   const parsed2 = createFactInputSchema.parse(args ?? {});
@@ -1954,13 +2038,13 @@ async function handleCreateFact(client, args) {
 }
 
 // src/tools/handlers/addPersonalContext.ts
-var import_v413 = require("zod/v4");
-var addPersonalContextInputSchema = import_v413.z.object({
-  content: import_v413.z.string().min(1),
-  category: import_v413.z.string().optional(),
-  tags: import_v413.z.array(import_v413.z.string()).optional(),
-  scope_type: import_v413.z.enum(["general", "project"]).optional(),
-  scope_id: import_v413.z.string().optional()
+var import_v417 = require("zod/v4");
+var addPersonalContextInputSchema = import_v417.z.object({
+  content: import_v417.z.string().min(1),
+  category: import_v417.z.string().optional(),
+  tags: import_v417.z.array(import_v417.z.string()).optional(),
+  scope_type: import_v417.z.enum(["general", "project"]).optional(),
+  scope_id: import_v417.z.string().optional()
 });
 async function handleAddPersonalContext(client, args) {
   const parsed2 = addPersonalContextInputSchema.parse(args ?? {});
@@ -1996,12 +2080,12 @@ async function handleAddPersonalContext(client, args) {
 }
 
 // src/tools/handlers/getPersonalContext.ts
-var import_v414 = require("zod/v4");
-var getPersonalContextInputSchema = import_v414.z.object({
-  query: import_v414.z.string().optional(),
-  scope_type: import_v414.z.enum(["general", "project"]).optional(),
-  scope_id: import_v414.z.string().optional(),
-  limit: import_v414.z.number().int().positive().optional()
+var import_v418 = require("zod/v4");
+var getPersonalContextInputSchema = import_v418.z.object({
+  query: import_v418.z.string().optional(),
+  scope_type: import_v418.z.enum(["general", "project"]).optional(),
+  scope_id: import_v418.z.string().optional(),
+  limit: import_v418.z.number().int().positive().optional()
 });
 function buildPersonalContextPath(parsed2) {
   const params = new URLSearchParams();
@@ -2038,13 +2122,13 @@ async function handleGetPersonalContext(client, args) {
 }
 
 // src/tools/handlers/askWithMemory.ts
-var import_v415 = require("zod/v4");
-var askWithMemoryInputSchema = import_v415.z.object({
-  question: import_v415.z.string().min(1),
-  code_context: import_v415.z.object({
-    file_path: import_v415.z.string().optional(),
-    selected_text: import_v415.z.string().optional(),
-    language: import_v415.z.string().optional()
+var import_v419 = require("zod/v4");
+var askWithMemoryInputSchema = import_v419.z.object({
+  question: import_v419.z.string().min(1),
+  code_context: import_v419.z.object({
+    file_path: import_v419.z.string().optional(),
+    selected_text: import_v419.z.string().optional(),
+    language: import_v419.z.string().optional()
   }).optional()
 });
 function isAskWithMemoryResponse(value) {
@@ -2080,13 +2164,13 @@ async function handleAskWithMemory(client, args) {
 }
 
 // src/tools/handlers/logIntent.ts
-var import_v416 = require("zod/v4");
-var logIntentInputSchema = import_v416.z.object({
-  intent: import_v416.z.enum(["task", "decision"]),
-  message: import_v416.z.string().min(1),
-  context: import_v416.z.record(import_v416.z.string(), import_v416.z.any()).optional(),
-  intent_source: import_v416.z.string().optional().default("cursor_chat"),
-  run_id: import_v416.z.string().min(1).optional()
+var import_v420 = require("zod/v4");
+var logIntentInputSchema = import_v420.z.object({
+  intent: import_v420.z.enum(["task", "decision"]),
+  message: import_v420.z.string().min(1),
+  context: import_v420.z.record(import_v420.z.string(), import_v420.z.any()).optional(),
+  intent_source: import_v420.z.string().optional().default("cursor_chat"),
+  run_id: import_v420.z.string().min(1).optional()
 });
 async function handleLogIntent(client, args) {
   const parsed2 = logIntentInputSchema.parse(args ?? {});
@@ -2128,18 +2212,18 @@ async function handleLogIntent(client, args) {
 }
 
 // src/tools/handlers/logChangeSummary.ts
-var import_v417 = require("zod/v4");
-var logChangeSummaryInputSchema = import_v417.z.object({
-  summary: import_v417.z.string().min(1),
-  scope: import_v417.z.string().min(1).optional(),
-  files: import_v417.z.array(import_v417.z.string().min(1)).optional(),
-  stats: import_v417.z.object({
-    files: import_v417.z.number().int().nonnegative().optional(),
-    add: import_v417.z.number().int().nonnegative().optional(),
-    del: import_v417.z.number().int().nonnegative().optional()
+var import_v421 = require("zod/v4");
+var logChangeSummaryInputSchema = import_v421.z.object({
+  summary: import_v421.z.string().min(1),
+  scope: import_v421.z.string().min(1).optional(),
+  files: import_v421.z.array(import_v421.z.string().min(1)).optional(),
+  stats: import_v421.z.object({
+    files: import_v421.z.number().int().nonnegative().optional(),
+    add: import_v421.z.number().int().nonnegative().optional(),
+    del: import_v421.z.number().int().nonnegative().optional()
   }).optional(),
-  commit: import_v417.z.string().min(1).optional(),
-  run_id: import_v417.z.string().min(1).optional()
+  commit: import_v421.z.string().min(1).optional(),
+  run_id: import_v421.z.string().min(1).optional()
 });
 async function handleLogChangeSummary(client, args) {
   const parsed2 = logChangeSummaryInputSchema.parse(args ?? {});
@@ -2174,17 +2258,17 @@ async function handleLogChangeSummary(client, args) {
 }
 
 // src/tools/handlers/logToolResult.ts
-var import_v418 = require("zod/v4");
-var logToolResultInputSchema = import_v418.z.object({
-  tool: import_v418.z.string().min(1),
-  status: import_v418.z.enum(["ok", "error", "partial"]),
-  summary: import_v418.z.string().min(1),
-  run_id: import_v418.z.string().min(1).optional(),
-  duration_ms: import_v418.z.number().int().nonnegative().optional(),
-  error_code: import_v418.z.string().min(1).optional(),
-  error_message: import_v418.z.string().min(1).optional(),
-  error_kind: import_v418.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
-  stats: import_v418.z.record(import_v418.z.string(), import_v418.z.any()).optional()
+var import_v422 = require("zod/v4");
+var logToolResultInputSchema = import_v422.z.object({
+  tool: import_v422.z.string().min(1),
+  status: import_v422.z.enum(["ok", "error", "partial"]),
+  summary: import_v422.z.string().min(1),
+  run_id: import_v422.z.string().min(1).optional(),
+  duration_ms: import_v422.z.number().int().nonnegative().optional(),
+  error_code: import_v422.z.string().min(1).optional(),
+  error_message: import_v422.z.string().min(1).optional(),
+  error_kind: import_v422.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
+  stats: import_v422.z.record(import_v422.z.string(), import_v422.z.any()).optional()
 });
 async function handleLogToolResult(client, args) {
   const parsed2 = logToolResultInputSchema.parse(args ?? {});
@@ -2222,15 +2306,15 @@ async function handleLogToolResult(client, args) {
 }
 
 // src/tools/handlers/logCommand.ts
-var import_v419 = require("zod/v4");
-var logCommandInputSchema = import_v419.z.object({
-  cmd: import_v419.z.string().min(1),
-  summary: import_v419.z.string().min(1),
-  cwd: import_v419.z.string().min(1).optional(),
-  exit_code: import_v419.z.number().int().optional(),
-  duration_ms: import_v419.z.number().int().nonnegative().optional(),
-  run_id: import_v419.z.string().min(1).optional(),
-  stats: import_v419.z.record(import_v419.z.string(), import_v419.z.any()).optional()
+var import_v423 = require("zod/v4");
+var logCommandInputSchema = import_v423.z.object({
+  cmd: import_v423.z.string().min(1),
+  summary: import_v423.z.string().min(1),
+  cwd: import_v423.z.string().min(1).optional(),
+  exit_code: import_v423.z.number().int().optional(),
+  duration_ms: import_v423.z.number().int().nonnegative().optional(),
+  run_id: import_v423.z.string().min(1).optional(),
+  stats: import_v423.z.record(import_v423.z.string(), import_v423.z.any()).optional()
 });
 async function handleLogCommand(client, args) {
   const parsed2 = logCommandInputSchema.parse(args ?? {});
@@ -2265,6 +2349,244 @@ async function handleLogCommand(client, args) {
   return { ok: true };
 }
 
+// src/tools/responseProjection.ts
+var timelineItemKeys = [
+  "id",
+  "ts",
+  "kind",
+  "concept",
+  "old_value",
+  "new_value",
+  "reason",
+  "confidence",
+  "links",
+  "source_ref",
+  "redacted",
+  "redaction_reason",
+  "summary",
+  "consolidated_of"
+];
+var conceptVersionKeys = [
+  "version",
+  "ts",
+  "reason",
+  "confidence",
+  "source_ref",
+  "value"
+];
+function invalidResponse() {
+  throw new Error("Invalid Memora response");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pickFields(raw, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(raw, key) && raw[key] !== void 0) {
+      result[key] = raw[key];
+    }
+  }
+  return result;
+}
+function pickConceptVersion(raw) {
+  return pickFields(raw, conceptVersionKeys);
+}
+function pickConceptItem(raw) {
+  if (typeof raw.id !== "string" || raw.id.trim() === "") invalidResponse();
+  const item = { id: raw.id };
+  if (Object.prototype.hasOwnProperty.call(raw, "tags")) {
+    if (!Array.isArray(raw.tags) || !raw.tags.every((tag) => typeof tag === "string")) {
+      invalidResponse();
+    }
+    item.tags = raw.tags;
+  }
+  if (Object.prototype.hasOwnProperty.call(raw, "parent_id")) {
+    if (raw.parent_id !== null && typeof raw.parent_id !== "string") invalidResponse();
+    item.parent_id = raw.parent_id;
+  }
+  if (Object.prototype.hasOwnProperty.call(raw, "latest")) {
+    if (raw.latest === null) {
+      item.latest = null;
+    } else if (isRecord(raw.latest)) {
+      item.latest = pickConceptVersion(raw.latest);
+    } else {
+      invalidResponse();
+    }
+  }
+  return item;
+}
+function normalizeCursor(raw) {
+  for (const key of ["next_cursor", "nextCursor"]) {
+    if (!Object.prototype.hasOwnProperty.call(raw, key)) continue;
+    const value = raw[key];
+    if (value === null) return null;
+    if (typeof value === "string") return value;
+    invalidResponse();
+  }
+  return null;
+}
+function projectTimelineResponse(data) {
+  if (!isRecord(data) || !Array.isArray(data.items) || !isRecord(data.page)) {
+    invalidResponse();
+  }
+  if (typeof data.page.limit !== "number" || !Number.isFinite(data.page.limit) || data.page.sort !== "newest" && data.page.sort !== "oldest") {
+    invalidResponse();
+  }
+  const items = data.items.map((entry) => {
+    if (!isRecord(entry)) invalidResponse();
+    return pickFields(entry, timelineItemKeys);
+  });
+  return {
+    items,
+    page: {
+      limit: data.page.limit,
+      sort: data.page.sort,
+      next_cursor: normalizeCursor(data.page)
+    }
+  };
+}
+function projectConceptListResponse(data, requestedLimit) {
+  if (!isRecord(data)) invalidResponse();
+  let entries;
+  if (Object.prototype.hasOwnProperty.call(data, "rows")) {
+    entries = data.rows;
+  } else if (Object.prototype.hasOwnProperty.call(data, "items")) {
+    entries = data.items;
+  } else {
+    invalidResponse();
+  }
+  if (!Array.isArray(entries)) invalidResponse();
+  let cursorSource = data;
+  if (!Object.prototype.hasOwnProperty.call(data, "next_cursor") && !Object.prototype.hasOwnProperty.call(data, "nextCursor") && Object.prototype.hasOwnProperty.call(data, "page")) {
+    if (!isRecord(data.page)) invalidResponse();
+    cursorSource = data.page;
+  }
+  return {
+    items: entries.map((entry) => {
+      if (!isRecord(entry)) invalidResponse();
+      return pickConceptItem(entry);
+    }),
+    page: {
+      limit: requestedLimit ?? 50,
+      next_cursor: normalizeCursor(cursorSource)
+    }
+  };
+}
+function projectConceptResponse(data) {
+  if (!isRecord(data)) invalidResponse();
+  const item = pickConceptItem(data);
+  if (!Object.prototype.hasOwnProperty.call(data, "history")) {
+    return { ...item, history: [] };
+  }
+  if (!Array.isArray(data.history)) invalidResponse();
+  const history = data.history.map((entry) => {
+    if (!isRecord(entry)) invalidResponse();
+    return pickConceptVersion(entry);
+  });
+  return { ...item, history };
+}
+function projectCreatedConceptVersionResponse(data) {
+  if (!isRecord(data)) invalidResponse();
+  return pickConceptItem(data);
+}
+
+// src/tools/handlers/toolRequestError.ts
+function rethrowToolRequestError(toolName, error) {
+  if (error instanceof SyntaxError) {
+    throw new Error("Invalid Memora response");
+  }
+  if (!(error instanceof MemoraOneHttpError)) throw error;
+  let detail = "request failed";
+  if (error.status === 401) detail = "authentication failed";
+  else if (error.status === 403) detail = "connection unavailable";
+  else if (error.status === 404) detail = "resource not found";
+  else if (error.status === 409) detail = "conflict";
+  else if (error.status >= 500) detail = "backend error";
+  throw new Error(`${toolName} failed: ${error.status} ${detail}`);
+}
+
+// src/tools/handlers/listTimeline.ts
+function buildQuery(input) {
+  const parts = [];
+  const append = (key, value) => {
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+  };
+  if (input.since !== void 0) append("since", input.since);
+  if (input.concept !== void 0) append("concept", input.concept);
+  if (input.kind !== void 0) {
+    for (const kind of Array.isArray(input.kind) ? input.kind : [input.kind]) {
+      append("kind", kind);
+    }
+  }
+  if (input.sort !== void 0) append("sort", input.sort);
+  if (input.limit !== void 0) append("limit", String(input.limit));
+  if (input.cursor !== void 0) append("cursor", input.cursor);
+  return parts.length === 0 ? "" : `?${parts.join("&")}`;
+}
+async function handleListTimeline(client, args) {
+  const input = listTimelineInputSchema.parse(args ?? {});
+  try {
+    return projectTimelineResponse(await client.get(`/timeline${buildQuery(input)}`));
+  } catch (error) {
+    rethrowToolRequestError("memora_list_timeline", error);
+  }
+}
+
+// src/tools/handlers/listConcepts.ts
+function buildQuery2(input) {
+  const parts = [];
+  const append = (key, value) => {
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+  };
+  if (input.q !== void 0) append("q", input.q);
+  if (input.tag !== void 0) append("tag", input.tag);
+  if (input.parent_id !== void 0) append("parent_id", input.parent_id);
+  if (input.limit !== void 0) append("limit", String(input.limit));
+  if (input.cursor !== void 0) append("cursor", input.cursor);
+  return parts.length === 0 ? "" : `?${parts.join("&")}`;
+}
+async function handleListConcepts(client, args) {
+  const input = listConceptsInputSchema.parse(args ?? {});
+  try {
+    const data = await client.get(`/concepts${buildQuery2(input)}`);
+    return projectConceptListResponse(data, input.limit);
+  } catch (error) {
+    rethrowToolRequestError("memora_list_concepts", error);
+  }
+}
+
+// src/tools/handlers/getConcept.ts
+async function handleGetConcept(client, args) {
+  const input = getConceptInputSchema.parse(args ?? {});
+  try {
+    const data = await client.get(`/concepts/${encodeURIComponent(input.id)}`);
+    return projectConceptResponse(data);
+  } catch (error) {
+    rethrowToolRequestError("memora_get_concept", error);
+  }
+}
+
+// src/tools/handlers/createConceptVersion.ts
+async function handleCreateConceptVersion(client, args) {
+  const input = createConceptVersionInputSchema.parse(args ?? {});
+  if (!isJsonValue(input.value)) {
+    throw new Error("Invalid arguments: value must be a valid JSON value");
+  }
+  const body = { value: input.value };
+  if (input.reason !== void 0) body.reason = input.reason;
+  if (input.confidence !== void 0) body.confidence = input.confidence;
+  if (input.source_ref !== void 0) body.source_ref = input.source_ref;
+  if (input.tags !== void 0) body.tags = input.tags;
+  if (input.parent_id !== void 0) body.parent_id = input.parent_id;
+  try {
+    const path14 = `/concepts/${encodeURIComponent(input.id)}/versions`;
+    return projectCreatedConceptVersionResponse(await client.post(path14, body));
+  } catch (error) {
+    rethrowToolRequestError("memora_create_concept_version", error);
+  }
+}
+
 // src/tools/handlers/bindingStatus.ts
 function buildBindingStatus(binding, options = {}) {
   const status = {
@@ -2315,8 +2637,9 @@ function isHeartbeatDebugEnabled() {
   const value = String(process.env.MEMORAONE_DEBUG_HEARTBEAT ?? "").trim().toLowerCase();
   return ["1", "true", "yes", "on"].includes(value);
 }
+var LOCAL_MCP_HEARTBEAT_INTERVAL_MS = 1e3;
 function resolveHeartbeatIntervalMs() {
-  return Number.isFinite(config2.heartbeatIntervalMs) ? Math.max(1e3, config2.heartbeatIntervalMs) : 3e4;
+  return LOCAL_MCP_HEARTBEAT_INTERVAL_MS;
 }
 function redactSensitiveText(text) {
   return text.replace(/mcs_[A-Za-z0-9_-]+/g, "mcs_[redacted]").replace(/mia_[A-Za-z0-9_-]+/g, "mia_[redacted]").replace(/mir_[A-Za-z0-9_-]+/g, "mir_[redacted]").replace(/mcc_[A-Za-z0-9_-]+/g, "mcc_[redacted]").replace(/Bearer\s+\S+/gi, "Bearer [redacted]");
@@ -2426,6 +2749,7 @@ async function sendProjectHeartbeat(client, ctx) {
 }
 function createDaemonHeartbeat(opts) {
   let interval = null;
+  let runGeneration = 0;
   let client = null;
   let announced = false;
   let studioActive = null;
@@ -2494,21 +2818,24 @@ function createDaemonHeartbeat(opts) {
       studioActive = true;
     }
   };
-  const tick = async () => {
-    if (!client) return;
+  const tick = async (generation) => {
+    if (!client || generation !== runGeneration) return;
     const outcome = await sendProjectHeartbeat(client, ctx);
+    if (generation !== runGeneration || !interval) return;
     applyHeartbeatOutcome(outcome);
   };
   const beginInterval = () => {
     if (interval) return;
     const intervalMs = resolveHeartbeatIntervalMs();
+    const generation = runGeneration;
     log(
       `daemon owns heartbeat for binding=${opts.binding.repositoryBindingId} project=${opts.binding.projectId} ideType=${ctx.ideType ?? "unknown"} interval=${intervalMs}ms`
     );
-    void tick();
     interval = setInterval(() => {
-      void tick();
+      void tick(generation);
     }, intervalMs);
+    interval.unref?.();
+    void tick(generation);
   };
   const start = async () => {
     if (!config2.heartbeatEnabled) {
@@ -2541,6 +2868,7 @@ function createDaemonHeartbeat(opts) {
     }
   };
   const stop = () => {
+    runGeneration += 1;
     if (interval) {
       clearInterval(interval);
       interval = null;
@@ -2560,7 +2888,7 @@ function createDaemonHeartbeat(opts) {
       return;
     }
     if (client && interval) {
-      void tick();
+      void tick(runGeneration);
     }
   };
   const getIdeType = () => ctx.ideType;
@@ -2580,12 +2908,52 @@ function createDaemonHeartbeat(opts) {
 }
 
 // src/ideType.ts
+function mapReliableClientInfoName(name) {
+  if (typeof name !== "string") {
+    return void 0;
+  }
+  const normalized = name.trim().toLowerCase();
+  if (normalized === "") {
+    return void 0;
+  }
+  if (normalized === "claude-code") {
+    return "claude-code";
+  }
+  if (normalized === "devin") {
+    return "windsurf";
+  }
+  if (normalized === "windsurf" || /^windsurf[\s_-].+$/.test(normalized)) {
+    return "windsurf";
+  }
+  return void 0;
+}
+function mapReliableHostIdentity(env2) {
+  if (env2.WINDSURF_IDE_TYPE === "windsurf") {
+    return "windsurf";
+  }
+  if (env2.ACP_BACKEND === "windsurf") {
+    return "windsurf";
+  }
+  if (env2.__CFBundleIdentifier === "com.exafunction.windsurf") {
+    return "windsurf";
+  }
+  return void 0;
+}
 function inferIdeType(params, options = {}) {
   const env2 = options.env ?? process.env;
   const argv = (options.argv ?? process.argv).join(" ").toLowerCase();
-  const configIdeType = options.configIdeType ?? config2.ideType;
-  if (configIdeType) {
-    return configIdeType;
+  const hasExplicitConfigOption = Object.prototype.hasOwnProperty.call(options, "configIdeType");
+  const explicitHint = hasExplicitConfigOption ? options.configIdeType : resolveIdeTypeFromEnv(env2) ?? config2.ideType;
+  const fromClientInfo = mapReliableClientInfoName(params?.clientInfo?.name);
+  if (fromClientInfo) {
+    return fromClientInfo;
+  }
+  const fromHost = mapReliableHostIdentity(env2);
+  if (fromHost) {
+    return fromHost;
+  }
+  if (explicitHint) {
+    return explicitHint;
   }
   const clientInfoName = String(params?.clientInfo?.name ?? "").toLowerCase();
   const clientInfoVersion = String(params?.clientInfo?.version ?? "").toLowerCase();
@@ -2742,7 +3110,11 @@ async function main(opts = {}) {
           `[memoraone-mcp] refreshed stale cached binding ${reconciled.binding.repositoryBindingId}: project=${reconciled.binding.projectId}`
         );
         try {
-          const socketPath = getBindingSocketPath(opts.daemonBindingHint);
+          const socketPath = getBindingSocketPath(
+            opts.daemonBindingHint,
+            process.env,
+            runtime.ideType ?? ""
+          );
           writeBindingSidecar(socketPath, reconciled.binding, runtime.ideType ?? "");
         } catch (err) {
           console.error(
@@ -2935,6 +3307,71 @@ async function main(opts = {}) {
     }
   );
   registeredToolNames.push("memora_log_command");
+  server.registerTool(
+    "memora_list_timeline",
+    {
+      description: listTimelineDescription,
+      inputSchema: listTimelineInputSchema
+    },
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleListTimeline(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_list_timeline");
+  server.registerTool(
+    "memora_list_concepts",
+    {
+      description: listConceptsDescription,
+      inputSchema: listConceptsInputSchema
+    },
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleListConcepts(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_list_concepts");
+  server.registerTool(
+    "memora_get_concept",
+    {
+      description: getConceptDescription,
+      inputSchema: getConceptInputSchema
+    },
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleGetConcept(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_get_concept");
+  server.registerTool(
+    "memora_create_concept_version",
+    {
+      description: createConceptVersionDescription,
+      inputSchema: createConceptVersionInputSchema
+    },
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleCreateConceptVersion(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_create_concept_version");
+  if (registeredToolNames.length !== LOCAL_MCP_TOOL_NAMES.length || registeredToolNames.some(
+    (name) => !LOCAL_MCP_TOOL_NAMES.includes(name)
+  )) {
+    throw new Error("Local MCP tool registration inventory mismatch");
+  }
   server.server.setRequestHandler(
     import_types.InitializeRequestSchema,
     async (request) => runWithSessionContext(sessionContext, async () => {