@memoraone/mcp 0.1.38 → 0.1.40

package/dist/index.cjs

@@ -39,8 +39,8 @@ var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/config.ts
 var process2 = __toESM(require("process"), 1);
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
+var fs2 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
 var dotenv = __toESM(require("dotenv"), 1);
 var import_v4 = require("zod/v4");
 
@@ -62,9 +62,130 @@ function resolveApiUrl(env2) {
   return DEFAULT_API_URL;
 }
 
+// src/socketPaths.ts
+var os = __toESM(require("os"), 1);
+var path2 = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+
+// src/bindingIdentity.ts
+var crypto = __toESM(require("crypto"), 1);
+var path = __toESM(require("path"), 1);
+var BINDING_SOCKET_HASH_LENGTH = 16;
+function hashBindingIdentity(repositoryBindingId, workspaceRoot, ideType) {
+  const input = [
+    repositoryBindingId.trim(),
+    path.resolve(workspaceRoot),
+    ideType
+  ].join("|");
+  return crypto.createHash("sha256").update(input).digest("hex").slice(0, BINDING_SOCKET_HASH_LENGTH);
+}
+function bindingsMatch(a, b) {
+  const envA = a.environment ?? void 0;
+  const envB = b.environment ?? void 0;
+  return a.repositoryBindingId === b.repositoryBindingId && a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path.resolve(a.workspaceRoot) === path.resolve(b.workspaceRoot) && (a.installationPublicId ?? void 0) === (b.installationPublicId ?? void 0) && envA === envB && a.status === b.status;
+}
+function formatMissingInitializeWorkspaceError(options) {
+  const lines = [
+    "[memoraone-mcp] Could not resolve workspace from MCP initialize params."
+  ];
+  if (options?.rootsListAttempted) {
+    lines.push(
+      "Cursor initialize lacked workspaceFolders/rootUri; roots/list was attempted but returned no usable repo root."
+    );
+    if (options.rootsListUris && options.rootsListUris.length > 0) {
+      lines.push(`roots/list URIs: ${options.rootsListUris.join(", ")}`);
+    }
+    lines.push(
+      "Global Cursor MCP cannot safely bind per-window repos without a workspace signal from Cursor (initialize roots or roots/list)."
+    );
+    lines.push(
+      "Reload MCP in this Cursor window, or ensure this repo has a managed .cursor/mcp.json from setup-ide-files --cursor."
+    );
+    return lines.join("\n");
+  }
+  lines.push(
+    "Reload MCP in this Cursor window so initialize includes workspaceFolders, rootUri, or a usable roots/list response for this repo."
+  );
+  return lines.join("\n");
+}
+
+// src/socketPaths.ts
+var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path2.join(os.homedir(), ".memoraone-mcp");
+var HASH_SOCKET_FILENAME_RE = new RegExp(
+  `^mcp-[0-9a-f]{${BINDING_SOCKET_HASH_LENGTH}}\\.sock$`,
+  "i"
+);
+var IDE_TYPES = [
+  "cursor",
+  "copilot-vscode",
+  "jetbrains",
+  "claude-code",
+  "windsurf",
+  "opencode",
+  "codex",
+  "zed",
+  "kiro",
+  "visual-studio",
+  "cline",
+  "roo-code",
+  // dormant: unsupported for setup/connect
+  "auggie",
+  "continue",
+  // dormant: unsupported for setup/connect
+  "copilot-cli",
+  "kiro-cli",
+  "cline-cli",
+  "continue-cli",
+  // dormant: unsupported (no writer; wire id only)
+  "claude-desktop",
+  "gemini-cli",
+  // dormant: individual-user CLI unsupported; writer kept internal
+  "antigravity",
+  "antigravity-cli",
+  // Antigravity CLI (agy); shares MCP config with IDE; identity from clientInfo
+  "goose",
+  "junie",
+  "xcode",
+  "copilot-jetbrains",
+  "copilot-visual-studio"
+];
+var IDE_TYPE_SET = new Set(IDE_TYPES);
+var IDE_TYPE_CLI_CHOICES = IDE_TYPES.join("|");
+var IDE_TYPE_ALTERNATION = [...IDE_TYPES].sort((a, b) => b.length - a.length).join("|");
+var LEGACY_SOCKET_FILENAME_RE = new RegExp(
+  `^mcp-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:-([0-9a-f]{12}))?(?:-(${IDE_TYPE_ALTERNATION}))?\\.sock$`,
+  "i"
+);
+var IDE_FROM_COMMAND_LINE_RE = new RegExp(
+  `--ide\\s+(${IDE_TYPE_ALTERNATION})(?:\\s|$)`
+);
+function parseIdeType(value) {
+  if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
+    return void 0;
+  }
+  return value;
+}
+function resolveIdeTypeFromEnv(env2 = process.env) {
+  return parseIdeType(env2.MEMORAONE_IDE_TYPE);
+}
+function resolveBindingIdeType(env2 = process.env, ideTypeOverride) {
+  if (ideTypeOverride !== void 0) {
+    return ideTypeOverride;
+  }
+  return resolveIdeTypeFromEnv(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, ideTypeOverride) {
+  return path2.join(BASE_DIR, getBindingSocketFilename(binding, env2, ideTypeOverride));
+}
+
 // src/config.ts
-var dotenvPath = path.resolve(process2.cwd(), ".env");
-if (fs.existsSync(dotenvPath)) {
+var dotenvPath = path3.resolve(process2.cwd(), ".env");
+if (fs2.existsSync(dotenvPath)) {
   try {
     dotenv.config({ path: dotenvPath });
   } catch (err) {
@@ -78,7 +199,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(IDE_TYPES).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,11 +248,13 @@ 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
-var crypto = __toESM(require("crypto"), 1);
+var crypto2 = __toESM(require("crypto"), 1);
 
 // src/localState/installationCredentials.ts
 var import_node_crypto2 = require("crypto");
@@ -344,39 +467,39 @@ function hasUsableAccessToken(payload) {
 }
 
 // src/localState/localLocks.ts
-var fs3 = __toESM(require("fs/promises"), 1);
+var fs4 = __toESM(require("fs/promises"), 1);
 
 // src/localState/atomicFs.ts
-var fs2 = __toESM(require("fs/promises"), 1);
-var path2 = __toESM(require("path"), 1);
+var fs3 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
 var import_node_crypto3 = require("crypto");
 var STATE_DIR_MODE = 448;
 var STATE_FILE_MODE = 384;
 async function ensurePrivateDir(dirPath) {
-  await fs2.mkdir(dirPath, { recursive: true, mode: STATE_DIR_MODE });
+  await fs3.mkdir(dirPath, { recursive: true, mode: STATE_DIR_MODE });
   try {
-    await fs2.chmod(dirPath, STATE_DIR_MODE);
+    await fs3.chmod(dirPath, STATE_DIR_MODE);
   } catch {
   }
 }
 async function writeFileAtomic(filePath, content, options = {}) {
   const mode = options.mode ?? STATE_FILE_MODE;
-  const dir = path2.dirname(filePath);
+  const dir = path4.dirname(filePath);
   await ensurePrivateDir(dir);
-  const tmpPath = path2.join(
+  const tmpPath = path4.join(
     dir,
-    `.${path2.basename(filePath)}.${process.pid}.${(0, import_node_crypto3.randomBytes)(8).toString("hex")}.tmp`
+    `.${path4.basename(filePath)}.${process.pid}.${(0, import_node_crypto3.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs2.writeFile(tmpPath, content, { encoding: "utf8", mode });
-    await fs2.rename(tmpPath, filePath);
+    await fs3.writeFile(tmpPath, content, { encoding: "utf8", mode });
+    await fs3.rename(tmpPath, filePath);
     try {
-      await fs2.chmod(filePath, mode);
+      await fs3.chmod(filePath, mode);
     } catch {
     }
   } catch (err) {
     try {
-      await fs2.unlink(tmpPath);
+      await fs3.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -384,7 +507,7 @@ async function writeFileAtomic(filePath, content, options = {}) {
 }
 async function readJsonFile(filePath) {
   try {
-    const raw = await fs2.readFile(filePath, "utf8");
+    const raw = await fs3.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch (err) {
     if (err?.code === "ENOENT") {
@@ -402,26 +525,26 @@ async function writeJsonAtomic(filePath, value, options = {}) {
 }
 
 // src/localState/statePaths.ts
-var os = __toESM(require("os"), 1);
-var path3 = __toESM(require("path"), 1);
+var os2 = __toESM(require("os"), 1);
+var path5 = __toESM(require("path"), 1);
 var MEMORAONE_STATE_DIRNAME = ".memoraone";
-function getMemoraoneStateDir(homeDir = os.homedir()) {
-  return path3.join(homeDir, MEMORAONE_STATE_DIRNAME);
+function getMemoraoneStateDir(homeDir = os2.homedir()) {
+  return path5.join(homeDir, MEMORAONE_STATE_DIRNAME);
 }
-function getPathIndexPath(homeDir = os.homedir()) {
-  return path3.join(getMemoraoneStateDir(homeDir), "path-index.json");
+function getPathIndexPath(homeDir = os2.homedir()) {
+  return path5.join(getMemoraoneStateDir(homeDir), "path-index.json");
 }
-function getBindingsDir(homeDir = os.homedir()) {
-  return path3.join(getMemoraoneStateDir(homeDir), "bindings");
+function getBindingsDir(homeDir = os2.homedir()) {
+  return path5.join(getMemoraoneStateDir(homeDir), "bindings");
 }
-function getBindingFilePath(repositoryBindingId, homeDir = os.homedir()) {
-  return path3.join(getBindingsDir(homeDir), `${repositoryBindingId}.json`);
+function getBindingFilePath(repositoryBindingId, homeDir = os2.homedir()) {
+  return path5.join(getBindingsDir(homeDir), `${repositoryBindingId}.json`);
 }
-function getLocksDir(homeDir = os.homedir()) {
-  return path3.join(getMemoraoneStateDir(homeDir), "locks");
+function getLocksDir(homeDir = os2.homedir()) {
+  return path5.join(getMemoraoneStateDir(homeDir), "locks");
 }
-function getLockPath(lockName, homeDir = os.homedir()) {
-  return path3.join(getLocksDir(homeDir), `${lockName}.lock`);
+function getLockPath(lockName, homeDir = os2.homedir()) {
+  return path5.join(getLocksDir(homeDir), `${lockName}.lock`);
 }
 
 // src/localState/localLocks.ts
@@ -436,16 +559,16 @@ async function acquireLocalLock(lockName, options = {}) {
   while (retries <= maxRetries) {
     try {
       try {
-        const stat3 = await fs3.stat(lockPath);
+        const stat3 = await fs4.stat(lockPath);
         if (Date.now() - stat3.mtimeMs > maxLockAgeMs) {
-          await fs3.unlink(lockPath);
+          await fs4.unlink(lockPath);
         }
       } catch (err) {
         if (err?.code !== "ENOENT") {
           throw err;
         }
       }
-      const fd = await fs3.open(lockPath, "wx");
+      const fd = await fs4.open(lockPath, "wx");
       await fd.writeFile(
         JSON.stringify({
           pid: process.pid,
@@ -456,7 +579,7 @@ async function acquireLocalLock(lockName, options = {}) {
       await fd.close();
       return async () => {
         try {
-          await fs3.unlink(lockPath);
+          await fs4.unlink(lockPath);
         } catch (err) {
           if (err?.code !== "ENOENT") {
           }
@@ -595,8 +718,8 @@ async function refreshInstallationAccessToken(options) {
 }
 
 // src/localState/bindingStore.ts
-var fs4 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs/promises"), 1);
+var path6 = __toESM(require("path"), 1);
 
 // src/localState/bindingRecord.ts
 var BINDING_RECORD_VERSION = 1;
@@ -827,7 +950,7 @@ var MemoraClient = class {
     };
   }
   async perform(method, path14, body, options, retried = false) {
-    const nonce = crypto.randomBytes(8).toString("hex");
+    const nonce = crypto2.randomBytes(8).toString("hex");
     const url = `${this.baseUrl}${path14.startsWith("/") ? path14 : `/${path14}`}`;
     this.resolveProjectId();
     console.error(
@@ -891,20 +1014,20 @@ var MemoraClient = class {
 var memoraClient_default = MemoraClient;
 
 // src/projectBinding.ts
-var fs7 = __toESM(require("fs/promises"), 1);
-var path8 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs/promises"), 1);
+var path10 = __toESM(require("path"), 1);
 
 // src/localState/resolveLocalBinding.ts
-var fs6 = __toESM(require("fs/promises"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs7 = __toESM(require("fs/promises"), 1);
+var path9 = __toESM(require("path"), 1);
 
 // src/localState/pathIndex.ts
-var path6 = __toESM(require("path"), 1);
+var path8 = __toESM(require("path"), 1);
 
 // src/localState/rootFilesystemIdentity.ts
-var fs5 = __toESM(require("fs/promises"), 1);
-var os2 = __toESM(require("os"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
+var os3 = __toESM(require("os"), 1);
+var path7 = __toESM(require("path"), 1);
 var import_node_child_process = require("child_process");
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
@@ -929,13 +1052,13 @@ async function readDarwinDeviceId() {
 }
 async function readLinuxDeviceId() {
   try {
-    const content = await fs5.readFile("/etc/machine-id", "utf8");
+    const content = await fs6.readFile("/etc/machine-id", "utf8");
     const id = content.trim();
     if (id) return id;
   } catch {
   }
   try {
-    const content = await fs5.readFile("/var/lib/dbus/machine-id", "utf8");
+    const content = await fs6.readFile("/var/lib/dbus/machine-id", "utf8");
     const id = content.trim();
     if (id) return id;
   } catch {
@@ -955,7 +1078,7 @@ async function readWindowsDeviceId() {
   }
   return match[1].trim();
 }
-async function resolveDeviceId(platform2 = os2.platform()) {
+async function resolveDeviceId(platform2 = os3.platform()) {
   if (platform2 === "darwin") return readDarwinDeviceId();
   if (platform2 === "linux") return readLinuxDeviceId();
   if (platform2 === "win32") return readWindowsDeviceId();
@@ -968,10 +1091,10 @@ async function resolveDeviceId(platform2 = os2.platform()) {
   throw new Error(`[memoraone-mcp] Unsupported platform for device ID: ${platform2}`);
 }
 async function captureRootFilesystemIdentity(rootPath, deps = {}) {
-  const resolved = path5.resolve(rootPath);
-  const platform2 = deps.platform ?? os2.platform();
+  const resolved = path7.resolve(rootPath);
+  const platform2 = deps.platform ?? os3.platform();
   const statRoot = deps.statRoot ?? (async (p) => {
-    const st2 = await fs5.stat(p);
+    const st2 = await fs6.stat(p);
     return {
       ino: st2.ino,
       dev: st2.dev,
@@ -1055,7 +1178,7 @@ async function savePathIndex(index, homeDir) {
   await writeJsonAtomic(getPathIndexPath(homeDir), next);
 }
 function lookupPathIndex(index, workspaceRoot, identity) {
-  const resolved = path6.resolve(workspaceRoot);
+  const resolved = path8.resolve(workspaceRoot);
   const byPathId = index.byPath[resolved];
   if (byPathId) {
     return { kind: "path", repositoryBindingId: assertRepositoryBindingId(byPathId) };
@@ -1081,14 +1204,14 @@ function lookupPathIndex(index, workspaceRoot, identity) {
 }
 async function upsertPathIndexEntry(options) {
   const repositoryBindingId = assertRepositoryBindingId(options.repositoryBindingId);
-  const resolved = path6.resolve(options.workspaceRoot);
+  const resolved = path8.resolve(options.workspaceRoot);
   const identityKey = filesystemIdentityKey(options.identity);
   return withLocalLock(
     "path-index",
     async () => {
       const index = await loadPathIndex(options.homeDir);
-      if (options.previousPath && path6.resolve(options.previousPath) !== resolved) {
-        delete index.byPath[path6.resolve(options.previousPath)];
+      if (options.previousPath && path8.resolve(options.previousPath) !== resolved) {
+        delete index.byPath[path8.resolve(options.previousPath)];
       }
       for (const [p, id] of Object.entries(index.byPath)) {
         if (id === repositoryBindingId && p !== resolved) {
@@ -1114,16 +1237,16 @@ function identityMatchesStored(stored, current) {
 
 // src/localState/resolveLocalBinding.ts
 async function detectLegacyM1Warning(workspaceRoot) {
-  const candidate = path7.join(path7.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
+  const candidate = path9.join(path9.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
   try {
-    await fs6.access(candidate);
+    await fs7.access(candidate);
     return candidate;
   } catch {
     return void 0;
   }
 }
 async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
-  const resolved = path7.resolve(workspaceRoot);
+  const resolved = path9.resolve(workspaceRoot);
   const identity = await captureRootFilesystemIdentity(resolved, options.identityDeps);
   const legacyM1WarningPath = await detectLegacyM1Warning(resolved);
   const index = await loadPathIndex(options.homeDir);
@@ -1131,7 +1254,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   if (lookup.kind === "path") {
     const record = await readBindingRecord(lookup.repositoryBindingId, options.homeDir);
     if (record && identityMatchesStored(record.filesystemIdentity, identity)) {
-      if (path7.resolve(record.workspaceRoot) !== resolved) {
+      if (path9.resolve(record.workspaceRoot) !== resolved) {
         const updated = {
           ...record,
           workspaceRoot: resolved,
@@ -1193,7 +1316,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   };
 }
 async function resolveLocalBinding(workspaceRoot, options = {}) {
-  const resolved = path7.resolve(workspaceRoot);
+  const resolved = path9.resolve(workspaceRoot);
   const { repositoryBindingId, legacyM1WarningPath } = await ensureRepositoryBindingForRoot(
     resolved,
     { ...options, createIfMissing: false }
@@ -1257,9 +1380,9 @@ function toResolvedBinding(local) {
   };
 }
 async function warnLegacyM1IfPresent(workspaceRoot) {
-  const candidate = path8.join(path8.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
+  const candidate = path10.join(path10.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
   try {
-    await fs7.access(candidate);
+    await fs8.access(candidate);
     process.stderr.write(
       `[memoraone-mcp] warning: ignoring legacy ${CANONICAL_M1_FILENAME} (not used for credentials or binding)
 `
@@ -1316,7 +1439,7 @@ function normalizeWorkspaceSearchRoots(workspaceRoot) {
     if (raw === void 0) continue;
     const trimmed = String(raw).trim();
     if (trimmed === "") continue;
-    const resolved = path8.resolve(trimmed);
+    const resolved = path10.resolve(trimmed);
     if (!seen.has(resolved)) {
       seen.add(resolved);
       out.push(resolved);
@@ -1327,7 +1450,7 @@ function normalizeWorkspaceSearchRoots(workspaceRoot) {
 function bindingRelevantValuesMatch(a, b) {
   const envA = a.environment ?? void 0;
   const envB = b.environment ?? void 0;
-  return a.repositoryBindingId === b.repositoryBindingId && a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path8.resolve(a.workspaceRoot) === path8.resolve(b.workspaceRoot) && (a.installationPublicId ?? void 0) === (b.installationPublicId ?? void 0) && envA === envB && a.status === b.status;
+  return a.repositoryBindingId === b.repositoryBindingId && a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path10.resolve(a.workspaceRoot) === path10.resolve(b.workspaceRoot) && (a.installationPublicId ?? void 0) === (b.installationPublicId ?? void 0) && envA === envB && a.status === b.status;
 }
 async function reconcileResolvedBindingWithDisk(cached) {
   const repositoryBindingId = assertRepositoryBindingId(cached.repositoryBindingId);
@@ -1337,7 +1460,7 @@ async function reconcileResolvedBindingWithDisk(cached) {
       `[memoraone-mcp] Cached binding missing for ${repositoryBindingId}. Run: memoraone-mcp connect <code>`
     );
   }
-  const workspaceRoot = path8.resolve(record.workspaceRoot);
+  const workspaceRoot = path10.resolve(record.workspaceRoot);
   const identity = await captureRootFilesystemIdentity(workspaceRoot);
   if (!identitiesMatch(record.filesystemIdentity, identity)) {
     throw new ReconnectRequiredError(
@@ -1379,82 +1502,6 @@ function encodeResolvedBinding(binding) {
 // src/initializeBinding.ts
 var path11 = __toESM(require("path"), 1);
 var import_node_url = require("url");
-
-// src/bindingIdentity.ts
-var crypto2 = __toESM(require("crypto"), 1);
-var path9 = __toESM(require("path"), 1);
-var BINDING_SOCKET_HASH_LENGTH = 16;
-function hashBindingIdentity(repositoryBindingId, workspaceRoot, ideType) {
-  const input = [
-    repositoryBindingId.trim(),
-    path9.resolve(workspaceRoot),
-    ideType
-  ].join("|");
-  return crypto2.createHash("sha256").update(input).digest("hex").slice(0, BINDING_SOCKET_HASH_LENGTH);
-}
-function bindingsMatch(a, b) {
-  const envA = a.environment ?? void 0;
-  const envB = b.environment ?? void 0;
-  return a.repositoryBindingId === b.repositoryBindingId && a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path9.resolve(a.workspaceRoot) === path9.resolve(b.workspaceRoot) && (a.installationPublicId ?? void 0) === (b.installationPublicId ?? void 0) && envA === envB && a.status === b.status;
-}
-function formatMissingInitializeWorkspaceError(options) {
-  const lines = [
-    "[memoraone-mcp] Could not resolve workspace from MCP initialize params."
-  ];
-  if (options?.rootsListAttempted) {
-    lines.push(
-      "Cursor initialize lacked workspaceFolders/rootUri; roots/list was attempted but returned no usable repo root."
-    );
-    if (options.rootsListUris && options.rootsListUris.length > 0) {
-      lines.push(`roots/list URIs: ${options.rootsListUris.join(", ")}`);
-    }
-    lines.push(
-      "Global Cursor MCP cannot safely bind per-window repos without a workspace signal from Cursor (initialize roots or roots/list)."
-    );
-    lines.push(
-      "Reload MCP in this Cursor window, or ensure this repo has a managed .cursor/mcp.json from setup-ide-files --cursor."
-    );
-    return lines.join("\n");
-  }
-  lines.push(
-    "Reload MCP in this Cursor window so initialize includes workspaceFolders, rootUri, or a usable roots/list response for this repo."
-  );
-  return lines.join("\n");
-}
-
-// src/socketPaths.ts
-var os3 = __toESM(require("os"), 1);
-var path10 = __toESM(require("path"), 1);
-var fs8 = __toESM(require("fs"), 1);
-var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path10.join(os3.homedir(), ".memoraone-mcp");
-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_TYPE_SET = new Set(IDE_TYPES);
-function parseIdeType(value) {
-  if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
-    return void 0;
-  }
-  return value;
-}
-function resolveIdeTypeFromEnv(env2 = process.env) {
-  return parseIdeType(env2.MEMORAONE_IDE_TYPE);
-}
-function resolveBindingIdeType(env2 = process.env) {
-  return resolveIdeTypeFromEnv(env2) ?? "";
-}
-function getBindingSocketFilename(binding, env2 = process.env) {
-  const ideType = resolveBindingIdeType(env2);
-  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));
-}
-
-// src/initializeBinding.ts
 var MEMORAONE_WORKSPACE_ROOT_ENV = "MEMORAONE_WORKSPACE_ROOT";
 function getBridgeBindingResolveOptions(env2 = process.env) {
   const ideType = resolveIdeTypeFromEnv(env2);
@@ -1770,8 +1817,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 +1945,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 +2024,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 +2072,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 +2114,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 +2156,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 +2198,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 +2246,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 +2292,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 +2340,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 +2383,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 +2671,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 +2783,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 +2852,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 +2902,7 @@ function createDaemonHeartbeat(opts) {
     }
   };
   const stop = () => {
+    runGeneration += 1;
     if (interval) {
       clearInterval(interval);
       interval = null;
@@ -2560,7 +2922,7 @@ function createDaemonHeartbeat(opts) {
       return;
     }
     if (client && interval) {
-      void tick();
+      void tick(runGeneration);
     }
   };
   const getIdeType = () => ctx.ideType;
@@ -2580,12 +2942,125 @@ function createDaemonHeartbeat(opts) {
 }
 
 // src/ideType.ts
+var RELIABLE_CLIENT_INFO_NAMES = /* @__PURE__ */ new Map([
+  // Existing
+  ["claude-code", "claude-code"],
+  ["devin", "windsurf"],
+  ["windsurf", "windsurf"],
+  // Zed
+  ["zed", "zed"],
+  // Kiro IDE (exact only — not generic "kiro …" mcp-remote wrappers)
+  ["kiro", "kiro"],
+  // Visual Studio (never Visual Studio Code)
+  ["visual studio", "visual-studio"],
+  ["visual-studio", "visual-studio"],
+  // Cline IDE
+  ["cline", "cline"],
+  // Roo Code
+  ["roo code", "roo-code"],
+  ["roo-code", "roo-code"],
+  // Auggie / Augment Code (canonical wire ID: auggie)
+  ["auggie", "auggie"],
+  ["augment", "auggie"],
+  ["augment code", "auggie"],
+  ["augment-code", "auggie"],
+  // Continue IDE (not bare "continue")
+  ["continue-client", "continue"],
+  // Continue CLI
+  ["continue-cli-client", "continue-cli"],
+  ["continue-cli", "continue-cli"],
+  ["continue cli", "continue-cli"],
+  // Copilot CLI (not GitHub Copilot in VS Code)
+  ["github-copilot-developer", "copilot-cli"],
+  ["copilot-cli", "copilot-cli"],
+  ["copilot cli", "copilot-cli"],
+  // Kiro CLI (explicit CLI names only — not Amazon Q / Q-DEV-CLI)
+  ["kiro-cli", "kiro-cli"],
+  ["kiro cli", "kiro-cli"],
+  // Cline CLI
+  ["cline-cli", "cline-cli"],
+  ["cline cli", "cline-cli"],
+  // Claude Desktop (never bare "claude"; never claude-code)
+  ["claude-ai", "claude-desktop"],
+  ["claude-desktop", "claude-desktop"],
+  ["claude desktop", "claude-desktop"],
+  // Gemini CLI (not bare "gemini")
+  ["gemini-cli", "gemini-cli"],
+  ["gemini cli", "gemini-cli"],
+  // Google Antigravity IDE vs CLI (shared MCP config; clientInfo distinguishes)
+  ["antigravity", "antigravity"],
+  ["antigravity ide", "antigravity"],
+  ["antigravity-client", "antigravity-cli"],
+  // Goose
+  ["goose", "goose"],
+  // JetBrains Junie (distinct from generic jetbrains / copilot-jetbrains)
+  ["junie", "junie"],
+  // GitHub Copilot for Xcode
+  ["xcode", "xcode"],
+  ["copilot-xcode", "xcode"],
+  ["github-copilot-xcode", "xcode"],
+  // GitHub Copilot for JetBrains (distinct from jetbrains AI Assistant)
+  ["copilot-jetbrains", "copilot-jetbrains"],
+  ["github-copilot-jetbrains", "copilot-jetbrains"],
+  ["github copilot jetbrains", "copilot-jetbrains"],
+  // GitHub Copilot in Visual Studio (distinct from visual-studio / copilot-vscode)
+  ["copilot-visual-studio", "copilot-visual-studio"],
+  ["github-copilot-visual-studio", "copilot-visual-studio"],
+  ["github copilot visual studio", "copilot-visual-studio"]
+]);
+function mapReliableClientInfoName(name) {
+  if (typeof name !== "string") {
+    return void 0;
+  }
+  const normalized = name.trim().toLowerCase();
+  if (normalized === "") {
+    return void 0;
+  }
+  const exact = RELIABLE_CLIENT_INFO_NAMES.get(normalized);
+  if (exact) {
+    return exact;
+  }
+  if (/^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";
+  }
+  if (env2.__CFBundleIdentifier === "com.anthropic.claudefordesktop") {
+    return "claude-desktop";
+  }
+  if (env2.__CFBundleIdentifier === "dev.zed.Zed") {
+    return "zed";
+  }
+  if (Object.prototype.hasOwnProperty.call(env2, "COPILOT_CLI")) {
+    return "copilot-cli";
+  }
+  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();
@@ -2610,7 +3085,7 @@ function inferIdeType(params, options = {}) {
   if (hasJetBrainsSignals) {
     return "jetbrains";
   }
-  const hasVsCodeSignals = envKeys.some((key) => key.startsWith("VSCODE_")) || /(visual studio code|vscode|vs code|github copilot)/.test(clientInfoName) || /(visual studio code|vscode|vs code)/.test(argv);
+  const hasVsCodeSignals = envKeys.some((key) => key.startsWith("VSCODE_")) || /(visual studio code|vscode|vs code)/.test(clientInfoName) || /(visual studio code|vscode|vs code)/.test(argv);
   if (hasVsCodeSignals) {
     return "copilot-vscode";
   }
@@ -2742,7 +3217,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 +3414,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 () => {