@memoraone/mcp 0.1.17 → 0.1.19

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.17",
+      version: "0.1.19",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -46,8 +46,11 @@ var require_package = __commonJS({
       scripts: {
         build: "tsup && node scripts/writeBinWrapper.cjs",
         prepublishOnly: "pnpm run build",
-        dev: "tsx src/index.ts",
-        lint: "eslint ."
+        dev: "tsx src/cli.ts",
+        lint: "eslint .",
+        "lint:contracts": "node scripts/lint-contracts.cjs",
+        test: "pnpm run lint:contracts && node --import=tsx --test test/*.test.js",
+        "validate:auth": "node --import=tsx --test test/memoraClient.test.js"
       },
       dependencies: {
         "@modelcontextprotocol/sdk": "^1.25.1",
@@ -63,302 +66,75 @@ var require_package = __commonJS({
   }
 });
 
-// src/index.ts
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+// src/cli.ts
+var path3 = __toESM(require("path"), 1);
+var net = __toESM(require("net"), 1);
+var import_node_child_process = require("child_process");
 
-// src/config.ts
-var process2 = __toESM(require("process"), 1);
-var fs = __toESM(require("fs"), 1);
+// src/socketPaths.ts
+var os = __toESM(require("os"), 1);
 var path = __toESM(require("path"), 1);
-var import_dotenv = __toESM(require("dotenv"), 1);
-var import_v4 = require("zod/v4");
-
-// src/configUtils.ts
-var DEFAULT_API_URL = "https://api.memoraone.com";
-var DEV_API_URL = "http://localhost:3001";
-function resolveApiUrl(env2) {
-  const explicitUrl = env2.MEMORAONE_API_URL?.trim();
-  if (explicitUrl) {
-    return explicitUrl;
-  }
-  if (env2.MEMORAONE_DEV_MODE === "1") {
-    return DEV_API_URL;
-  }
-  return DEFAULT_API_URL;
+var fs = __toESM(require("fs"), 1);
+var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path.join(os.homedir(), ".memoraone-mcp");
+function getSocketPath(projectId) {
+  return path.join(BASE_DIR, `mcp-${projectId}.sock`);
+}
+function ensureBaseDir() {
+  fs.mkdirSync(BASE_DIR, { recursive: true });
+  return BASE_DIR;
 }
 
-// src/config.ts
-var dotenvPath = path.resolve(process2.cwd(), ".env");
-if (fs.existsSync(dotenvPath)) {
+// src/projectBinding.ts
+var fs2 = __toESM(require("fs/promises"), 1);
+var path2 = __toESM(require("path"), 1);
+var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseAndValidateM1(content, markerPath) {
+  let parsed;
   try {
-    import_dotenv.default.config({ path: dotenvPath });
-  } catch (err) {
-    process2.stderr.write("[memoraone-mcp] Failed to load .env: " + String(err) + "\n");
-  }
-}
-var EnvSchema = import_v4.z.object({
-  MEMORAONE_API_URL: import_v4.z.string().url().optional(),
-  MEMORAONE_API_KEY: import_v4.z.string().min(1),
-  MEMORAONE_DEV_MODE: import_v4.z.string().min(1).optional(),
-  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_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()
-});
-var requiredEnvVars = ["MEMORAONE_API_KEY"];
-var missingEnvVars = requiredEnvVars.filter((key) => {
-  const value = process2.env[key];
-  return value === void 0 || value.trim() === "";
-});
-if (missingEnvVars.length > 0) {
-  for (const key of missingEnvVars) {
-    process2.stderr.write(`Missing ${key}
-`);
-  }
-  process2.exit(1);
-}
-var parsed = EnvSchema.safeParse(process2.env);
-var resolvedApiUrl = resolveApiUrl(process2.env);
-if (!parsed.success) {
-  const formatted = parsed.error.format();
-  process2.stderr.write(
-    "[memoraone-mcp] Invalid environment variables " + JSON.stringify(formatted) + "\n"
-  );
-  throw new Error("Config validation failed");
-}
-var parseBooleanFlag = (value, defaultValue) => {
-  if (value === void 0) {
-    return defaultValue;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (["1", "true", "yes", "on"].includes(normalized)) {
-    return true;
-  }
-  if (["0", "false", "no", "off"].includes(normalized)) {
-    return false;
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`[memoraone-mcp] Invalid memoraone.m1 JSON at ${markerPath}`);
   }
-  return defaultValue;
-};
-var config = {
-  apiUrl: resolvedApiUrl.replace(/\/+$/, ""),
-  apiKey: parsed.data.MEMORAONE_API_KEY,
-  agentName: parsed.data.MEMORAONE_AGENT_NAME ?? "cursor",
-  agentType: parsed.data.MEMORAONE_AGENT_TYPE ?? "agent",
-  source: parsed.data.MEMORAONE_SOURCE ?? "cursor",
-  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)
-};
-
-// src/client/memoraClient.ts
-var crypto2 = __toESM(require("crypto"), 1);
-
-// src/runContext.ts
-var crypto = __toESM(require("crypto"), 1);
-var currentRunId = null;
-var currentProjectId = null;
-function setCurrentRunId(id) {
-  currentRunId = id;
-}
-function getCurrentProjectId() {
-  return currentProjectId;
-}
-function setCurrentProjectId(id) {
-  currentProjectId = id;
-}
-function resolveRunId(passed) {
-  if (passed) {
-    return passed;
+  const projectId = parsed?.projectId ?? parsed?.project_id;
+  if (!projectId || typeof projectId !== "string") {
+    throw new Error(`[memoraone-mcp] memoraone.m1 missing projectId at ${markerPath}`);
   }
-  return currentRunId;
-}
-function generateRunId() {
-  return crypto.randomBytes(16).toString("hex");
-}
-
-// src/client/memoraClient.ts
-var parseBooleanFlag2 = (value) => {
-  if (!value) {
-    return false;
+  if (!uuidRegex.test(projectId.trim())) {
+    throw new Error(`[memoraone-mcp] memoraone.m1 projectId is not a UUID at ${markerPath}`);
   }
-  const normalized = value.trim().toLowerCase();
-  return ["1", "true", "yes", "on"].includes(normalized);
-};
-var debugEnabled = parseBooleanFlag2(process.env.MEMORAONE_DEV_MODE);
-async function requestJson(url, method, headers, body) {
-  const res = await fetch(url, {
-    method,
-    headers,
-    body: method === "GET" ? void 0 : JSON.stringify(body ?? {})
-  });
-  const text = await res.text();
-  return {
-    status: res.status,
-    statusText: res.statusText,
-    ok: res.ok,
-    text
-  };
+  const apiKeyRaw = parsed?.MEMORAONE_API_KEY ?? parsed?.api_key;
+  const apiKey = apiKeyRaw !== void 0 && apiKeyRaw !== null && typeof apiKeyRaw === "string" && apiKeyRaw.trim() !== "" ? apiKeyRaw.trim() : null;
+  return { projectId: projectId.trim(), apiKey };
 }
-var MemoraOneHttpError = class extends Error {
-  constructor(status, statusText, body) {
-    super(`MemoraOne request failed: ${status} ${statusText}`);
-    this.name = "MemoraOneHttpError";
-    this.status = status;
-    this.body = body;
-  }
-};
-var MemoraClient = class {
-  constructor(cfg, projectKey) {
-    if (!projectKey?.trim()) {
-      throw new Error("[memoraone-mcp] Invalid projectKey for MemoraClient");
-    }
-    this.baseUrl = cfg.apiUrl;
-    this.apiKey = cfg.apiKey;
-    this.projectKey = projectKey;
-  }
-  resolveProjectKey() {
-    const selected = getCurrentProjectId();
-    const projectKey = (selected ?? this.projectKey)?.trim();
-    if (!projectKey) {
-      throw new Error("Missing projectKey: select a project first");
-    }
-    return projectKey;
-  }
-  buildHeaders(options) {
-    return {
-      "content-type": "application/json",
-      "x-api-key": this.apiKey,
-      ...options?.headers ?? {}
-    };
-  }
-  async post(path5, body, options) {
-    console.error(
-      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path5}`
-    );
-    const nonce = crypto2.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path5.startsWith("/") ? path5 : `/${path5}`}`;
-    this.resolveProjectKey();
-    console.error(
-      `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=POST url=${url}`
-    );
-    const res = await requestJson(url, "POST", this.buildHeaders(options), body);
-    if (debugEnabled && options?.log !== false) {
-      const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
-      console.error(
-        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_response_log`
-      );
-      const line = `[memoraone-mcp][info] http response method=POST url=${url} status=${res.status} body=${snippet}`;
-      console.error(line);
-      console.error(
-        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=after_response_log`
-      );
-    }
-    if (!res.ok) {
-      const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
-      process.stderr.write(
-        `[memoraone-mcp][error] http error method=POST url=${url} status=${res.status} body=${snippet}
-`
-      );
-      throw new MemoraOneHttpError(res.status, res.statusText, res.text);
-    }
-    console.error(
-      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path5}`
-    );
-    return res.text ? JSON.parse(res.text) : null;
-  }
-  async get(path5, options) {
-    const nonce = crypto2.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path5.startsWith("/") ? path5 : `/${path5}`}`;
-    this.resolveProjectKey();
-    console.error(
-      `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=GET url=${url}`
-    );
-    const res = await requestJson(url, "GET", this.buildHeaders(options));
-    if (debugEnabled && options?.log !== false) {
-      const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
-      console.error(
-        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_response_log`
-      );
-      const line = `[memoraone-mcp][info] http response method=GET url=${url} status=${res.status} body=${snippet}`;
-      console.error(line);
-      console.error(
-        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=after_response_log`
-      );
-    }
-    if (!res.ok) {
-      const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
-      process.stderr.write(
-        `[memoraone-mcp][error] http error method=GET url=${url} status=${res.status} body=${snippet}
-`
-      );
-      throw new MemoraOneHttpError(res.status, res.statusText, res.text);
-    }
-    return res.text ? JSON.parse(res.text) : null;
-  }
-};
-var memoraClient_default = MemoraClient;
-
-// src/repoFingerprint.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-var crypto3 = __toESM(require("crypto"), 1);
-var parseBooleanFlag3 = (value) => {
-  if (!value) {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return ["1", "true", "yes", "on"].includes(normalized);
-};
-var debugEnabled2 = parseBooleanFlag3(process.env.MEMORAONE_DEV_MODE);
-var debugLog = (message) => {
-  if (!debugEnabled2) {
-    return;
+async function resolveProjectIdFromExplicitM1Path() {
+  const raw = process.env.MEMORAONE_M1_PATH;
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
   }
-  process.stderr.write(`[memoraone-mcp][debug] ${message}
-`);
-};
-var normalizeRemoteUrl = (remoteUrl) => {
-  let normalized = remoteUrl.trim();
-  normalized = normalized.replace(/^[a-z]+:\/\//i, "");
-  normalized = normalized.replace(/^git@([^:]+):/i, "$1/");
-  normalized = normalized.replace(/\.git$/i, "");
-  normalized = normalized.replace(/\/+$/, "");
-  return normalized.toLowerCase();
-};
-var sha256 = (value) => {
-  return crypto3.createHash("sha256").update(value).digest("hex");
-};
-var resolveGitDir = (gitPath) => {
+  const markerPath = path2.resolve(raw);
   try {
-    const stat = fs2.statSync(gitPath);
-    if (stat.isDirectory()) {
-      return gitPath;
-    }
-    if (stat.isFile()) {
-      const content = fs2.readFileSync(gitPath, "utf8");
-      const match = content.match(/^gitdir:\s*(.+)$/m);
-      if (match) {
-        const gitDir = match[1].trim();
-        return path2.resolve(path2.dirname(gitPath), gitDir);
-      }
+    const content = await fs2.readFile(markerPath, "utf8");
+    const { projectId, apiKey } = parseAndValidateM1(content, markerPath);
+    return { projectId, apiKey, foundAt: markerPath };
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      return null;
     }
-  } catch {
-    return null;
+    throw err;
   }
-  return null;
-};
-var findGitRoot = (start) => {
-  let current = path2.resolve(start);
+}
+async function findM1WalkingUp(workspaceRoot) {
+  let current = path2.resolve(workspaceRoot);
   while (true) {
-    const gitPath = path2.join(current, ".git");
-    if (fs2.existsSync(gitPath)) {
-      const gitDir = resolveGitDir(gitPath);
-      if (gitDir) {
-        return { gitRoot: current, gitDir };
+    const markerPath = path2.join(current, "memoraone.m1");
+    try {
+      const content = await fs2.readFile(markerPath, "utf8");
+      const { projectId, apiKey } = parseAndValidateM1(content, markerPath);
+      const repoRoot = path2.dirname(markerPath);
+      return { projectId, apiKey, repoRoot, markerPath };
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        throw err;
       }
     }
     const parent = path2.dirname(current);
@@ -368,943 +144,80 @@ var findGitRoot = (start) => {
     current = parent;
   }
   return null;
-};
-var readOriginRemote = (gitDir) => {
-  const configPath = path2.join(gitDir, "config");
-  try {
-    const content = fs2.readFileSync(configPath, "utf8");
-    const lines = content.split(/\r?\n/);
-    let inOrigin = false;
-    for (const line of lines) {
-      const sectionMatch = line.match(/^\s*\[(.+)]\s*$/);
-      if (sectionMatch) {
-        inOrigin = sectionMatch[1].trim() === 'remote "origin"';
-        continue;
-      }
-      if (inOrigin) {
-        const urlMatch = line.match(/^\s*url\s*=\s*(.+)\s*$/);
-        if (urlMatch) {
-          return urlMatch[1].trim();
-        }
-      }
-    }
-  } catch {
-    return null;
-  }
-  return null;
-};
-function resolveRepoFingerprint(cwd2) {
-  const found = findGitRoot(cwd2);
-  if (!found) {
-    const fallbackPath = path2.resolve(cwd2);
-    const fingerprint2 = sha256(fallbackPath);
-    debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
-    return {
-      fingerprint: fingerprint2,
-      gitRoot: fallbackPath,
-      source: "path-fallback"
-    };
-  }
-  const { gitRoot, gitDir } = found;
-  const remoteUrl = readOriginRemote(gitDir);
-  if (remoteUrl) {
-    const normalized = normalizeRemoteUrl(remoteUrl);
-    const fingerprint2 = sha256(normalized);
-    debugLog(`repo fingerprint=${fingerprint2} source=git-remote`);
-    return {
-      fingerprint: fingerprint2,
-      gitRoot,
-      remoteUrl,
-      source: "git-remote"
-    };
-  }
-  const fingerprint = sha256(path2.resolve(gitRoot));
-  debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
-  return {
-    fingerprint,
-    gitRoot,
-    source: "path-fallback"
-  };
-}
-
-// src/workspaceMap.ts
-var fs3 = __toESM(require("fs/promises"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_node_os = __toESM(require("os"), 1);
-var parseBooleanFlag4 = (value) => {
-  if (!value) {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return ["1", "true", "yes", "on"].includes(normalized);
-};
-var debugEnabled3 = parseBooleanFlag4(process.env.MEMORAONE_DEV_MODE);
-var debugLog2 = (message) => {
-  if (!debugEnabled3) {
-    return;
-  }
-  process.stderr.write(`[memoraone-mcp][debug] ${message}
-`);
-};
-var fingerprintRegex = /^[0-9a-f]{64}$/i;
-function getWorkspaceMapPath() {
-  return path3.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
 }
-var ensureWorkspaceDir = async () => {
-  const dir = path3.dirname(getWorkspaceMapPath());
-  await fs3.mkdir(dir, { recursive: true });
-};
-var validateWorkspaceMap = (map, filePath) => {
-  if (!map || typeof map !== "object" || Array.isArray(map)) {
-    throw new Error(
-      `[memoraone-mcp] Invalid workspace map schema in ${filePath}`
-    );
+function normalizeWorkspaceSearchRoots(workspaceRoot) {
+  if (workspaceRoot === void 0) {
+    return [];
   }
-  for (const [fingerprint, entry] of Object.entries(map)) {
-    if (!fingerprintRegex.test(fingerprint)) {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace fingerprint in ${filePath}`
-      );
-    }
-    if (typeof entry === "string") {
-      if (!entry.trim()) {
-        throw new Error(
-          `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
-        );
-      }
+  const list = Array.isArray(workspaceRoot) ? workspaceRoot : [workspaceRoot];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of list) {
+    if (raw === void 0) {
       continue;
     }
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
-      );
-    }
-    const projectKey = entry.projectKey ?? entry.project_id;
-    if (!projectKey || !projectKey.trim()) {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
-      );
-    }
-    const source = entry.source;
-    if (source !== void 0 && typeof source !== "string") {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace source in ${filePath}`
-      );
-    }
-    const linkedAt = entry.linked_at;
-    if (linkedAt !== void 0 && typeof linkedAt !== "string") {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace linked_at in ${filePath}`
-      );
-    }
-  }
-};
-async function readWorkspaceMap() {
-  const filePath = getWorkspaceMapPath();
-  try {
-    const content = await fs3.readFile(filePath, "utf8");
-    const parsed2 = JSON.parse(content);
-    validateWorkspaceMap(parsed2, filePath);
-    const typed = parsed2;
-    let migrated = false;
-    const normalized = {};
-    for (const [fingerprint, entry] of Object.entries(typed)) {
-      if (typeof entry === "string") {
-        normalized[fingerprint] = entry;
-        continue;
-      }
-      const projectKey = entry.projectKey ?? entry.project_id ?? "";
-      if (entry.project_id && !entry.projectKey) {
-        migrated = true;
-      }
-      normalized[fingerprint] = {
-        ...projectKey ? { projectKey } : {},
-        ...entry.source ? { source: entry.source } : {},
-        ...entry.linked_at ? { linked_at: entry.linked_at } : {}
-      };
-    }
-    if (migrated) {
-      await writeWorkspaceMap(normalized);
-    }
-    debugLog2(
-      `workspace map loaded path=${filePath} entries=${Object.keys(normalized).length}`
-    );
-    return normalized;
-  } catch (err) {
-    if (err?.code === "ENOENT") {
-      const emptyMap = {};
-      debugLog2(`workspace map loaded path=${filePath} entries=0`);
-      return emptyMap;
-    }
-    if (err instanceof SyntaxError) {
-      throw new Error(
-        `[memoraone-mcp] Failed to parse workspace map at ${filePath}`
-      );
-    }
-    throw err;
-  }
-}
-async function writeWorkspaceMap(map) {
-  const filePath = getWorkspaceMapPath();
-  validateWorkspaceMap(map, filePath);
-  await ensureWorkspaceDir();
-  const tempPath = `${filePath}.tmp`;
-  const content = JSON.stringify(map, null, 2);
-  await fs3.writeFile(tempPath, content, "utf8");
-  await fs3.rename(tempPath, filePath);
-}
-async function getProjectIdForFingerprint(fingerprint) {
-  if (!fingerprintRegex.test(fingerprint)) {
-    throw new Error("[memoraone-mcp] Invalid fingerprint");
-  }
-  const map = await readWorkspaceMap();
-  const entry = map[fingerprint];
-  if (!entry) {
-    return { projectKey: null, source: "unknown" };
-  }
-  if (typeof entry === "string") {
-    return { projectKey: entry, source: "unknown" };
-  }
-  return {
-    projectKey: entry.projectKey ?? entry.project_id ?? null,
-    source: entry.source ?? "unknown"
-  };
-}
-async function setProjectIdForFingerprint(args2) {
-  const { fingerprint, projectKey, source, linked_at } = args2;
-  if (!fingerprintRegex.test(fingerprint)) {
-    throw new Error("[memoraone-mcp] Invalid fingerprint");
-  }
-  if (!projectKey.trim()) {
-    throw new Error("[memoraone-mcp] Invalid projectKey");
-  }
-  const map = await readWorkspaceMap();
-  map[fingerprint] = {
-    projectKey,
-    ...source ? { source } : {},
-    linked_at: linked_at ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await writeWorkspaceMap(map);
-  debugLog2(
-    `workspace map set fingerprint=${fingerprint} projectKey=${projectKey}`
-  );
-}
-
-// src/projectBinding.ts
-var fs4 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
-function readRepoProjectIdPath(gitRoot) {
-  return path4.join(gitRoot, ".memoraone-project");
-}
-async function readRepoProjectId(gitRoot) {
-  const filePath = readRepoProjectIdPath(gitRoot);
-  try {
-    const content = await fs4.readFile(filePath, "utf8");
-    const value = content.trim();
-    return value ? value : null;
-  } catch (err) {
-    if (err?.code === "ENOENT") {
-      return null;
-    }
-    throw err;
-  }
-}
-function resolveProjectIdOrThrow(args2) {
-  const envProjectKey = args2.envProjectKey?.trim();
-  if (envProjectKey) {
-    return { projectKey: envProjectKey, source: "env" };
-  }
-  const repoFileProjectKey = args2.repoFileProjectKey?.trim();
-  if (repoFileProjectKey) {
-    return { projectKey: repoFileProjectKey, source: "repo-file" };
-  }
-  const workspaceProjectKey = args2.workspaceProjectKey?.trim();
-  if (workspaceProjectKey) {
-    return { projectKey: workspaceProjectKey, source: "workspace-map" };
-  }
-  throw new Error(
-    `Repo not linked to a MemoraOne project. Set MEMORAONE_PROJECT_ID or create ${args2.repoFilePath} containing a project key.`
-  );
-}
-
-// src/tools/postEvent.ts
-var import_v42 = require("zod/v4");
-var postEventShape = {
-  kind: import_v42.z.string().min(1),
-  actor: import_v42.z.object({
-    identifier: import_v42.z.string().min(1),
-    id: import_v42.z.string().min(1).optional()
-  }),
-  content: import_v42.z.record(import_v42.z.string(), import_v42.z.any()),
-  metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional()
-};
-
-// src/tools/askWithMemory.ts
-var import_v43 = require("zod/v4");
-var askWithMemoryShape = {
-  question: import_v43.z.string().min(1),
-  code_context: import_v43.z.object({
-    file_path: import_v43.z.string().optional(),
-    selected_text: import_v43.z.string().optional(),
-    language: import_v43.z.string().optional()
-  }).optional()
-};
-
-// src/tools/logIntent.ts
-var import_v44 = require("zod/v4");
-var logIntentShape = {
-  intent: import_v44.z.enum(["task", "decision"]),
-  message: import_v44.z.string().min(1),
-  context: import_v44.z.record(import_v44.z.string(), import_v44.z.any()).optional(),
-  intent_source: import_v44.z.string().optional().default("cursor_chat"),
-  run_id: import_v44.z.string().min(1).optional()
-};
-
-// src/tools/logChangeSummary.ts
-var import_v45 = require("zod/v4");
-var logChangeSummaryShape = {
-  summary: import_v45.z.string().min(1),
-  scope: import_v45.z.string().min(1).optional(),
-  files: import_v45.z.array(import_v45.z.string().min(1)).optional(),
-  stats: import_v45.z.object({
-    files: import_v45.z.number().int().nonnegative().optional(),
-    add: import_v45.z.number().int().nonnegative().optional(),
-    del: import_v45.z.number().int().nonnegative().optional()
-  }).optional(),
-  commit: import_v45.z.string().min(1).optional(),
-  run_id: import_v45.z.string().min(1).optional()
-};
-
-// src/tools/logToolResult.ts
-var import_v46 = require("zod/v4");
-var logToolResultShape = {
-  tool: import_v46.z.string().min(1),
-  status: import_v46.z.enum(["ok", "error", "partial"]),
-  summary: import_v46.z.string().min(1),
-  run_id: import_v46.z.string().min(1).optional(),
-  duration_ms: import_v46.z.number().int().nonnegative().optional(),
-  error_code: import_v46.z.string().min(1).optional(),
-  error_message: import_v46.z.string().min(1).optional(),
-  error_kind: import_v46.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
-  stats: import_v46.z.record(import_v46.z.string(), import_v46.z.any()).optional()
-};
-
-// src/tools/logCommand.ts
-var import_v47 = require("zod/v4");
-var logCommandShape = {
-  cmd: import_v47.z.string().min(1),
-  summary: import_v47.z.string().min(1),
-  cwd: import_v47.z.string().min(1).optional(),
-  exit_code: import_v47.z.number().int().optional(),
-  duration_ms: import_v47.z.number().int().nonnegative().optional(),
-  run_id: import_v47.z.string().min(1).optional(),
-  stats: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional()
-};
-
-// src/tools/listProjects.ts
-var listProjectsShape = {};
-
-// src/tools/setProject.ts
-var import_v48 = require("zod/v4");
-var setProjectShape = {
-  projectKey: import_v48.z.string().min(1).optional(),
-  projectId: import_v48.z.string().min(1).optional()
-};
-
-// src/tools/handlers/postEvent.ts
-var import_v49 = require("zod/v4");
-var crypto4 = __toESM(require("crypto"), 1);
-var postEventInputSchema = import_v49.z.object({
-  kind: import_v49.z.string().min(1),
-  actor: import_v49.z.object({
-    identifier: import_v49.z.string().min(1),
-    id: import_v49.z.string().min(1).optional()
-  }),
-  content: import_v49.z.record(import_v49.z.string(), import_v49.z.any()),
-  metadata: import_v49.z.record(import_v49.z.string(), import_v49.z.any()).optional()
-});
-async function handlePostEvent(client, args2) {
-  const nonce = crypto4.randomBytes(8).toString("hex");
-  console.error(
-    `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=before_post`
-  );
-  const parsed2 = postEventInputSchema.parse(args2 ?? {});
-  const projectKey = getCurrentProjectId();
-  if (!projectKey) {
-    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
-  }
-  const content = parsed2.content ?? {};
-  const message = typeof content.message === "string" ? content.message : typeof content.text === "string" ? content.text : JSON.stringify(content);
-  const body = {
-    kind: parsed2.kind,
-    message,
-    projectKey,
-    actor: {
-      type: "agent",
-      identifier: config.agentName,
-      ...parsed2.actor.id ? { id: parsed2.actor.id } : {}
-    },
-    ...parsed2.metadata ? { metadata: parsed2.metadata } : {}
-  };
-  try {
-    await client.post("/timeline/events", body);
-    console.error(
-      `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=after_post`
-    );
-  } catch (err) {
-    if (err instanceof MemoraOneHttpError) {
-      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
-      throw new Error(
-        `memora_post_event failed: ${err.status} ${err.message} ${bodyText}`.trim()
-      );
-    }
-    throw err;
-  }
-  return { ok: true, forwarded: true };
-}
-
-// src/tools/handlers/askWithMemory.ts
-var import_v410 = require("zod/v4");
-var askWithMemoryInputSchema = import_v410.z.object({
-  question: import_v410.z.string().min(1),
-  code_context: import_v410.z.object({
-    file_path: import_v410.z.string().optional(),
-    selected_text: import_v410.z.string().optional(),
-    language: import_v410.z.string().optional()
-  }).optional()
-});
-function isAskWithMemoryResponse(value) {
-  return typeof value === "object" && value !== null && typeof value.answer === "string" && value.answer !== "";
-}
-async function handleAskWithMemory(client, args2) {
-  const parsed2 = askWithMemoryInputSchema.parse(args2 ?? {});
-  const projectKey = getCurrentProjectId();
-  if (!projectKey) {
-    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
-  }
-  const payload = {
-    question: parsed2.question,
-    projectKey
-  };
-  if (parsed2.code_context) {
-    payload.code_context = parsed2.code_context;
-  }
-  const res = await client.post("/agent/ask-with-memory", payload);
-  if (!isAskWithMemoryResponse(res)) {
-    const err = new Error("Unexpected response from MemoraOne");
-    err.status = 502;
-    err.body = res;
-    throw err;
-  }
-  return {
-    answer: res.answer,
-    used: res.used ?? {}
-  };
-}
-
-// src/tools/handlers/logIntent.ts
-var import_v411 = require("zod/v4");
-var logIntentInputSchema = import_v411.z.object({
-  intent: import_v411.z.enum(["task", "decision"]),
-  message: import_v411.z.string().min(1),
-  context: import_v411.z.record(import_v411.z.string(), import_v411.z.any()).optional(),
-  intent_source: import_v411.z.string().optional().default("cursor_chat"),
-  run_id: import_v411.z.string().min(1).optional()
-});
-async function handleLogIntent(client, args2) {
-  const parsed2 = logIntentInputSchema.parse(args2 ?? {});
-  const projectKey = getCurrentProjectId();
-  if (!projectKey) {
-    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
-  }
-  const intent = parsed2.intent;
-  const message = parsed2.message.trim();
-  if (!message) {
-    throw new Error("message cannot be empty after trimming");
-  }
-  const intent_source = parsed2.intent_source ?? "cursor_chat";
-  const context = parsed2.context;
-  const purpose = intent;
-  const concept = purpose === "task" ? "concept:task" : "concept:decision";
-  const run_id = parsed2.run_id ?? generateRunId();
-  setCurrentRunId(run_id);
-  const body = {
-    kind: "note",
-    actor: { type: config.agentType, name: config.agentName },
-    concept,
-    // MUST be TOP-LEVEL so it populates timeline_events.concept
-    message,
-    projectKey,
-    metadata: {
-      source: config.source,
-      purpose,
-      // 'task' | 'decision'
-      intent_source: intent_source ?? "cursor_chat",
-      run_id,
-      ...context ? { context } : {}
-    }
-  };
-  await client.post("/timeline/events", body);
-  return { ok: true, run_id };
-}
-
-// src/tools/handlers/logChangeSummary.ts
-var import_v412 = require("zod/v4");
-var logChangeSummaryInputSchema = import_v412.z.object({
-  summary: import_v412.z.string().min(1),
-  scope: import_v412.z.string().min(1).optional(),
-  files: import_v412.z.array(import_v412.z.string().min(1)).optional(),
-  stats: import_v412.z.object({
-    files: import_v412.z.number().int().nonnegative().optional(),
-    add: import_v412.z.number().int().nonnegative().optional(),
-    del: import_v412.z.number().int().nonnegative().optional()
-  }).optional(),
-  commit: import_v412.z.string().min(1).optional(),
-  run_id: import_v412.z.string().min(1).optional()
-});
-async function handleLogChangeSummary(client, args2) {
-  const parsed2 = logChangeSummaryInputSchema.parse(args2 ?? {});
-  const projectKey = getCurrentProjectId();
-  if (!projectKey) {
-    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
-  }
-  const { summary, scope, files, stats, commit } = parsed2;
-  const message = summary.startsWith("CHANGE:") ? summary : `CHANGE: ${scope ?? "code"} \u2014 ${summary}`;
-  const run_id = resolveRunId(parsed2.run_id);
-  const body = {
-    kind: "note",
-    concept: "concept:change_summary",
-    actor: { type: config.agentType, name: config.agentName },
-    message,
-    projectKey,
-    metadata: {
-      source: config.source,
-      purpose: "change_summary",
-      tool: "memora_log_change_summary",
-      ...scope ? { scope } : {},
-      ...files ? { files } : {},
-      ...stats ? { stats } : {},
-      ...commit ? { commit } : {},
-      ...run_id ? { run_id } : {}
-    }
-  };
-  await client.post("/timeline/events", body);
-  return { ok: true };
-}
-
-// src/tools/handlers/logToolResult.ts
-var import_v413 = require("zod/v4");
-var logToolResultInputSchema = import_v413.z.object({
-  tool: import_v413.z.string().min(1),
-  status: import_v413.z.enum(["ok", "error", "partial"]),
-  summary: import_v413.z.string().min(1),
-  run_id: import_v413.z.string().min(1).optional(),
-  duration_ms: import_v413.z.number().int().nonnegative().optional(),
-  error_code: import_v413.z.string().min(1).optional(),
-  error_message: import_v413.z.string().min(1).optional(),
-  error_kind: import_v413.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
-  stats: import_v413.z.record(import_v413.z.string(), import_v413.z.any()).optional()
-});
-async function handleLogToolResult(client, args2) {
-  const parsed2 = logToolResultInputSchema.parse(args2 ?? {});
-  const projectKey = getCurrentProjectId();
-  if (!projectKey) {
-    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
-  }
-  const { tool, status, summary, duration_ms, error_code, error_message, error_kind, stats } = parsed2;
-  const message = summary.startsWith("RESULT:") ? summary : `RESULT: ${tool} \u2014 ${status} \u2014 ${summary}`;
-  const run_id = resolveRunId(parsed2.run_id);
-  const body = {
-    kind: "note",
-    concept: "concept:tool_result",
-    actor: { type: config.agentType, name: config.agentName },
-    message,
-    projectKey,
-    metadata: {
-      source: config.source,
-      purpose: "tool_result",
-      tool: "memora_log_tool_result",
-      tool_name: tool,
-      status,
-      ...run_id ? { run_id } : {},
-      ...duration_ms ? { duration_ms } : {},
-      ...error_code ? { error_code } : {},
-      ...error_message ? { error_message } : {},
-      ...error_kind ? { error_kind } : {},
-      ...stats ? { stats } : {}
+    const trimmed = String(raw).trim();
+    if (trimmed === "") {
+      continue;
     }
-  };
-  await client.post("/timeline/events", body);
-  return { ok: true };
-}
-
-// src/tools/handlers/logCommand.ts
-var import_v414 = require("zod/v4");
-var logCommandInputSchema = import_v414.z.object({
-  cmd: import_v414.z.string().min(1),
-  summary: import_v414.z.string().min(1),
-  cwd: import_v414.z.string().min(1).optional(),
-  exit_code: import_v414.z.number().int().optional(),
-  duration_ms: import_v414.z.number().int().nonnegative().optional(),
-  run_id: import_v414.z.string().min(1).optional(),
-  stats: import_v414.z.record(import_v414.z.string(), import_v414.z.any()).optional()
-});
-async function handleLogCommand(client, args2) {
-  const parsed2 = logCommandInputSchema.parse(args2 ?? {});
-  const projectKey = getCurrentProjectId();
-  if (!projectKey) {
-    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
-  }
-  const { cmd, summary, cwd: cwd2, exit_code, duration_ms, stats } = parsed2;
-  const message = summary.startsWith("COMMAND:") ? summary : `COMMAND: ${cmd} \u2014 ${summary}`;
-  const run_id = resolveRunId(parsed2.run_id);
-  const body = {
-    kind: "note",
-    concept: "concept:command",
-    actor: { type: config.agentType, name: config.agentName },
-    message,
-    projectKey,
-    metadata: {
-      source: config.source,
-      purpose: "command",
-      tool: "memora_log_command",
-      cmd,
-      ...cwd2 ? { cwd: cwd2 } : {},
-      ...exit_code !== void 0 ? { exit_code } : {},
-      ...duration_ms !== void 0 ? { duration_ms } : {},
-      ...run_id ? { run_id } : {},
-      ...stats ? { stats } : {}
+    const resolved = path2.resolve(trimmed);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      out.push(resolved);
     }
-  };
-  await client.post("/timeline/events", body);
-  return { ok: true };
-}
-
-// src/tools/handlers/listProjects.ts
-async function handleListProjects(client) {
-  const res = await client.get("/admin/projects");
-  return res ?? { items: [] };
-}
-
-// src/tools/handlers/setProject.ts
-var import_v415 = require("zod/v4");
-var setProjectInputSchema = import_v415.z.object({
-  projectKey: import_v415.z.string().min(1).optional(),
-  projectId: import_v415.z.string().min(1).optional()
-});
-async function handleSetProject(args2) {
-  const parsed2 = setProjectInputSchema.parse(args2 ?? {});
-  const resolvedProjectKey = parsed2.projectKey ?? parsed2.projectId;
-  if (!resolvedProjectKey) {
-    throw new Error("projectKey is required");
   }
-  setCurrentProjectId(resolvedProjectKey);
-  const repo = resolveRepoFingerprint(process.cwd());
-  await setProjectIdForFingerprint({
-    fingerprint: repo.fingerprint,
-    projectKey: resolvedProjectKey,
-    source: "manual"
-  });
-  return { ok: true, projectKey: resolvedProjectKey };
+  return out;
 }
-
-// src/index.ts
-async function sendHeartbeat(client) {
-  try {
-    await client.post("/admin/api-keys/heartbeat", {}, { log: false });
-  } catch (err) {
-    process.stderr.write(
-      `[memoraone-mcp][info] heartbeat error (silent) ${String(err)}
-`
-    );
+function resolveApiKeyWithSource(fileApiKey) {
+  const envApiKey = process.env.MEMORAONE_API_KEY?.trim();
+  if (envApiKey) {
+    return { apiKey: envApiKey, apiKeySource: "env" };
   }
-}
-function redactSensitiveFields(obj) {
-  if (obj === null || obj === void 0) return obj;
-  if (typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(redactSensitiveFields);
-  const redacted = {};
-  const sensitiveKeys = /^(headers?|api[_-]?key|token|cookie|authorization|auth|password|secret|credential|bearer)$/i;
-  for (const [key, value] of Object.entries(obj)) {
-    if (sensitiveKeys.test(key)) {
-      redacted[key] = "[REDACTED]";
-    } else if (typeof value === "object") {
-      redacted[key] = redactSensitiveFields(value);
-    } else {
-      redacted[key] = value;
-    }
+  const aliasEnvApiKey = process.env.MEMORA_API_KEY?.trim();
+  if (aliasEnvApiKey) {
+    return { apiKey: aliasEnvApiKey, apiKeySource: "env" };
   }
-  return redacted;
-}
-function sanitizeArgsSummary(args2) {
-  try {
-    const redacted = redactSensitiveFields(args2);
-    const summary = JSON.stringify(redacted);
-    return summary.length > 200 ? summary.slice(0, 200) + "..." : summary;
-  } catch {
-    return "[unable to serialize args]";
+  if (fileApiKey) {
+    return { apiKey: fileApiKey, apiKeySource: "memoraone.m1" };
   }
+  return { apiKey: null, apiKeySource: "none" };
 }
-async function postWorklogEvent(client, message) {
-  try {
-    const projectKey = getCurrentProjectId();
-    if (!projectKey) {
-      return;
-    }
-    const body = {
-      kind: "note",
-      concept: "concept:worklog",
-      actor: { type: config.agentType, name: config.agentName },
-      message,
-      projectKey,
-      metadata: {
-        source: config.source,
-        purpose: "worklog"
-      }
+async function resolveAuthoritativeBinding(workspaceRoot) {
+  const explicitBinding = await resolveProjectIdFromExplicitM1Path();
+  if (explicitBinding) {
+    const resolved = resolveApiKeyWithSource(explicitBinding.apiKey);
+    return {
+      projectId: explicitBinding.projectId,
+      workspaceRoot: path2.dirname(explicitBinding.foundAt),
+      m1Path: explicitBinding.foundAt,
+      apiKey: resolved.apiKey,
+      bindingSource: "explicit-m1-path",
+      apiKeySource: resolved.apiKeySource
     };
-    await client.post("/timeline/events", body);
-  } catch (err) {
-    console.error("[memoraone-mcp] worklog error (silent)", err);
   }
-}
-function registerToolWithWorklog(server, client, toolName, description, schema, handler) {
-  if (!config.worklogEnabled) {
-    server.tool(toolName, description, schema, handler);
-    return;
+  const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
+  if (candidates.length === 0) {
+    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
   }
-  server.tool(toolName, description, schema, async (args2) => {
-    const argsSummary = sanitizeArgsSummary(args2);
-    const start = Date.now();
-    await postWorklogEvent(client, `tool_start: ${toolName} ${argsSummary}`);
-    try {
-      const result = await handler(args2);
-      const durationMs = Date.now() - start;
-      await postWorklogEvent(client, `tool_end: ${toolName} ok (${durationMs}ms)`);
-      return result;
-    } catch (err) {
-      const durationMs = Date.now() - start;
-      const errorSummary = err?.message || String(err);
-      const shortError = errorSummary.length > 100 ? errorSummary.slice(0, 100) + "..." : errorSummary;
-      await postWorklogEvent(client, `tool_end: ${toolName} error (${durationMs}ms): ${shortError}`);
-      throw err;
-    }
-  });
-}
-async function main() {
-  const repo = resolveRepoFingerprint(process.cwd());
-  const envProjectKey = process.env.MEMORAONE_PROJECT_ID;
-  const repoFilePath = readRepoProjectIdPath(repo.gitRoot);
-  const repoFileProjectKey = await readRepoProjectId(repo.gitRoot);
-  const workspaceResolved = await getProjectIdForFingerprint(repo.fingerprint);
-  const binding = resolveProjectIdOrThrow({
-    envProjectKey,
-    repoFileProjectKey,
-    workspaceProjectKey: workspaceResolved.projectKey,
-    repoFilePath
-  });
-  const projectKey = binding.projectKey;
-  const source = binding.source;
-  setCurrentProjectId(projectKey);
-  const devMode = Boolean(config.devMode);
-  if (devMode) {
-    const remoteInfo = repo.remoteUrl ? ` remoteUrl=${repo.remoteUrl}` : "";
-    console.error(
-      `[memoraone-mcp][debug] repo fingerprint=${repo.fingerprint} projectKey=${projectKey} source=${source} gitRoot=${repo.gitRoot}${remoteInfo}`
-    );
-  }
-  const client = new memoraClient_default(config, projectKey);
-  console.error(
-    `[memoraone-mcp] Agent identity: name="${config.agentName}", type="${config.agentType}", source="${config.source}"`
-  );
-  const server = new import_mcp.McpServer({
-    name: "memoraone-mcp",
-    version: "1.0.0"
-  });
-  const registeredToolNames = [];
-  registeredToolNames.push("memora_post_event");
-  server.tool(
-    "memora_post_event",
-    "Forward an event to MemoraOne timeline",
-    postEventShape,
-    async (args2) => {
-      const result = await handlePostEvent(client, args2);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
-      };
-    }
-  );
-  registeredToolNames.push("memora_list_projects");
-  server.tool(
-    "memora_list_projects",
-    "List projects available to the current API key",
-    listProjectsShape,
-    async () => {
-      const result = await handleListProjects(client);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
-      };
-    }
-  );
-  registeredToolNames.push("memora_set_project");
-  server.tool(
-    "memora_set_project",
-    "Set the current project key for subsequent tool calls",
-    setProjectShape,
-    async (args2) => {
-      const result = await handleSetProject(args2);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
-      };
-    }
-  );
-  registeredToolNames.push("memora_ask_with_memory");
-  registerToolWithWorklog(
-    server,
-    client,
-    "memora_ask_with_memory",
-    "Ask MemoraOne with project memory context",
-    askWithMemoryShape,
-    async (args2) => {
-      const result = await handleAskWithMemory(client, args2);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
-      };
-    }
-  );
-  registeredToolNames.push("memora_log_intent");
-  registerToolWithWorklog(
-    server,
-    client,
-    "memora_log_intent",
-    "Log a natural-language TASK or DECISION intent to the MemoraOne timeline",
-    logIntentShape,
-    async (args2) => {
-      const result = await handleLogIntent(client, args2);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
-      };
-    }
-  );
-  registeredToolNames.push("memora_log_change_summary");
-  registerToolWithWorklog(
-    server,
-    client,
-    "memora_log_change_summary",
-    "Log a concise code change summary to the MemoraOne timeline",
-    logChangeSummaryShape,
-    async (args2) => {
-      const result = await handleLogChangeSummary(client, args2);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
-      };
-    }
-  );
-  registeredToolNames.push("memora_log_tool_result");
-  registerToolWithWorklog(
-    server,
-    client,
-    "memora_log_tool_result",
-    "Log a tool execution result to the MemoraOne timeline",
-    logToolResultShape,
-    async (args2) => {
-      const result = await handleLogToolResult(client, args2);
+  for (const root of candidates) {
+    const binding = await findM1WalkingUp(root);
+    if (binding) {
+      const resolved = resolveApiKeyWithSource(binding.apiKey);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        projectId: binding.projectId,
+        workspaceRoot: binding.repoRoot,
+        m1Path: binding.markerPath,
+        apiKey: resolved.apiKey,
+        bindingSource: "workspace-search",
+        apiKeySource: resolved.apiKeySource
       };
     }
-  );
-  registeredToolNames.push("memora_log_command");
-  registerToolWithWorklog(
-    server,
-    client,
-    "memora_log_command",
-    "Log a command execution to the MemoraOne timeline",
-    logCommandShape,
-    async (args2) => {
-      const result = await handleLogCommand(client, args2);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
-      };
-    }
-  );
-  if (devMode) {
-    console.error("[memoraone-mcp] Starting MCP server with", registeredToolNames.length, "tools");
-  }
-  const transport = new import_stdio.StdioServerTransport();
-  await server.connect(transport);
-  let heartbeatInterval = null;
-  if (config.heartbeatEnabled) {
-    if (globalThis.__memoraHeartbeatInterval) {
-      clearInterval(globalThis.__memoraHeartbeatInterval);
-    }
-    await sendHeartbeat(client);
-    const intervalMs = Number.isFinite(config.heartbeatIntervalMs) ? Math.max(1e3, config.heartbeatIntervalMs) : 3e4;
-    heartbeatInterval = setInterval(() => {
-      sendHeartbeat(client).catch(() => {
-      });
-    }, intervalMs);
-    globalThis.__memoraHeartbeatInterval = heartbeatInterval;
-  }
-  const shutdown = (signal) => {
-    if (heartbeatInterval) clearInterval(heartbeatInterval);
-    if (globalThis.__memoraHeartbeatInterval) {
-      clearInterval(globalThis.__memoraHeartbeatInterval);
-    }
-    if (devMode) {
-      console.error(`[memoraone-mcp] Received ${signal}, shutting down`);
-    }
-    process.exit(0);
-  };
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  if (devMode) {
-    console.error("[memoraone-mcp] MCP server ready");
   }
+  throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+}
+function encodeResolvedBinding(binding) {
+  return Buffer.from(JSON.stringify(binding), "utf8").toString("base64");
 }
-main().catch((err) => {
-  console.error("[memoraone-mcp] fatal error", err);
-  process.exit(1);
-});
 
 // src/cli.ts
 var { version } = require_package();
@@ -1314,6 +227,103 @@ if (args.includes("--version") || args.includes("-v")) {
   process.exit(0);
 }
 if (args.includes("--help") || args.includes("-h")) {
-  console.log("Usage: memoraone-mcp [--version] [--help]");
+  console.log("Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid>]");
   process.exit(0);
 }
+if (args.includes("--daemon")) {
+  import("./daemon.cjs").then(({ runDaemon }) => runDaemon()).catch((err) => {
+    process.stderr.write(`[memoraone-mcp] daemon fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
+} else {
+  let getWorkspaceRootCandidates = function() {
+    const raw = process.env.WORKSPACE_FOLDER_PATHS;
+    const parts = [];
+    if (raw !== void 0 && raw.trim() !== "") {
+      for (const p of raw.split(path3.delimiter).map((s) => s.trim()).filter(Boolean)) {
+        parts.push(path3.resolve(p));
+      }
+    }
+    parts.push(process.cwd());
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const p of parts) {
+      if (!seen.has(p)) {
+        seen.add(p);
+        deduped.push(p);
+      }
+    }
+    return deduped;
+  }, connectWithRetry = function(socketPath) {
+    return new Promise((resolve3, reject) => {
+      const tryConnect = (attempt) => {
+        const socket = net.connect(socketPath, () => {
+          resolve3(socket);
+        });
+        socket.on("error", (err) => {
+          if (attempt >= MAX_RETRIES) {
+            reject(err);
+            return;
+          }
+          log(`connect attempt ${attempt + 1} failed, retrying in ${RETRY_DELAY_MS}ms: ${String(err)}`);
+          setTimeout(() => tryConnect(attempt + 1), RETRY_DELAY_MS);
+        });
+      };
+      tryConnect(0);
+    });
+  };
+  const log = (msg) => {
+    process.stderr.write(`[memoraone-mcp][bridge] ${msg}
+`);
+  };
+  const MAX_RETRIES = 5;
+  const RETRY_DELAY_MS = 200;
+  async function resolveBinding() {
+    return resolveAuthoritativeBinding(getWorkspaceRootCandidates());
+  }
+  async function runBridge() {
+    ensureBaseDir();
+    const binding = await resolveBinding();
+    const socketPath = getSocketPath(binding.projectId);
+    log(
+      `authoritative binding project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}`
+    );
+    let socket;
+    try {
+      socket = await connectWithRetry(socketPath);
+    } catch {
+      log("daemon not running, spawning...");
+      const child = (0, import_node_child_process.spawn)(process.execPath, [process.argv[1], "--daemon", "--project-id", binding.projectId], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          MEMORAONE_DAEMON_BINDING_B64: encodeResolvedBinding(binding)
+        }
+      });
+      child.unref();
+      await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+      socket = await connectWithRetry(socketPath);
+    }
+    log("bridge connected");
+    log("forwarding active");
+    process.stdin.on("data", (chunk) => {
+      const text = chunk.toString("utf8");
+      const hasToolsCall = text.includes('"tools/call"') || text.includes("tools/call");
+      const hasInitialize = text.includes('"initialize"');
+      log(`[stdin-diagnostic] bytes=${chunk.length} tools/call=${hasToolsCall} initialize=${hasInitialize}`);
+    });
+    process.stdin.pipe(socket);
+    socket.pipe(process.stdout);
+    socket.on("close", () => process.exit(0));
+    socket.on("error", (err) => {
+      log(`socket error: ${String(err)}`);
+      process.exit(1);
+    });
+  }
+  runBridge().catch((err) => {
+    log(`fatal: ${String(err)}`);
+    process.exit(1);
+  });
+}