@memoraone/mcp 0.1.17 → 0.1.18

package/dist/daemon.cjs

@@ -0,0 +1,1923 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  runDaemon: () => runDaemon
+});
+module.exports = __toCommonJS(daemon_exports);
+var fs6 = __toESM(require("fs"), 1);
+var net = __toESM(require("net"), 1);
+var import_stdio2 = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/socketPaths.ts
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+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/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 parsed2;
+  try {
+    parsed2 = JSON.parse(content);
+  } catch {
+    throw new Error(`[memoraone-mcp] Invalid memoraone.m1 JSON at ${markerPath}`);
+  }
+  const projectId = parsed2?.projectId ?? parsed2?.project_id;
+  if (!projectId || typeof projectId !== "string") {
+    throw new Error(`[memoraone-mcp] memoraone.m1 missing projectId at ${markerPath}`);
+  }
+  if (!uuidRegex.test(projectId.trim())) {
+    throw new Error(`[memoraone-mcp] memoraone.m1 projectId is not a UUID at ${markerPath}`);
+  }
+  const apiKeyRaw = parsed2?.MEMORAONE_API_KEY ?? parsed2?.api_key;
+  const apiKey = apiKeyRaw !== void 0 && apiKeyRaw !== null && typeof apiKeyRaw === "string" && apiKeyRaw.trim() !== "" ? apiKeyRaw.trim() : null;
+  return { projectId: projectId.trim(), apiKey };
+}
+async function resolveProjectIdFromExplicitM1Path() {
+  const raw = process.env.MEMORAONE_M1_PATH;
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
+  }
+  const markerPath = path2.resolve(raw);
+  try {
+    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;
+    }
+    throw err;
+  }
+}
+async function findM1WalkingUp(workspaceRoot) {
+  let current = path2.resolve(workspaceRoot);
+  while (true) {
+    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);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+function normalizeWorkspaceSearchRoots(workspaceRoot) {
+  if (workspaceRoot === void 0) {
+    return [];
+  }
+  const list = Array.isArray(workspaceRoot) ? workspaceRoot : [workspaceRoot];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of list) {
+    if (raw === void 0) {
+      continue;
+    }
+    const trimmed = String(raw).trim();
+    if (trimmed === "") {
+      continue;
+    }
+    const resolved = path2.resolve(trimmed);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      out.push(resolved);
+    }
+  }
+  return out;
+}
+function resolveApiKeyWithSource(fileApiKey) {
+  const envApiKey = process.env.MEMORAONE_API_KEY?.trim();
+  if (envApiKey) {
+    return { apiKey: envApiKey, apiKeySource: "env" };
+  }
+  const aliasEnvApiKey = process.env.MEMORA_API_KEY?.trim();
+  if (aliasEnvApiKey) {
+    return { apiKey: aliasEnvApiKey, apiKeySource: "env" };
+  }
+  if (fileApiKey) {
+    return { apiKey: fileApiKey, apiKeySource: "memoraone.m1" };
+  }
+  return { apiKey: null, apiKeySource: "none" };
+}
+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
+    };
+  }
+  const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
+  if (candidates.length === 0) {
+    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  }
+  for (const root of candidates) {
+    const binding = await findM1WalkingUp(root);
+    if (binding) {
+      const resolved = resolveApiKeyWithSource(binding.apiKey);
+      return {
+        projectId: binding.projectId,
+        workspaceRoot: binding.repoRoot,
+        m1Path: binding.markerPath,
+        apiKey: resolved.apiKey,
+        bindingSource: "workspace-search",
+        apiKeySource: resolved.apiKeySource
+      };
+    }
+  }
+  throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+}
+function decodeResolvedBinding(value) {
+  if (!value) {
+    return null;
+  }
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(Buffer.from(value, "base64").toString("utf8"));
+  } catch {
+    throw new Error("[memoraone-mcp] Invalid encoded binding payload");
+  }
+  const projectId = parsed2?.projectId;
+  const workspaceRoot = parsed2?.workspaceRoot;
+  const m1Path = parsed2?.m1Path;
+  const apiKey = parsed2?.apiKey;
+  const bindingSource = parsed2?.bindingSource;
+  const apiKeySource = parsed2?.apiKeySource;
+  if (!projectId || typeof projectId !== "string" || !uuidRegex.test(projectId.trim())) {
+    throw new Error("[memoraone-mcp] Invalid binding projectId");
+  }
+  if (!workspaceRoot || typeof workspaceRoot !== "string") {
+    throw new Error("[memoraone-mcp] Invalid binding workspaceRoot");
+  }
+  if (!m1Path || typeof m1Path !== "string") {
+    throw new Error("[memoraone-mcp] Invalid binding m1Path");
+  }
+  if (apiKey !== null && apiKey !== void 0 && typeof apiKey !== "string") {
+    throw new Error("[memoraone-mcp] Invalid binding apiKey");
+  }
+  if (bindingSource !== "explicit-m1-path" && bindingSource !== "workspace-search") {
+    throw new Error("[memoraone-mcp] Invalid binding source");
+  }
+  if (apiKeySource !== "env" && apiKeySource !== "memoraone.m1" && apiKeySource !== "none") {
+    throw new Error("[memoraone-mcp] Invalid binding apiKeySource");
+  }
+  return {
+    projectId: projectId.trim(),
+    workspaceRoot,
+    m1Path,
+    apiKey: typeof apiKey === "string" && apiKey.trim() !== "" ? apiKey.trim() : null,
+    bindingSource,
+    apiKeySource
+  };
+}
+
+// src/index.ts
+var path7 = __toESM(require("path"), 1);
+var crypto5 = __toESM(require("crypto"), 1);
+var import_node_url2 = require("url");
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/config.ts
+var process2 = __toESM(require("process"), 1);
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var dotenv = __toESM(require("dotenv"), 1);
+var import_v4 = require("zod/v4");
+
+// src/configUtils.ts
+var DEFAULT_API_URL = "http://localhost:3001";
+var DEV_API_URL = "http://localhost:3001";
+function resolveApiUrl(env2) {
+  const explicitUrl = env2.MEMORAONE_API_URL?.trim();
+  if (explicitUrl) {
+    return explicitUrl;
+  }
+  const aliasUrl = env2.MEMORA_API_URL?.trim();
+  if (aliasUrl) {
+    return aliasUrl;
+  }
+  if (env2.MEMORAONE_DEV_MODE === "1") {
+    return DEV_API_URL;
+  }
+  return DEFAULT_API_URL;
+}
+
+// src/config.ts
+var dotenvPath = path3.resolve(process2.cwd(), ".env");
+if (fs3.existsSync(dotenvPath)) {
+  try {
+    dotenv.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).optional(),
+  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_IDE_TYPE: import_v4.z.enum(["cursor", "copilot-vscode", "jetbrains"]).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 = [];
+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;
+  }
+  return defaultValue;
+};
+var config2 = {
+  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",
+  ideType: parsed.data.MEMORAONE_IDE_TYPE,
+  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 crypto = __toESM(require("crypto"), 1);
+var PROJECT_ID_HEADER = "x-project-id";
+var uuidRegex2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var parseBooleanFlag2 = (value) => {
+  if (!value) {
+    return false;
+  }
+  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
+  };
+}
+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, projectId, apiKey) {
+    if (!uuidRegex2.test(projectId)) {
+      throw new Error("[memoraone-mcp] Invalid project_id for MemoraClient");
+    }
+    this.baseUrl = cfg.apiUrl;
+    this.apiKey = apiKey;
+    this.projectId = projectId;
+  }
+  resolveProjectId() {
+    const projectId = this.projectId?.trim();
+    if (!projectId) {
+      throw new Error(`Missing ${PROJECT_ID_HEADER}: select a project first`);
+    }
+    if (!uuidRegex2.test(projectId)) {
+      throw new Error("[memoraone-mcp] Invalid project_id for request");
+    }
+    return projectId;
+  }
+  resolveApiKey() {
+    const key = this.apiKey?.trim();
+    if (!key) {
+      throw new Error("[memoraone-mcp] Missing api_key for request");
+    }
+    return key;
+  }
+  buildHeaders(options) {
+    const projectId = this.resolveProjectId();
+    const apiKey = this.resolveApiKey();
+    return {
+      "content-type": "application/json",
+      "x-api-key": apiKey,
+      [PROJECT_ID_HEADER]: projectId,
+      ...options?.headers ?? {}
+    };
+  }
+  async post(path8, body, options) {
+    console.error(
+      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path8}`
+    );
+    const nonce = crypto.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path8.startsWith("/") ? path8 : `/${path8}`}`;
+    this.resolveProjectId();
+    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=${path8}`
+    );
+    return res.text ? JSON.parse(res.text) : null;
+  }
+  async get(path8, options) {
+    const nonce = crypto.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path8.startsWith("/") ? path8 : `/${path8}`}`;
+    this.resolveProjectId();
+    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/sourceRegistration.ts
+var path4 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+async function registerRepoSource(client, projectId, repoPath, ideType) {
+  const normalizedRepoPath = path4.resolve(repoPath);
+  const endpointPath = `/v1/projects/${projectId}/sources`;
+  console.error(
+    `[memoraone-mcp DEBUG registerRepoSource] registerRepoSource() called projectId=${projectId} repoPath(raw)=${JSON.stringify(repoPath)} repoPath(normalized)=${JSON.stringify(normalizedRepoPath)} ideType=${ideType ?? "(none)"}`
+  );
+  try {
+    const body = {
+      kind: "repo",
+      label: path4.basename(normalizedRepoPath),
+      uri: (0, import_node_url.pathToFileURL)(normalizedRepoPath).href
+    };
+    if (ideType) {
+      body.metadata = {
+        ide_type: ideType
+      };
+    }
+    console.error(
+      `[memoraone-mcp DEBUG registerRepoSource] POST endpoint=${endpointPath} body=${JSON.stringify(body)}`
+    );
+    const result = await client.post(endpointPath, body);
+    console.error(
+      `[memoraone-mcp DEBUG registerRepoSource] POST succeeded endpoint=${endpointPath} responseSummary=${JSON.stringify(result)}`
+    );
+  } catch (err) {
+    console.error(
+      `[memoraone-mcp DEBUG registerRepoSource] POST threw endpoint=${endpointPath} message=${String(err?.message ?? err)}`
+    );
+    if (err instanceof MemoraOneHttpError) {
+      const bodyStr = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? null);
+      console.error(
+        `[memoraone-mcp DEBUG registerRepoSource] MemoraOneHttpError status=${err.status} body=${bodyStr}`
+      );
+    }
+    console.warn("[memoraone-mcp] registerRepoSource failed:", err);
+  }
+}
+
+// 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 crypto3 = __toESM(require("crypto"), 1);
+
+// src/runContext.ts
+var import_node_async_hooks = require("async_hooks");
+var crypto2 = __toESM(require("crypto"), 1);
+var sessionContextStorage = new import_node_async_hooks.AsyncLocalStorage();
+function createSessionRunContext(initial = {}) {
+  return {
+    currentRunId: null,
+    currentProjectId: null,
+    currentApiKey: null,
+    boundProjectId: null,
+    boundApiKey: null,
+    ...initial
+  };
+}
+function runWithSessionContext(context, fn) {
+  return sessionContextStorage.run(context, fn);
+}
+function getSessionContext() {
+  const context = sessionContextStorage.getStore();
+  if (!context) {
+    throw new Error("[memoraone-mcp] Session context not initialized");
+  }
+  return context;
+}
+function getBoundProjectId() {
+  return getSessionContext().boundProjectId;
+}
+function setBoundProjectId(id) {
+  getSessionContext().boundProjectId = id;
+}
+function setBoundApiKey(key) {
+  getSessionContext().boundApiKey = key;
+}
+function getCurrentRunId() {
+  return getSessionContext().currentRunId;
+}
+function setCurrentRunId(id) {
+  getSessionContext().currentRunId = id;
+}
+function getCurrentProjectId() {
+  return getSessionContext().currentProjectId;
+}
+function setCurrentProjectId(id) {
+  getSessionContext().currentProjectId = id;
+}
+function setCurrentApiKey(key) {
+  getSessionContext().currentApiKey = key;
+}
+function resolveRunId(passed) {
+  if (passed) {
+    return passed;
+  }
+  return getCurrentRunId();
+}
+function generateRunId() {
+  return crypto2.randomBytes(16).toString("hex");
+}
+
+// src/tools/handlers/postEvent.ts
+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, args) {
+  const nonce = crypto3.randomBytes(8).toString("hex");
+  console.error(
+    `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=before_post`
+  );
+  const parsed2 = postEventInputSchema.parse(args ?? {});
+  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: config2.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, args) {
+  const parsed2 = askWithMemoryInputSchema.parse(args ?? {});
+  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, args) {
+  const parsed2 = logIntentInputSchema.parse(args ?? {});
+  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: config2.agentType, name: config2.agentName },
+    concept,
+    // MUST be TOP-LEVEL so it populates timeline_events.concept
+    message,
+    projectKey,
+    metadata: {
+      source: config2.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, args) {
+  const parsed2 = logChangeSummaryInputSchema.parse(args ?? {});
+  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: config2.agentType, name: config2.agentName },
+    message,
+    projectKey,
+    metadata: {
+      source: config2.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, args) {
+  const parsed2 = logToolResultInputSchema.parse(args ?? {});
+  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: config2.agentType, name: config2.agentName },
+    message,
+    projectKey,
+    metadata: {
+      source: config2.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 } : {}
+    }
+  };
+  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, args) {
+  const parsed2 = logCommandInputSchema.parse(args ?? {});
+  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: config2.agentType, name: config2.agentName },
+    message,
+    projectKey,
+    metadata: {
+      source: config2.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 } : {}
+    }
+  };
+  await client.post("/timeline/events", body);
+  return { ok: true };
+}
+
+// src/tools/handlers/listProjects.ts
+async function handleListProjects(client) {
+  const res = await client.get("/v1/projects");
+  return res ?? { items: [] };
+}
+
+// src/tools/handlers/setProject.ts
+var import_v415 = require("zod/v4");
+
+// src/repoFingerprint.ts
+var fs4 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var crypto4 = __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;
+  }
+  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 crypto4.createHash("sha256").update(value).digest("hex");
+};
+var resolveGitDir = (gitPath) => {
+  try {
+    const stat2 = fs4.statSync(gitPath);
+    if (stat2.isDirectory()) {
+      return gitPath;
+    }
+    if (stat2.isFile()) {
+      const content = fs4.readFileSync(gitPath, "utf8");
+      const match = content.match(/^gitdir:\s*(.+)$/m);
+      if (match) {
+        const gitDir = match[1].trim();
+        return path5.resolve(path5.dirname(gitPath), gitDir);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+var findGitRoot = (start) => {
+  let current = path5.resolve(start);
+  while (true) {
+    const gitPath = path5.join(current, ".git");
+    if (fs4.existsSync(gitPath)) {
+      const gitDir = resolveGitDir(gitPath);
+      if (gitDir) {
+        return { gitRoot: current, gitDir };
+      }
+    }
+    const parent = path5.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+};
+var readOriginRemote = (gitDir) => {
+  const configPath = path5.join(gitDir, "config");
+  try {
+    const content = fs4.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 = path5.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(path5.resolve(gitRoot));
+  debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
+  return {
+    fingerprint,
+    gitRoot,
+    source: "path-fallback"
+  };
+}
+
+// src/workspaceMap.ts
+var fs5 = __toESM(require("fs/promises"), 1);
+var path6 = __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 path6.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
+}
+var ensureWorkspaceDir = async () => {
+  const dir = path6.dirname(getWorkspaceMapPath());
+  await fs5.mkdir(dir, { recursive: true });
+};
+async function acquireWorkspaceMapLock() {
+  const filePath = getWorkspaceMapPath();
+  const lockPath = `${filePath}.lock`;
+  const maxRetries = 10;
+  const retryDelayMs = 50;
+  const maxLockAgeMs = 5e3;
+  let lockAcquired = false;
+  let retries = 0;
+  while (!lockAcquired && retries < maxRetries) {
+    try {
+      try {
+        const stat2 = await fs5.stat(lockPath);
+        const ageMs = Date.now() - stat2.mtimeMs;
+        if (ageMs > maxLockAgeMs) {
+          await fs5.unlink(lockPath);
+          debugLog2(`removed stale workspace map lock (age: ${ageMs}ms)`);
+        }
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      const fd = await fs5.open(lockPath, "wx");
+      await fd.close();
+      lockAcquired = true;
+    } catch (err) {
+      if (err?.code === "EEXIST") {
+        retries++;
+        if (retries < maxRetries) {
+          await new Promise((resolve6) => setTimeout(resolve6, retryDelayMs));
+          continue;
+        }
+        throw new Error(
+          `[memoraone-mcp] Failed to acquire workspace map lock after ${maxRetries} retries`
+        );
+      }
+      throw err;
+    }
+  }
+  return async () => {
+    try {
+      await fs5.unlink(lockPath);
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        debugLog2(`failed to release workspace map lock: ${String(err)}`);
+      }
+    }
+  };
+}
+var validateWorkspaceMap = (map, filePath) => {
+  if (!map || typeof map !== "object" || Array.isArray(map)) {
+    throw new Error(
+      `[memoraone-mcp] Invalid workspace map schema in ${filePath}`
+    );
+  }
+  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}`
+        );
+      }
+      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 fs5.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 } : {}
+      };
+    }
+    debugLog2(
+      `workspace map loaded path=${filePath} entries=${Object.keys(normalized).length}`
+    );
+    return { map: normalized, needsMigration: migrated };
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      const emptyMap = {};
+      debugLog2(`workspace map loaded path=${filePath} entries=0`);
+      return { map: emptyMap, needsMigration: false };
+    }
+    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 fs5.writeFile(tempPath, content, "utf8");
+  await fs5.rename(tempPath, filePath);
+}
+async function setProjectIdForFingerprint(args) {
+  const { fingerprint, projectKey, source, linked_at } = args;
+  if (!fingerprintRegex.test(fingerprint)) {
+    throw new Error("[memoraone-mcp] Invalid fingerprint");
+  }
+  if (!projectKey.trim()) {
+    throw new Error("[memoraone-mcp] Invalid projectKey");
+  }
+  const releaseLock = await acquireWorkspaceMapLock();
+  try {
+    const { map, needsMigration } = await readWorkspaceMap();
+    if (needsMigration) {
+      await writeWorkspaceMap(map);
+    }
+    map[fingerprint] = {
+      projectKey,
+      ...source ? { source } : {},
+      linked_at: linked_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeWorkspaceMap(map);
+    debugLog2(
+      `workspace map set fingerprint=${fingerprint} projectKey=${projectKey}`
+    );
+  } finally {
+    await releaseLock();
+  }
+}
+
+// src/tools/handlers/setProject.ts
+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(args) {
+  const parsed2 = setProjectInputSchema.parse(args ?? {});
+  const resolvedProjectKey = parsed2.projectKey ?? parsed2.projectId;
+  if (!resolvedProjectKey) {
+    throw new Error("projectKey is required");
+  }
+  const requested = resolvedProjectKey.trim();
+  const bound = getBoundProjectId();
+  if (bound !== null && requested !== bound) {
+    throw new Error(
+      `Project switching is disabled (Option A). This MCP process is bound to ${bound}. Start a separate MCP instance/window for ${requested}.`
+    );
+  }
+  setCurrentProjectId(resolvedProjectKey);
+  const repo = resolveRepoFingerprint(process.cwd());
+  await setProjectIdForFingerprint({
+    fingerprint: repo.fingerprint,
+    projectKey: resolvedProjectKey,
+    source: "manual"
+  });
+  return { ok: true, projectKey: resolvedProjectKey };
+}
+
+// src/index.ts
+var notInitializedResult = {
+  content: [
+    {
+      type: "text",
+      text: "MemoraOne MCP not initialized (project binding missing)."
+    }
+  ]
+};
+var initializeDiagDumped = false;
+var uriToPath = (uri) => {
+  if (uri.startsWith("file://")) {
+    return (0, import_node_url2.fileURLToPath)(uri);
+  }
+  return uri;
+};
+function getCursorWorkspaceRootFromEnv() {
+  const raw = process.env.WORKSPACE_FOLDER_PATHS;
+  if (raw === void 0 || raw.trim() === "") {
+    return void 0;
+  }
+  const parts = raw.split(path7.delimiter).map((p) => p.trim()).filter(Boolean);
+  const first = parts[0];
+  return first ? path7.resolve(first) : void 0;
+}
+function isHeartbeatDebugEnabled() {
+  const value = String(process.env.MEMORAONE_DEBUG_HEARTBEAT ?? "").trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(value);
+}
+function fingerprintApiKey(apiKey) {
+  return crypto5.createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
+}
+function inferIdeType(params) {
+  if (config2.ideType) {
+    return config2.ideType;
+  }
+  const clientInfoName = String(params?.clientInfo?.name ?? "").toLowerCase();
+  const clientInfoVersion = String(params?.clientInfo?.version ?? "").toLowerCase();
+  const termProgram = String(process.env.TERM_PROGRAM ?? "").toLowerCase();
+  const argv = process.argv.join(" ").toLowerCase();
+  const envKeys = Object.keys(process.env);
+  const hasCursorSignals = envKeys.some((key) => key.startsWith("CURSOR_")) || termProgram === "cursor" || clientInfoName.includes("cursor") || clientInfoVersion.includes("cursor") || argv.includes("cursor");
+  if (hasCursorSignals) {
+    return "cursor";
+  }
+  const hasJetBrainsSignals = envKeys.some(
+    (key) => [
+      "JETBRAINS_IDE",
+      "IDEA_INITIAL_DIRECTORY",
+      "JETBRAINS_REMOTE_RUN",
+      "INTELLIJ_ENVIRONMENT_READER"
+    ].includes(key)
+  ) || String(process.env.TERMINAL_EMULATOR ?? "").toLowerCase().includes("jetbrains") || /(jetbrains|intellij|pycharm|webstorm|goland|rubymine|clion|phpstorm|rider|datagrip)/.test(
+    clientInfoName
+  ) || /(jetbrains|intellij|pycharm|webstorm|goland|rubymine|clion|phpstorm|rider|datagrip)/.test(
+    argv
+  );
+  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);
+  if (hasVsCodeSignals) {
+    return "copilot-vscode";
+  }
+  return void 0;
+}
+async function sendHeartbeat(client, runtime) {
+  try {
+    const pid = runtime.projectId?.trim();
+    if (isHeartbeatDebugEnabled()) {
+      process.stderr.write(
+        `[memoraone-mcp][diag] heartbeat projectId=${pid ?? "unknown"} apiKeySource=${runtime.apiKeySource ?? "unknown"} apiKeyFingerprint=${runtime.apiKeyFingerprint ?? "unknown"}
+`
+      );
+    }
+    if (!pid) {
+      throw new Error("[memoraone-mcp] Cannot send heartbeat without an active project binding");
+    }
+    const body = {};
+    if (runtime.ideType) body.ide_type = runtime.ideType;
+    await client.post(`/v1/projects/${pid}/heartbeat`, body, {
+      log: false,
+      headers: {
+        "x-project-id": pid
+      }
+    });
+  } catch (err) {
+    process.stderr.write(
+      `[memoraone-mcp][info] heartbeat error (silent) ${String(err)}
+`
+    );
+  }
+}
+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;
+    }
+  }
+  return redacted;
+}
+function sanitizeArgsSummary(args) {
+  try {
+    const redacted = redactSensitiveFields(args);
+    const summary = JSON.stringify(redacted);
+    return summary.length > 200 ? summary.slice(0, 200) + "..." : summary;
+  } catch {
+    return "[unable to serialize args]";
+  }
+}
+async function postWorklogEvent(client, projectId, message) {
+  try {
+    if (!projectId) {
+      return;
+    }
+    const body = {
+      kind: "note",
+      concept: "concept:worklog",
+      actor: { type: config2.agentType, name: config2.agentName },
+      message,
+      projectKey: projectId,
+      metadata: {
+        source: config2.source,
+        purpose: "worklog"
+      }
+    };
+    await client.post("/timeline/events", body);
+  } catch (err) {
+    console.error("[memoraone-mcp] worklog error (silent)", err);
+  }
+}
+function registerToolWithWorklog(server, runtime, sessionContext, toolName, description, schema, handler) {
+  const wrapped = async (args) => runWithSessionContext(sessionContext, async () => {
+    if (!runtime.client || !runtime.projectId) return notInitializedResult;
+    if (!config2.worklogEnabled) {
+      return handler(args);
+    }
+    const argsSummary = sanitizeArgsSummary(args);
+    const start = Date.now();
+    await postWorklogEvent(runtime.client, runtime.projectId, `tool_start: ${toolName} ${argsSummary}`);
+    try {
+      const result = await handler(args);
+      const durationMs = Date.now() - start;
+      await postWorklogEvent(runtime.client, runtime.projectId, `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(
+        runtime.client,
+        runtime.projectId,
+        `tool_end: ${toolName} error (${durationMs}ms): ${shortError}`
+      );
+      throw err;
+    }
+  });
+  server.tool(toolName, description, schema, wrapped);
+}
+async function main(opts = {}) {
+  let bindingReadyResolve = null;
+  let bindingReadyReject = null;
+  const bindingReady = new Promise((resolve6, reject) => {
+    bindingReadyResolve = resolve6;
+    bindingReadyReject = reject;
+  });
+  const devMode = Boolean(config2.devMode);
+  const sessionLabel = opts.sessionLabel ?? "session";
+  const sessionContext = createSessionRunContext();
+  const runtime = {
+    client: null,
+    projectId: null,
+    apiKeySource: null,
+    apiKeyFingerprint: null,
+    ideType: void 0
+  };
+  let workspaceRoot;
+  const server = new import_mcp.McpServer({
+    name: "memoraone-mcp",
+    version: "1.0.0"
+  });
+  const resolveFallbackBindingFromInitialize = async (params) => {
+    let fallbackWorkspaceRoot = workspaceRoot;
+    try {
+      const rootsResult = await server.server.listRoots({});
+      const roots = Array.isArray(rootsResult?.roots) ? rootsResult.roots : [];
+      console.error(`[memoraone-mcp] roots/list returned ${roots.length}: ${JSON.stringify(roots)}`);
+      if (!fallbackWorkspaceRoot && roots.length > 0 && roots[0]?.uri) {
+        fallbackWorkspaceRoot = uriToPath(roots[0].uri);
+        console.error("[memoraone-mcp] Workspace resolution strategy: roots/list (first root)");
+      }
+    } catch (e) {
+      console.error("[memoraone-mcp] roots/list failed:", String(e));
+    }
+    console.error(`[memoraone-mcp] process.cwd(): ${process.cwd()}`);
+    console.error(
+      `[memoraone-mcp] WORKSPACE_FOLDER_PATHS: ${process.env.WORKSPACE_FOLDER_PATHS ?? "(unset)"}`
+    );
+    if (!fallbackWorkspaceRoot) {
+      if (params.workspaceFolders?.length) {
+        fallbackWorkspaceRoot = uriToPath(params.workspaceFolders[0].uri);
+        console.error("[memoraone-mcp] Workspace resolution strategy: initialize.workspaceFolders");
+      } else if (params.rootUri) {
+        fallbackWorkspaceRoot = uriToPath(params.rootUri);
+        console.error("[memoraone-mcp] Workspace resolution strategy: initialize.rootUri");
+      } else {
+        const cursorRoot = getCursorWorkspaceRootFromEnv();
+        if (cursorRoot !== void 0) {
+          fallbackWorkspaceRoot = cursorRoot;
+          console.error("[memoraone-mcp] Workspace resolution strategy: env.WORKSPACE_FOLDER_PATHS");
+        } else {
+          fallbackWorkspaceRoot = process.cwd();
+          console.error("[memoraone-mcp] Workspace resolution strategy: process.cwd() fallback");
+        }
+      }
+    }
+    const binding = await resolveAuthoritativeBinding(fallbackWorkspaceRoot);
+    workspaceRoot = binding.workspaceRoot;
+    return binding;
+  };
+  const registeredToolNames = [];
+  server.tool(
+    "memora_post_event",
+    "Forward an event to MemoraOne timeline",
+    postEventShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handlePostEvent(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_post_event");
+  server.tool(
+    "memora_list_projects",
+    "List projects available to the current API key",
+    listProjectsShape,
+    async () => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleListProjects(runtime.client);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_list_projects");
+  server.tool(
+    "memora_set_project",
+    "Set the current project key for subsequent tool calls",
+    setProjectShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleSetProject(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_set_project");
+  registerToolWithWorklog(
+    server,
+    runtime,
+    sessionContext,
+    "memora_ask_with_memory",
+    "Ask MemoraOne with project memory context",
+    askWithMemoryShape,
+    async (args) => {
+      const result = await handleAskWithMemory(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  registeredToolNames.push("memora_ask_with_memory");
+  registerToolWithWorklog(
+    server,
+    runtime,
+    sessionContext,
+    "memora_log_intent",
+    "Log a natural-language TASK or DECISION intent to the MemoraOne timeline",
+    logIntentShape,
+    async (args) => {
+      const result = await handleLogIntent(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_intent");
+  registerToolWithWorklog(
+    server,
+    runtime,
+    sessionContext,
+    "memora_log_change_summary",
+    "Log a concise code change summary to the MemoraOne timeline",
+    logChangeSummaryShape,
+    async (args) => {
+      const result = await handleLogChangeSummary(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_change_summary");
+  registerToolWithWorklog(
+    server,
+    runtime,
+    sessionContext,
+    "memora_log_tool_result",
+    "Log a tool execution result to the MemoraOne timeline",
+    logToolResultShape,
+    async (args) => {
+      const result = await handleLogToolResult(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_tool_result");
+  registerToolWithWorklog(
+    server,
+    runtime,
+    sessionContext,
+    "memora_log_command",
+    "Log a command execution to the MemoraOne timeline",
+    logCommandShape,
+    async (args) => {
+      const result = await handleLogCommand(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_command");
+  server.server.setRequestHandler(
+    import_types.InitializeRequestSchema,
+    async (request) => runWithSessionContext(sessionContext, async () => {
+      try {
+        const params = request.params;
+        runtime.ideType = inferIdeType(params);
+        if (!initializeDiagDumped) {
+          initializeDiagDumped = true;
+          const folders = Array.isArray(params.workspaceFolders) ? params.workspaceFolders.map((f) => ({ name: f?.name, uri: f?.uri })) : params.workspaceFolders;
+          const capKeys = params.capabilities && typeof params.capabilities === "object" ? Object.keys(params.capabilities) : [];
+          const cursorEnv = Object.keys(process.env).filter((k) => k.startsWith("CURSOR_")).reduce((acc, k) => {
+            acc[k] = process.env[k] ?? "";
+            return acc;
+          }, {});
+          const vscodeEnv = Object.keys(process.env).filter((k) => k.startsWith("VSCODE_")).reduce((acc, k) => {
+            acc[k] = process.env[k] ?? "";
+            return acc;
+          }, {});
+          console.error("[memoraone-mcp][diag] Initialize dump (once per process):");
+          console.error(`[memoraone-mcp][diag]   params.rootUri: ${JSON.stringify(params.rootUri)}`);
+          console.error(`[memoraone-mcp][diag]   params.workspaceFolders: ${JSON.stringify(folders)}`);
+          console.error(`[memoraone-mcp][diag]   params.clientInfo: ${JSON.stringify(params.clientInfo)}`);
+          console.error(`[memoraone-mcp][diag]   params.capabilities (keys): ${JSON.stringify(capKeys)}`);
+          console.error(`[memoraone-mcp][diag]   process.cwd(): ${process.cwd()}`);
+          console.error(`[memoraone-mcp][diag]   process.execPath: ${process.execPath}`);
+          console.error(`[memoraone-mcp][diag]   process.argv: ${JSON.stringify(process.argv)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.WORKSPACE_FOLDER_PATHS: ${JSON.stringify(process.env.WORKSPACE_FOLDER_PATHS)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.PWD: ${JSON.stringify(process.env.PWD)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.HOME: ${JSON.stringify(process.env.HOME)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.CURSOR_*: ${JSON.stringify(cursorEnv)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.VSCODE_*: ${JSON.stringify(vscodeEnv)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.TERM_PROGRAM: ${JSON.stringify(process.env.TERM_PROGRAM)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.MEMORAONE_M1_PATH: ${JSON.stringify(process.env.MEMORAONE_M1_PATH)}`);
+        }
+        const debugAuth = ["1", "true", "yes", "on"].includes(
+          String(process.env.MEMORAONE_DEBUG_AUTH ?? "").trim().toLowerCase()
+        );
+        const debugLog3 = config2.devMode || debugAuth;
+        const binding = opts.authoritativeBinding ? opts.authoritativeBinding : await resolveFallbackBindingFromInitialize(params);
+        const apiKeyToUse = binding.apiKey;
+        if (!apiKeyToUse) {
+          throw new Error(
+            "[memoraone-mcp] No actor key. Set MEMORAONE_API_KEY or MEMORA_API_KEY, or add MEMORAONE_API_KEY/api_key to memoraone.m1"
+          );
+        }
+        if (debugLog3) {
+          console.error(
+            "[memoraone-mcp][debug] Resolved actor key from " + (binding.apiKeySource === "env" ? "ENV" : "memoraone.m1")
+          );
+        }
+        const projectId = binding.projectId;
+        const existing = getBoundProjectId();
+        if (existing !== null && existing !== projectId) {
+          const requestedRoot = binding.workspaceRoot ?? workspaceRoot ?? process.cwd();
+          const action = "Open this repo in a separate window or configure a separate MCP server instance per root.";
+          const errMsg = `[memoraone-mcp] This MCP process is already bound to project ${existing}. Open a new IDE window or start a separate MCP instance for a different project.`;
+          console.error(
+            `[memoraone-mcp][ERROR] Option A conflict: boundProjectId=${existing} requestedProjectId=${projectId} workspaceRoot=${requestedRoot}. ${action}`
+          );
+          bindingReadyReject?.(new Error(errMsg));
+          setImmediate(() => process.exit(1));
+          throw new Error(errMsg);
+        }
+        if (existing === null) {
+          setBoundProjectId(projectId);
+          setBoundApiKey(apiKeyToUse);
+          console.error(
+            `[memoraone-mcp] ${sessionLabel} bound to project ${projectId} (Option A: single-project binding)`
+          );
+        }
+        setCurrentProjectId(projectId);
+        setCurrentApiKey(apiKeyToUse);
+        runtime.projectId = projectId;
+        runtime.apiKeySource = binding.apiKeySource;
+        runtime.apiKeyFingerprint = fingerprintApiKey(apiKeyToUse);
+        runtime.client = new memoraClient_default(config2, projectId, apiKeyToUse);
+        workspaceRoot = binding.workspaceRoot;
+        console.error(
+          `[memoraone-mcp DEBUG registerRepoSource] pre-register bindingSource=${binding.bindingSource} workspaceRoot=${JSON.stringify(binding.workspaceRoot)} m1Path=${JSON.stringify(binding.m1Path)} ideType=${runtime.ideType ?? "(none)"}`
+        );
+        await registerRepoSource(runtime.client, runtime.projectId, workspaceRoot, runtime.ideType);
+        if (debugAuth) {
+          console.error("[memoraone-mcp][auth] repo root:", binding.workspaceRoot);
+          console.error("[memoraone-mcp][auth] project_id:", projectId);
+          console.error("[memoraone-mcp][auth] api_key source:", binding.apiKeySource);
+        }
+        console.error(
+          `[memoraone-mcp] ${sessionLabel} authoritative binding: project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}`
+        );
+        bindingReadyResolve?.(runtime.client);
+        return server.server._oninitialize(request);
+      } catch (err) {
+        bindingReadyReject?.(err);
+        throw err;
+      }
+    })
+  );
+  if (devMode) {
+    console.error("[memoraone-mcp] Starting MCP server with", registeredToolNames.length, "tools");
+  }
+  const transport = opts.transport ?? new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  const activeClient = await bindingReady;
+  let heartbeatInterval = null;
+  if (config2.heartbeatEnabled) {
+    await sendHeartbeat(activeClient, runtime);
+    const intervalMs = Number.isFinite(config2.heartbeatIntervalMs) ? Math.max(1e3, config2.heartbeatIntervalMs) : 3e4;
+    console.error(
+      `[memoraone-mcp] ${sessionLabel} owns heartbeat for project ${runtime.projectId} interval=${intervalMs}ms`
+    );
+    heartbeatInterval = setInterval(() => {
+      sendHeartbeat(activeClient, runtime).catch(() => {
+      });
+    }, intervalMs);
+  }
+  const onSigInt = () => shutdown("SIGINT");
+  const onSigTerm = () => shutdown("SIGTERM");
+  const shutdown = (signal, exitProcess = true) => {
+    process.off("SIGINT", onSigInt);
+    process.off("SIGTERM", onSigTerm);
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
+    heartbeatInterval = null;
+    if (runtime.projectId) {
+      console.error(`[memoraone-mcp] ${sessionLabel} released heartbeat for project ${runtime.projectId}`);
+    }
+    if (devMode) {
+      console.error(`[memoraone-mcp] ${sessionLabel} received ${signal}, shutting down`);
+    }
+    if (exitProcess) {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", onSigInt);
+  process.on("SIGTERM", onSigTerm);
+  if (devMode) {
+    console.error("[memoraone-mcp] MCP server ready");
+  }
+  if (opts.sessionSocket) {
+    await new Promise((resolve6) => {
+      opts.sessionSocket.once("close", () => {
+        shutdown("session closed", false);
+        resolve6();
+      });
+    });
+  }
+}
+
+// src/daemon.ts
+var log = (msg) => {
+  process.stderr.write(`[memoraone-mcp][daemon] ${msg}
+`);
+};
+var IDLE_SHUTDOWN_MS = 5e3;
+function parseProjectIdFromArgv() {
+  const args = process.argv.slice(2);
+  const idx = args.indexOf("--project-id");
+  if (idx === -1 || idx + 1 >= args.length) {
+    log("--project-id <uuid> required");
+    process.exit(1);
+  }
+  return args[idx + 1];
+}
+function parseBindingFromEnv(projectId) {
+  const binding = decodeResolvedBinding(process.env.MEMORAONE_DAEMON_BINDING_B64);
+  if (!binding) {
+    log("missing MEMORAONE_DAEMON_BINDING_B64");
+    process.exit(1);
+  }
+  if (binding.projectId !== projectId) {
+    log(`binding project mismatch: argv=${projectId} payload=${binding.projectId}`);
+    process.exit(1);
+  }
+  return binding;
+}
+async function ensureSocketClean(socketPath) {
+  try {
+    fs6.accessSync(socketPath);
+  } catch {
+    return;
+  }
+  return new Promise((resolve6) => {
+    const client = net.createConnection({ path: socketPath }, () => {
+      client.destroy();
+      log("daemon already running, exiting");
+      process.exit(0);
+    });
+    client.on("error", () => {
+      try {
+        fs6.unlinkSync(socketPath);
+        log("stale socket removed");
+      } catch {
+      }
+      resolve6();
+    });
+  });
+}
+async function runDaemon() {
+  const projectId = parseProjectIdFromArgv();
+  const binding = parseBindingFromEnv(projectId);
+  const socketPath = getSocketPath(projectId);
+  let nextSessionId = 1;
+  let activeSessions = 0;
+  let idleTimer = null;
+  let shuttingDown = false;
+  const dir = ensureBaseDir();
+  log(`directory ensured: ${dir}`);
+  log(
+    `authoritative binding project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}`
+  );
+  log("session policy: concurrent bridge sessions allowed per project daemon");
+  await ensureSocketClean(socketPath);
+  const cleanupSocketFile = () => {
+    try {
+      if (fs6.existsSync(socketPath)) {
+        fs6.unlinkSync(socketPath);
+        log("socket removed");
+      }
+    } catch (err) {
+      log(`socket cleanup warning: ${String(err)}`);
+    }
+  };
+  const server = net.createServer(async (socket) => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+      log("idle shutdown cancelled due to new session");
+    }
+    const sessionId = nextSessionId++;
+    activeSessions += 1;
+    let released = false;
+    const releaseActiveSession = () => {
+      if (released) return;
+      released = true;
+      activeSessions = Math.max(0, activeSessions - 1);
+      log(`session=${sessionId} closed activeSessions=${activeSessions}`);
+      if (activeSessions === 0 && !shuttingDown) {
+        idleTimer = setTimeout(() => {
+          if (activeSessions !== 0 || shuttingDown) return;
+          shuttingDown = true;
+          log(`idle timeout reached (${IDLE_SHUTDOWN_MS}ms), shutting down daemon`);
+          server.close(() => {
+            cleanupSocketFile();
+            process.exit(0);
+          });
+        }, IDLE_SHUTDOWN_MS);
+        log(`scheduled idle shutdown in ${IDLE_SHUTDOWN_MS}ms`);
+      }
+    };
+    socket.once("close", releaseActiveSession);
+    socket.once("end", releaseActiveSession);
+    socket.once("error", () => releaseActiveSession);
+    log(`bridge connected session=${sessionId} activeSessions=${activeSessions}`);
+    const transport = new import_stdio2.StdioServerTransport(socket, socket);
+    try {
+      await main({
+        authoritativeBinding: binding,
+        transport,
+        sessionSocket: socket,
+        sessionLabel: `daemon-session-${sessionId}`
+      });
+    } catch (err) {
+      log(`session error: ${String(err)}`);
+      socket.destroy();
+    } finally {
+      releaseActiveSession();
+    }
+  });
+  server.on("error", (err) => {
+    log(`server error: ${String(err)}`);
+    cleanupSocketFile();
+    process.exit(1);
+  });
+  const shutdownNow = (reason) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    log(`daemon shutdown: ${reason}`);
+    server.close(() => {
+      cleanupSocketFile();
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", () => shutdownNow("SIGINT"));
+  process.on("SIGTERM", () => shutdownNow("SIGTERM"));
+  process.on("exit", cleanupSocketFile);
+  return new Promise((resolve6) => {
+    server.listen(socketPath, () => {
+      log(`daemon started, listening on ${socketPath}`);
+      resolve6();
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runDaemon
+});