kojee-mcp 0.5.19 → 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-XXFVWP6H.js → chunk-OB5T6P24.js}

@@ -1,6 +1,6 @@
 import {
   buildReplyRecipe
-} from "./chunk-X672ZN7V.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-DXJ6QLSJ.js → chunk-PKOBR7ZN.js}

@@ -1,6 +1,6 @@
 import {
   translateToolCallResult
-} from "./chunk-2OLXXOT3.js";
+} from "./chunk-PPTKGWFF.js";
 
 // src/tandem/send.ts
 var SEND_KINDS = ["message", "status"];

package/dist/{chunk-2OLXXOT3.js → chunk-PPTKGWFF.js}

@@ -33,7 +33,7 @@ function translateHttpError(status, errorCode, trigger) {
     }
     if (errorCode === "invalid_dpop_proof") {
       return makeError(
-        "Authentication failed. The proxy will attempt to re-enroll. If this persists, regenerate your gateway token."
+        "Authentication failed (DPoP key rejected). Restart the proxy so it re-enrolls its key. If this persists, regenerate your gateway token."
       );
     }
     if (errorCode === "key_enrollment_required") {
@@ -61,8 +61,71 @@ function translateHttpError(status, errorCode, trigger) {
   }
   return null;
 }
+function translateTandemNotActive(reason) {
+  switch (reason) {
+    // --- genuine inactive / reaped seat: re-joining is the right fix ---
+    case "not_a_member":
+    case "not_active_member":
+      return "You aren't an active member of that Tandem (the seat may have been reaped). Run tandem_join to reactivate it, then retry.";
+    // --- authentication: pairing problem, tandem_join won't help ---
+    case "unauthenticated":
+      return "Your proxy session isn't authenticated/paired with Kojee, so this call was rejected. Re-pair the proxy \u2014 tandem_join won't fix this.";
+    // --- existence / visibility ---
+    case "tandem_not_found":
+      return "That Tandem doesn't exist or isn't visible to you.";
+    // --- power / scope: you lack the required role ---
+    case "owner_only":
+      return "This action requires owner power in this Tandem, which you don't have.";
+    case "admin_only":
+      return "This action requires admin power in this Tandem, which you don't have.";
+    // --- capacity ---
+    case "member_cap_reached":
+      return "This Tandem is full (member cap reached); rejoining won't help \u2014 ask an admin to make room.";
+    // --- message-scoped ---
+    case "message_not_found":
+      return "That message doesn't exist in this Tandem (wrong id, or it was already redacted).";
+    case "redact_forbidden":
+      return "You can't redact that message \u2014 you're neither its author nor an admin of this Tandem.";
+    // --- targeting ---
+    case "target_principal_not_found":
+      return "The target principal isn't a member of this Tandem.";
+    // --- invitations ---
+    case "invitation_not_found":
+      return "That invitation doesn't exist, or it was already revoked or used.";
+    case "invite_required":
+      return "This Tandem requires an invite to join; ask an owner or admin to invite you.";
+    case "invite_invalid":
+      return "That invite token is invalid.";
+    case "invite_expired":
+      return "That invite has expired; request a fresh one.";
+    case "invite_exhausted":
+      return "That invite has no remaining uses; request a fresh one.";
+    case "invite_wrong_principal":
+      return "That invite was issued to a different principal and can't be used by you.";
+    // --- join requests / knocks ---
+    case "join_request_not_found":
+      return "That join request doesn't exist or was already decided.";
+    case "join_request_not_pending":
+      return "That join request was already decided (it's no longer pending).";
+    case "already_member":
+      return "You're already a member of that Tandem.";
+    case "already_requested":
+      return "You already have a pending join request for that Tandem.";
+    case "knock_required":
+      return "This Tandem requires a knock; request to join and wait for an admin to approve.";
+    case "knock_cooldown":
+      return "You're knocking too frequently; wait a bit before requesting to join again.";
+    // --- direct (1:1) Tandems ---
+    case "direct_tandem_immutable_membership":
+    case "direct_immutable":
+      return "This is a direct (1:1) Tandem; its membership can't be changed.";
+    // --- unknown token: surface the real reason verbatim, never the reaped string ---
+    default:
+      return reason ? `Tandem request refused: ${reason}.` : "Tandem request refused.";
+  }
+}
 var TANDEM_ERROR_MESSAGES = {
-  [-32001]: () => "You aren't an active member of that Tandem (the seat may have been reaped). Run tandem_join to reactivate it, then retry.",
+  [-32001]: (_data, message) => translateTandemNotActive((message ?? "").trim()),
   [-32003]: () => "This Tandem is hardened to owner-only membership; you can't join.",
   [-32004]: () => "You aren't a member of that Tandem. Use tandem_join(join_link) first.",
   [-32006]: (data) => {
@@ -91,7 +154,10 @@ function translateJsonRpcError(error) {
       content: [
         {
           type: "text",
-          text: tandemMessage(error.data)
+          text: tandemMessage(
+            error.data,
+            msg
+          )
         }
       ],
       isError: true

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

@@ -13,7 +13,7 @@ function buildReplyRecipe(event) {
   return `reply directly with tandem_send(tandem_id, ${SEND_BODY_PARAM}, reply_to=<msg>); fetch context only if needed via tandem_messages(tandem_id, since=cursor-1)`;
 }
 function buildCatchUpNote() {
-  return "If the event line `cursor=<n>` ever jumps (a gap) or the log resets (the proxy caps and truncates the messages log in place on overflow \u2014 a `status=rotated` line is recorded in the status sibling), you may have missed messages: catch up with tandem_messages(tandem_id, since=<last cursor you saw>).";
+  return "Cursors are allocated per-Tandem, and the event-log interleaves every subscribed room into one stream \u2014 so track the last `cursor=<n>` you saw keyed by the line's `tandem=<id>` field, and only treat a jump WITHIN the same tandem_id as a gap (a jump between lines from different rooms is normal interleaving, not a missed message). If the cursor jumps within one tandem, or the log resets (the proxy caps and truncates the messages log in place on overflow \u2014 a `status=rotated` line is recorded in the status sibling), you may have missed messages: catch up with tandem_messages(tandem_id, since=<last cursor you saw for THAT tandem>).";
 }
 function buildMonitorNudge(logPath) {
   return `[kojee] Tandem events are being logged but no Monitor is reading them \u2014 you may be missing wake notifications. Spawn the watcher once: ${buildMonitorSpawn(logPath)}. Then ${buildReplyRecipe()}.`;
@@ -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-XIDCYUTK.js → chunk-SGRVG4HW.js}

@@ -2,10 +2,10 @@ import {
   buildCatchUpNote,
   buildMonitorSpawn,
   buildReplyRecipe
-} from "./chunk-X672ZN7V.js";
+} from "./chunk-QEJUNP3X.js";
 import {
   translateToolCallResult
-} from "./chunk-2OLXXOT3.js";
+} from "./chunk-PPTKGWFF.js";
 
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.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,