kojee-mcp 0.6.0 → 0.7.0

package/dist/{chunk-JXMVZEQ7.js → chunk-I67C2HYA.js}

@@ -2,7 +2,7 @@ import {
   generateES256KeyPair,
   loadKeystore,
   saveKeystore
-} from "./chunk-CH32ELFX.js";
+} from "./chunk-6G6YYST6.js";
 
 // src/auth/auth-module.ts
 import { calculateJwkThumbprint } from "jose";

package/dist/chunk-KNEJTD6G.js

@@ -0,0 +1,31 @@
+// src/runtime/cc-session-id.ts
+import { randomUUID } from "crypto";
+var SESSION_ID_ENV_VARS = ["CLAUDE_CODE_SESSION_ID"];
+function sanitizeKey(value) {
+  return value.replace(/[^A-Za-z0-9_-]/g, "");
+}
+function resolveInstanceKey(deps = {}) {
+  const env = deps.env ?? process.env;
+  for (const name of SESSION_ID_ENV_VARS) {
+    const sid = sanitizeKey((env[name] ?? "").trim());
+    if (sid) return sid;
+  }
+  const explicit = sanitizeKey((env.KOJEE_INSTANCE ?? "").trim());
+  if (explicit) return `inst-${explicit}`;
+  const mint = deps.randomUUID ?? randomUUID;
+  return `mint-${mint()}`;
+}
+function resolveSharedSessionId(deps = {}) {
+  const env = deps.env ?? process.env;
+  const fromEnv = sanitizeKey((env["CLAUDE_CODE_SESSION_ID"] ?? "").trim());
+  if (fromEnv) return fromEnv;
+  const fromStdin = sanitizeKey((deps.stdinSessionId ?? "").trim());
+  if (fromStdin) return fromStdin;
+  return null;
+}
+
+export {
+  SESSION_ID_ENV_VARS,
+  resolveInstanceKey,
+  resolveSharedSessionId
+};

package/dist/{chunk-NR4Y54OL.js → chunk-MIEI4PLB.js}

@@ -25,24 +25,6 @@ function computeAth(accessToken) {
   return base64url.encode(hash);
 }
 
-// src/tandem/session-id.ts
-import crypto2 from "crypto";
-import { ulid } from "ulidx";
-var MCP_SESSION_ID = ulid();
-function deriveStableSessionId(token, instanceKey) {
-  return crypto2.createHash("sha256").update(`${token}:${instanceKey}`).digest("hex").slice(0, 32);
-}
-var _stableSessionId = null;
-function setStableSessionId(id) {
-  _stableSessionId = id;
-}
-function getSessionId() {
-  return _stableSessionId ?? MCP_SESSION_ID;
-}
-
 export {
-  createDPoPProof,
-  deriveStableSessionId,
-  setStableSessionId,
-  getSessionId
+  createDPoPProof
 };

package/dist/chunk-NE2F5CKS.js

@@ -0,0 +1,113 @@
+// src/delivery/openclaw-wake.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_GATEWAY_PORT = 18789;
+var DEFAULT_HOOKS_PATH = "/hooks";
+function resolveOpenclawConfigPath(env = process.env) {
+  const explicit = (env["KOJEE_OPENCLAW_CONFIG"] ?? env["OPENCLAW_CONFIG_PATH"] ?? "").trim();
+  return explicit || path.join(os.homedir(), ".openclaw", "openclaw.json");
+}
+function parsePort(raw) {
+  const t = raw?.trim();
+  if (!t || !/^\d+$/.test(t)) return null;
+  const n = Number.parseInt(t, 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function resolveOpenclawWakeTarget(opts = {}) {
+  const env = opts.env ?? process.env;
+  const configPath = opts.configPath ?? resolveOpenclawConfigPath(env);
+  let raw = null;
+  try {
+    raw = fs.readFileSync(configPath, "utf8");
+  } catch {
+    raw = null;
+  }
+  return resolveWakeTargetFromRaw(raw, configPath, env);
+}
+function resolveWakeTargetFromRaw(raw, configPath, env) {
+  let cfg = {};
+  if (raw !== null) {
+    try {
+      const parsed = JSON.parse(raw);
+      cfg = parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      cfg = {};
+    }
+  }
+  const envUrl = (env["KOJEE_OPENCLAW_WAKE_URL"] ?? "").trim();
+  const envToken = (env["KOJEE_OPENCLAW_WAKE_TOKEN"] ?? "").trim();
+  const cfgToken = typeof cfg.hooks?.token === "string" ? cfg.hooks.token.trim() : "";
+  const token = envToken || cfgToken;
+  const hooksEnabled = cfg.hooks?.enabled === true;
+  let url = envUrl;
+  if (!url) {
+    const cfgPort = typeof cfg.gateway?.port === "number" && cfg.gateway.port > 0 ? cfg.gateway.port : DEFAULT_GATEWAY_PORT;
+    const port = parsePort(env["OPENCLAW_GATEWAY_PORT"]) ?? cfgPort;
+    const rawPath = typeof cfg.hooks?.path === "string" && cfg.hooks.path.trim() || DEFAULT_HOOKS_PATH;
+    const withSlash = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
+    const base = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+    url = `http://127.0.0.1:${port}${base}/wake`;
+  }
+  if (!token) {
+    return {
+      ok: false,
+      reason: `OpenClaw hooks token not found (KOJEE_OPENCLAW_WAKE_TOKEN or hooks.token in ${configPath}). Run \`kojee-mcp connect <code> --runtime openclaw\` to enable hooks.`
+    };
+  }
+  if (!hooksEnabled && !envToken && !envUrl) {
+    return {
+      ok: false,
+      reason: `OpenClaw hooks disabled (hooks.enabled != true in ${configPath}); /wake is not mounted.`
+    };
+  }
+  return { ok: true, target: { url, token } };
+}
+function createCachedOpenclawWakeResolver(opts = {}) {
+  let cache = null;
+  return async () => {
+    const env = opts.env ?? process.env;
+    const configPath = opts.configPath ?? resolveOpenclawConfigPath(env);
+    let mtimeMs = -1;
+    try {
+      mtimeMs = (await fs.promises.stat(configPath)).mtimeMs;
+    } catch {
+    }
+    if (cache && cache.mtimeMs === mtimeMs) return cache.resolution;
+    let raw = null;
+    if (mtimeMs !== -1) {
+      try {
+        raw = await fs.promises.readFile(configPath, "utf8");
+      } catch {
+        raw = null;
+      }
+    }
+    const resolution = resolveWakeTargetFromRaw(raw, configPath, env);
+    cache = { mtimeMs, resolution };
+    return resolution;
+  };
+}
+async function postOpenclawWake(target, body, deps = {}) {
+  const doFetch = deps.fetch ?? fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), deps.timeoutMs ?? 4e3);
+  try {
+    const res = await doFetch(target.url, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${target.token}` },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    return res.ok ? { ok: true, status: res.status } : { ok: false, status: res.status, error: `wake POST ${res.status}` };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export {
+  resolveOpenclawWakeTarget,
+  createCachedOpenclawWakeResolver,
+  postOpenclawWake
+};

package/dist/{chunk-N35X22G7.js → chunk-OB5T6P24.js}

@@ -1,6 +1,6 @@
 import {
   buildReplyRecipe
-} from "./chunk-Q7T3WAST.js";
+} from "./chunk-QEJUNP3X.js";
 
 // src/adapters/claude-code.ts
 function computeSeverity(event) {

package/dist/{chunk-65KRRDHP.js → chunk-OBIJ6WQP.js}

@@ -1,36 +1,72 @@
+import {
+  buildHookCommand,
+  isKojeeHookCommand,
+  npxHookCommand
+} from "./chunk-QJFMU4QC.js";
+import {
+  wrapNpxLauncher
+} from "./chunk-D6JKFJ6A.js";
 import {
   kojeeHomeDir
 } from "./chunk-SQL56SEB.js";
 import {
   secureFile
-} from "./chunk-BLEGIR35.js";
+} from "./chunk-U5HHHRXA.js";
 
 // src/wizard/codex-config.ts
 import fs from "fs";
+import os from "os";
 import path from "path";
+function win32DriveQualified(p, ...homeSegments) {
+  if (process.platform === "win32" && !/^[a-zA-Z]:/.test(p)) {
+    return path.win32.resolve(path.win32.join(os.homedir(), ...homeSegments));
+  }
+  return p;
+}
 function defaultCodexConfigPath() {
-  return path.join(kojeeHomeDir(), ".codex", "config.toml");
+  return win32DriveQualified(path.join(kojeeHomeDir(), ".codex", "config.toml"), ".codex", "config.toml");
 }
 function defaultCodexHooksPath() {
-  return path.join(kojeeHomeDir(), ".codex", "hooks.json");
+  return win32DriveQualified(path.join(kojeeHomeDir(), ".codex", "hooks.json"), ".codex", "hooks.json");
 }
-var CODEX_STOP_HOOK_COMMAND = "npx -y kojee-mcp hook --type=codex-stop";
-function codexArgsLiteral(token, url) {
+var CODEX_STOP_HOOK_COMMAND = npxHookCommand("codex-stop");
+function codexStopHookCommand() {
+  return buildHookCommand("codex-stop");
+}
+function codexRestArgs(token, url, pairedConfigPath) {
   if (token && url) {
-    return `["-y", "kojee-mcp", "--token", "${escapeTomlString(token)}", "--url", "${escapeTomlString(url)}"]`;
+    return ["-y", "kojee-mcp", "--token", token, "--url", url];
+  }
+  if (pairedConfigPath) {
+    return ["-y", "kojee-mcp", "--paired-config", pairedConfigPath];
   }
-  return '["-y", "kojee-mcp"]';
+  return ["-y", "kojee-mcp"];
+}
+function codexLauncherLiterals(token, url, pairedConfigPath) {
+  const rest = codexRestArgs(token, url, pairedConfigPath);
+  const { command, args } = wrapNpxLauncher("npx", rest);
+  return {
+    commandLiteral: `"${escapeTomlString(command)}"`,
+    argsLiteral: "[" + args.map((a) => `"${escapeTomlString(a)}"`).join(", ") + "]"
+  };
 }
 function buildCodexMcpServerTable(opts) {
+  const { commandLiteral, argsLiteral } = codexLauncherLiterals(
+    opts.token,
+    opts.url,
+    opts.pairedConfigPath
+  );
   return [
     "[mcp_servers.kojee]",
-    'command = "npx"',
-    `args = ${codexArgsLiteral(opts.token, opts.url)}`,
+    `command = ${commandLiteral}`,
+    `args = ${argsLiteral}`,
     "",
     "[mcp_servers.kojee.env]",
     'KOJEE_RUNTIME = "codex"',
-    `KOJEE_WEBHOOK_URL = "${escapeTomlString(opts.webhookUrl)}"`,
-    `KOJEE_WEBHOOK_SECRET = "${escapeTomlString(opts.webhookSecret)}"`,
+    // Webhook env is emitted ONLY when supplied (the credential-only `connect`
+    // path omits both → no placeholder URL, no fresh secret).
+    ...opts.webhookUrl !== void 0 ? [`KOJEE_WEBHOOK_URL = "${escapeTomlString(opts.webhookUrl)}"`] : [],
+    ...opts.webhookSecret !== void 0 ? [`KOJEE_WEBHOOK_SECRET = "${escapeTomlString(opts.webhookSecret)}"`] : [],
     // Signature emission overrides (0.5.3) — emitted only when configured.
     ...(opts.signatureEnv ?? []).map(([k, v]) => `${k} = "${escapeTomlString(v)}"`)
   ].join("\n");
@@ -40,7 +76,7 @@ function buildCodexStopHookBlock() {
     "[[hooks.Stop]]",
     "[[hooks.Stop.hooks]]",
     'type = "command"',
-    `command = "${escapeTomlString(CODEX_STOP_HOOK_COMMAND)}"`
+    `command = "${escapeTomlString(codexStopHookCommand())}"`
   ].join("\n");
 }
 function escapeTomlString(s) {
@@ -62,18 +98,30 @@ function writeCodexConfig(inputs) {
     inputs.webhookSecret,
     inputs.signatureEnv ?? [],
     inputs.token,
-    inputs.url
+    inputs.url,
+    inputs.pairedConfigPath
   );
   writeFile600(configPath, toml);
+  const command = codexStopHookCommand();
   const hooks = readJson(hooksPath);
   hooks.hooks ??= {};
   hooks.hooks.Stop ??= [];
-  const already = hooks.hooks.Stop.some(
-    (e) => e.hooks?.some((h) => h.command === CODEX_STOP_HOOK_COMMAND)
-  );
-  if (!already) {
+  let present = false;
+  for (const e of hooks.hooks.Stop) {
+    for (const h of e.hooks ?? []) {
+      if (h.command === command) {
+        present = true;
+      } else if (isKojeeHookCommand(h.command)) {
+        h.command = command;
+        present = true;
+      }
+      if (present) break;
+    }
+    if (present) break;
+  }
+  if (!present) {
     hooks.hooks.Stop.push({
-      hooks: [{ type: "command", command: CODEX_STOP_HOOK_COMMAND }]
+      hooks: [{ type: "command", command }]
     });
   }
   writeFile600(hooksPath, JSON.stringify(hooks, null, 2));
@@ -97,7 +145,8 @@ function removeCodexConfig(opts = {}) {
     if (stop && stop.length > 0) {
       const before = stop.length;
       hooks.hooks.Stop = stop.filter(
-        (e) => !e.hooks?.some((h) => h.command.startsWith("npx -y kojee-mcp hook"))
+        // F10: strip kojee entries in EITHER persisted form (npx or pinned).
+        (e) => !e.hooks?.some((h) => isKojeeHookCommand(h.command))
       );
       if (hooks.hooks.Stop.length !== before) {
         result.stopHook = true;
@@ -108,27 +157,33 @@ function removeCodexConfig(opts = {}) {
   }
   return result;
 }
-function upsertKojeeTomlTables(existing, webhookUrl, webhookSecret, signatureEnv = [], token, url) {
+function upsertKojeeTomlTables(existing, webhookUrl, webhookSecret, signatureEnv = [], token, url, pairedConfigPath) {
   const parsed = extractKojeeBlock(existing);
   if (!parsed) {
     const block = buildCodexMcpServerTable({
-      webhookUrl,
-      webhookSecret,
+      ...webhookUrl !== void 0 ? { webhookUrl } : {},
+      ...webhookSecret !== void 0 ? { webhookSecret } : {},
       ...signatureEnv.length > 0 ? { signatureEnv } : {},
       ...token ? { token } : {},
-      ...url ? { url } : {}
+      ...url ? { url } : {},
+      ...pairedConfigPath ? { pairedConfigPath } : {}
     });
     const base2 = existing.replace(/\s*$/, "");
     return base2.length === 0 ? block + "\n" : base2 + "\n\n" + block + "\n";
   }
+  const { commandLiteral, argsLiteral } = codexLauncherLiterals(token, url, pairedConfigPath);
   const tableKeys = upsertKeyLines(parsed.tableKeys, [
-    ["command", '"npx"'],
-    ["args", codexArgsLiteral(token, url)]
+    ["command", commandLiteral],
+    ["args", argsLiteral]
   ]);
   const envKeys = upsertKeyLines(parsed.envKeys, [
     ["KOJEE_RUNTIME", '"codex"'],
-    ["KOJEE_WEBHOOK_URL", `"${escapeTomlString(webhookUrl)}"`],
-    ["KOJEE_WEBHOOK_SECRET", `"${escapeTomlString(webhookSecret)}"`],
+    // Own KOJEE_WEBHOOK_URL/SECRET ONLY when supplied this run. The credential-
+    // only `connect` path passes neither → they drop out of the owned set and
+    // any existing operator/receiver values are PRESERVED verbatim (no clobber,
+    // no rotated secret, byte-stable re-runs).
+    ...webhookUrl !== void 0 ? [["KOJEE_WEBHOOK_URL", `"${escapeTomlString(webhookUrl)}"`]] : [],
+    ...webhookSecret !== void 0 ? [["KOJEE_WEBHOOK_SECRET", `"${escapeTomlString(webhookSecret)}"`]] : [],
     // Signature emission overrides (0.5.3) — owned only when configured this
     // run; an operator's existing signature lines are otherwise preserved.
     ...signatureEnv.map(([k, v]) => [k, `"${escapeTomlString(v)}"`])

package/dist/{chunk-Q7T3WAST.js → chunk-QEJUNP3X.js}

@@ -27,7 +27,8 @@ function buildWebhookReceiverNote(sig) {
 }
 var CODEX_LISTEN_CAP_MS = 8e3;
 function buildCodexWakeReason(cursor) {
-  return `[kojee] new Tandem event(s) pending (cursor=${cursor}). If relevant to your task, drain them now: call tandem_messages(tandem_id, since=${cursor - 1}) to read, then ` + buildReplyRecipe() + `. If you expect an imminent reply and want to wait for exactly one, call tandem_listen(tandem_id, since=${cursor}, timeout_ms<=${CODEX_LISTEN_CAP_MS}) \u2014 a BOUNDED wait, cap 8s, NEVER an unconditional long-poll. If not relevant, ignore.`;
+  const drainSince = Math.max(0, cursor - 1);
+  return `[kojee] new Tandem event(s) pending (cursor=${cursor}). If relevant to your task, drain them now: call tandem_messages(tandem_id, since=${drainSince}) to read, then ` + buildReplyRecipe() + `. If you expect an imminent reply and want to wait for exactly one, call tandem_listen(tandem_id, since=${cursor}, timeout_ms<=${CODEX_LISTEN_CAP_MS}) \u2014 a BOUNDED wait, cap 8s, NEVER an unconditional long-poll. If not relevant, ignore.`;
 }
 
 export {

package/dist/chunk-QJFMU4QC.js

@@ -0,0 +1,33 @@
+// src/hooks/hook-command.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function npxHookCommand(type) {
+  return `npx -y kojee-mcp hook --type=${type}`;
+}
+function resolveCliEntry(moduleUrl = import.meta.url) {
+  try {
+    const here = fileURLToPath(moduleUrl);
+    const candidate = path.join(path.dirname(here), "cli.js");
+    return fs.existsSync(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+function buildHookCommand(type, opts = {}) {
+  const cliEntry = opts.cliEntry !== void 0 ? opts.cliEntry : resolveCliEntry();
+  if (!cliEntry) return npxHookCommand(type);
+  const execPath = opts.execPath ?? process.execPath;
+  return `"${execPath}" "${cliEntry}" hook --type=${type}`;
+}
+var PINNED_HOOK_RE = /^"[^"]+" "[^"]+" hook --type=(stop|user-prompt-submit|codex-stop)$/;
+function isKojeeHookCommand(command) {
+  if (command.startsWith("npx -y kojee-mcp hook --type=")) return true;
+  return PINNED_HOOK_RE.test(command);
+}
+
+export {
+  npxHookCommand,
+  buildHookCommand,
+  isKojeeHookCommand
+};

package/dist/{chunk-EW72ZNQL.js → chunk-RDLF4NQC.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SQL56SEB.js";
 import {
   secureFile
-} from "./chunk-BLEGIR35.js";
+} from "./chunk-U5HHHRXA.js";
 
 // src/wizard/runtime-record.ts
 import fs from "fs";

package/dist/{chunk-ALZX3SGI.js → chunk-SGRVG4HW.js}

@@ -2,7 +2,7 @@ import {
   buildCatchUpNote,
   buildMonitorSpawn,
   buildReplyRecipe
-} from "./chunk-Q7T3WAST.js";
+} from "./chunk-QEJUNP3X.js";
 import {
   translateToolCallResult
 } from "./chunk-PPTKGWFF.js";
@@ -38,7 +38,11 @@ function resolveVersion() {
 var VERSION = resolveVersion();
 
 // src/server.ts
+function buildNonChannelInstructions() {
+  return "You are connected through the LOCAL kojee proxy. Do ALL Tandem operations (tandem_join/tandem_messages/tandem_send/tandem_set_wake_filter) through THESE tools \u2014 this is your ONLY wake-capable path: the proxy can only wake you for Tandem traffic that flows through it. If a REMOTE Kojee connector (e.g. a claude.ai-hosted 'Kojee' MCP) is ALSO available, do NOT use its Tandem tools \u2014 they cannot wake you.";
+}
 function buildChannelInstructions(_tandemMembershipCount, eventLogPath) {
+  const localProxyRule = "You are connected through the LOCAL kojee proxy. Do ALL Tandem operations (join/read/send/set_wake_filter) through THESE tools \u2014 this is your ONLY wake-capable path: it writes the wake log the Monitor and stop-hook read. If a REMOTE Kojee connector (e.g. a claude.ai-hosted 'Kojee' MCP) is ALSO available, do NOT use its Tandem tools \u2014 they cannot wake you.\n\n";
   const intro = `Tandem events are delivered to you in three ways depending on which is active in your Claude Code session:
 
 (1) If channel notifications are available, you'll see them as \`<channel source="kojee-mcp" ...>\` tags in your context. Each tag carries tandem_id, message_id, from_principal, kind, severity. To respond: ${buildReplyRecipe()}.
@@ -49,7 +53,7 @@ function buildChannelInstructions(_tandemMembershipCount, eventLogPath) {
 `;
   const listenSection = "(3) If you want to BLOCK until any single reply lands (rather than receive a stream of events), call tandem_listen(tandem_id, since=cursor, timeout_ms=N) instead.";
   const advice = "\n\nPrefer (2) at session start \u2014 it's the default no-allowlist wake mechanism. (1) supplements it when channels are enabled; (3) is for one-shot blocking waits.";
-  return intro + monitorSection + listenSection + advice;
+  return localProxyRule + intro + monitorSection + listenSection + advice;
 }
 function tandemIdArg(args) {
   return typeof args["tandem_id"] === "string" ? args["tandem_id"] : null;
@@ -75,7 +79,7 @@ function createMcpServer(registry, adapter, tandemMembershipCount = -1, eventLog
     { name: "kojee-mcp", version: VERSION },
     {
       capabilities,
-      ...adapter.supportsChannels ? { instructions: buildChannelInstructions(tandemMembershipCount, eventLogPath ?? "") } : {}
+      ...adapter.supportsChannels ? { instructions: buildChannelInstructions(tandemMembershipCount, eventLogPath ?? "") } : { instructions: buildNonChannelInstructions() }
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -101,6 +105,7 @@ async function startMcpServer(server) {
 
 export {
   VERSION,
+  buildNonChannelInstructions,
   buildChannelInstructions,
   executeToolCall,
   createMcpServer,

package/dist/{chunk-DURRQDYI.js → chunk-TNZITJAB.js}

@@ -1,9 +1,10 @@
 import {
+  readSessionDiscoveryByKey,
   sessionDiscoveryDir
-} from "./chunk-DO42NPNR.js";
+} from "./chunk-67F67AQ6.js";
 import {
   secureFile
-} from "./chunk-BLEGIR35.js";
+} from "./chunk-U5HHHRXA.js";
 
 // src/delivery/lib/event-log.ts
 import fs from "fs";
@@ -21,23 +22,35 @@ function statusLogPath(eventLogPath) {
   const m = base.match(/^kojee-events-(.+)\.log$/);
   return path.join(dir, m ? `kojee-status-${m[1]}.log` : `${base}.status`);
 }
-function livePathOwnedBySibling(candidatePath) {
+function livePathOwnedByForeignProxy(candidatePath, selfKey) {
   try {
-    const { livePaths } = listActiveSessionIds();
-    return livePaths.has(path.resolve(candidatePath));
+    const resolved = path.resolve(candidatePath);
+    const { liveOwners } = scanDiscovery(false);
+    for (const owner of liveOwners) {
+      if (owner.eventLogPath !== resolved) continue;
+      if (selfKey && owner.discoveryKey === selfKey) continue;
+      return true;
+    }
+    return false;
   } catch {
     return false;
   }
 }
+function resolveEventLogPath(opts) {
+  const dir = opts.dir ?? DEFAULT_DIR;
+  const base = path.join(dir, `kojee-events-${opts.key}.log`);
+  if (livePathOwnedByForeignProxy(base, opts.selfKey)) {
+    const suffix = opts.selfKey ?? String(process.pid);
+    return path.join(dir, `kojee-events-${opts.key}-${suffix}.log`);
+  }
+  return base;
+}
 function startEventLog(opts) {
   const dir = opts.dir ?? DEFAULT_DIR;
   const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
   const statusMaxBytes = opts.statusMaxBytes ?? DEFAULT_STATUS_MAX_BYTES;
   fs.mkdirSync(dir, { recursive: true });
-  let filePath = path.join(dir, `kojee-events-${opts.key}.log`);
-  if (livePathOwnedBySibling(filePath)) {
-    filePath = path.join(dir, `kojee-events-${opts.key}-${process.pid}.log`);
-  }
+  const filePath = resolveEventLogPath(opts);
   const statusPath = statusLogPath(filePath);
   fs.writeFileSync(filePath, "", { mode: 384 });
   secureFile(filePath);
@@ -114,6 +127,13 @@ function startEventLog(opts) {
       });
     },
     cleanup() {
+      if (opts.selfKey) {
+        const disc = readSessionDiscoveryByKey(opts.selfKey);
+        const owner = disc?.proxyPid ?? disc?.pid;
+        if (disc && typeof owner === "number" && owner !== process.pid && isProcessAlive(owner) && disc.eventLogPath && path.resolve(disc.eventLogPath) === path.resolve(filePath)) {
+          return;
+        }
+      }
       try {
         fs.unlinkSync(filePath);
       } catch {
@@ -175,19 +195,21 @@ function isProcessAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    if (err.code === "EPERM") return true;
+    const code = err.code;
+    if (code === "EPERM" || code === "EACCES") return true;
     return false;
   }
 }
-function listActiveSessionIds() {
+function scanDiscovery(reap) {
   const dir = sessionDiscoveryDir();
   const active = /* @__PURE__ */ new Set();
   const livePaths = /* @__PURE__ */ new Set();
+  const liveOwners = [];
   let entries;
   try {
     entries = fs.readdirSync(dir);
   } catch {
-    return { active, livePaths };
+    return { active, livePaths, liveOwners };
   }
   const dead = [];
   for (const name of entries) {
@@ -200,13 +222,20 @@ function listActiveSessionIds() {
       const livenessPid = data.proxyPid ?? data.pid;
       if (typeof livenessPid === "number" && isProcessAlive(livenessPid)) {
         active.add(sessionId);
-        if (data.eventLogPath) livePaths.add(path.resolve(data.eventLogPath));
+        if (data.eventLogPath) {
+          livePaths.add(path.resolve(data.eventLogPath));
+          liveOwners.push({
+            discoveryKey: data.discoveryKey ?? sessionId,
+            eventLogPath: path.resolve(data.eventLogPath)
+          });
+        }
       } else {
         dead.push({ filePath, eventLogPath: data.eventLogPath });
       }
     } catch {
     }
   }
+  if (!reap) return { active, livePaths, liveOwners };
   for (const { filePath, eventLogPath } of dead) {
     try {
       fs.unlinkSync(filePath);
@@ -216,14 +245,14 @@ function listActiveSessionIds() {
       reapEventLogSiblings(eventLogPath);
     }
   }
-  return { active, livePaths };
+  return { active, livePaths, liveOwners };
 }
 function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
   try {
     fs.unlinkSync(path.join(dir, "kojee-events-no-session.log"));
   } catch {
   }
-  const { active, livePaths } = listActiveSessionIds();
+  const { active, livePaths } = scanDiscovery(true);
   let entries;
   try {
     entries = fs.readdirSync(dir);
@@ -266,6 +295,7 @@ function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
 export {
   STATUS_LINE_PREFIX,
   statusLogPath,
+  resolveEventLogPath,
   startEventLog,
   monitorHeartbeatPath,
   nudgeSentinelPath,