kojee-mcp 0.5.19 → 0.7.0

package/dist/{wizard-Y3ULSO2C.js → chunk-GVWYW7MY.js}

@@ -1,19 +1,21 @@
 import {
-  clearRuntimeRecord,
-  readRecordedRuntime,
-  recordRuntime
-} from "./chunk-EW72ZNQL.js";
+  removeOpenclawMcpServer,
+  writeOpenclawMcpConfig
+} from "./chunk-E6WMFMM2.js";
 import {
   buildCodexMcpServerTable,
   buildCodexStopHookBlock,
   removeCodexConfig,
   writeCodexConfig
-} from "./chunk-65KRRDHP.js";
+} from "./chunk-OBIJ6WQP.js";
 import {
-  CHANNEL_ID,
-  removeOpenclawChannel,
-  writeOpenclawChannelConfig
-} from "./chunk-CLKCNV2A.js";
+  CONNECT_RUNTIMES
+} from "./chunk-EIH2LNF4.js";
+import {
+  clearRuntimeRecord,
+  readRecordedRuntime,
+  recordRuntime
+} from "./chunk-RDLF4NQC.js";
 import {
   kojeeHomeDir
 } from "./chunk-SQL56SEB.js";
@@ -26,17 +28,109 @@ import {
   resolveWebhookConfig
 } from "./chunk-V5VZPYMZ.js";
 import {
-  secureFile
-} from "./chunk-BLEGIR35.js";
+  loadPairedConfig,
+  pairedConfigPath,
+  perRuntimeConfigPath
+} from "./chunk-5SZHXYPK.js";
+import {
+  defaultPairedKeystorePath,
+  deriveKeystorePath
+} from "./chunk-6G6YYST6.js";
+import {
+  secureFile,
+  unlinkSyncRetry
+} from "./chunk-U5HHHRXA.js";
 import {
   CODEX_LISTEN_CAP_MS,
   buildWebhookReceiverNote
-} from "./chunk-X672ZN7V.js";
+} from "./chunk-QEJUNP3X.js";
+
+// src/wizard/pair-slot.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function absPerRuntimeConfigPath(runtime) {
+  const p = path.resolve(perRuntimeConfigPath(runtime));
+  if (process.platform === "win32" && !/^[a-zA-Z]:/.test(p)) {
+    return path.resolve(path.join(os.homedir(), ".kojee", "agents", runtime, "config.json"));
+  }
+  return p;
+}
+function reconcileConnectPairSlot(runtime, code) {
+  const messages = [];
+  for (const other of CONNECT_RUNTIMES) {
+    if (other === runtime) continue;
+    const sibling = loadPairedConfig(perRuntimeConfigPath(other));
+    if (sibling?.token === code) {
+      return {
+        ok: false,
+        output: `This pair code is already connected as ${other}; use a distinct per-agent code for ${runtime}. The dashboard mints one pair code per agent.`,
+        exitCode: 2
+      };
+    }
+  }
+  if (!CONNECT_RUNTIMES.includes(runtime)) {
+    return { ok: true, messages };
+  }
+  const legacy = loadPairedConfig(pairedConfigPath());
+  if (legacy && legacy.token === code) {
+    if (legacy.runtime === "hermes") {
+      return {
+        ok: false,
+        output: `This pair code backs the live hermes connection (${pairedConfigPath()}); retiring it would silently break the hermes daemon. Use a distinct per-agent code for ${runtime}. The dashboard mints one pair code per agent.`,
+        exitCode: 2
+      };
+    }
+    try {
+      unlinkSyncRetry(pairedConfigPath());
+    } catch (err) {
+      const e = err;
+      if (e.code !== "ENOENT") {
+        return {
+          ok: false,
+          output: `Aborted: could not retire the legacy global config at ${pairedConfigPath()} (${e.message}). Close any running kojee proxy and retry.`,
+          exitCode: 1
+        };
+      }
+    }
+    const legacyKeystore = defaultPairedKeystorePath();
+    const target = deriveKeystorePath(code);
+    try {
+      if (fs.existsSync(legacyKeystore) && !fs.existsSync(target)) {
+        fs.renameSync(legacyKeystore, target);
+      }
+    } catch {
+    }
+    messages.push("Migrated the legacy global slot into this per-runtime connection.");
+  }
+  return { ok: true, messages };
+}
+function pairSlotFor(runtime, code) {
+  if (CONNECT_RUNTIMES.includes(runtime)) {
+    const configPath = absPerRuntimeConfigPath(runtime);
+    return {
+      configPath,
+      keystorePath: deriveKeystorePath(code),
+      runtime,
+      allowOverwrite: true,
+      pairedConfigPath: configPath
+    };
+  }
+  return {
+    configPath: pairedConfigPath(),
+    keystorePath: defaultPairedKeystorePath(),
+    // F2: stamp the pairing runtime into the global PairedConfig so a later
+    // connect-runtime reconcile can recognize a live hermes slot and refuse to
+    // retire it (see reconcileConnectPairSlot).
+    runtime,
+    allowOverwrite: false
+  };
+}
 
 // src/wizard/wizard.ts
 import crypto2 from "crypto";
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 import { fileURLToPath } from "url";
 
 // src/wizard/registry.ts
@@ -53,15 +147,15 @@ function runtimeUsesWebhook(id) {
 
 // src/wizard/capabilities/webhook-secret.ts
 import crypto from "crypto";
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 function generateSecret() {
   return crypto.randomBytes(32).toString("hex");
 }
 function readSecretFromEnv(envPath) {
   let body;
   try {
-    body = fs.readFileSync(envPath, "utf8");
+    body = fs2.readFileSync(envPath, "utf8");
   } catch {
     return void 0;
   }
@@ -74,10 +168,10 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function upsertEnvFile(filePath, vars, opts = {}) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
   let lines = [];
   try {
-    lines = fs.readFileSync(filePath, "utf8").split("\n");
+    lines = fs2.readFileSync(filePath, "utf8").split("\n");
   } catch {
   }
   if (opts.header && !lines.some((l) => l === opts.header)) lines.unshift(opts.header);
@@ -89,7 +183,7 @@ function upsertEnvFile(filePath, vars, opts = {}) {
     if (idx >= 0) lines[idx] = line;
     else lines.push(line);
   }
-  fs.writeFileSync(filePath, lines.join("\n") + "\n", { mode: 384 });
+  fs2.writeFileSync(filePath, lines.join("\n") + "\n", { mode: 384 });
 }
 function writeWebhookSecretBothSides(opts) {
   const existing = opts.existingSecret ?? readSecretFromEnv(opts.daemonEnvPath) ?? readSecretFromEnv(opts.adapterEnvPath);
@@ -117,11 +211,11 @@ function writeWebhookSecretBothSides(opts) {
 }
 
 // src/wizard/installers/hermes.ts
-import path4 from "path";
+import path5 from "path";
 
 // src/wizard/plugin-payload.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var HERMES_PAYLOAD_FILES = [
   "__init__.py",
   "adapter.py",
@@ -129,24 +223,24 @@ var HERMES_PAYLOAD_FILES = [
   "plugin.yaml"
 ];
 function stagePluginPayload(opts) {
-  fs2.mkdirSync(opts.destDir, { recursive: true });
+  fs3.mkdirSync(opts.destDir, { recursive: true });
   const written = [];
   for (const file of opts.files) {
-    const src = path2.join(opts.srcDir, file);
-    if (!fs2.existsSync(src)) {
+    const src = path3.join(opts.srcDir, file);
+    if (!fs3.existsSync(src)) {
       throw new Error(
         `stagePluginPayload: missing payload file '${file}' in ${opts.srcDir}`
       );
     }
-    const dest = path2.join(opts.destDir, file);
-    fs2.copyFileSync(src, dest);
+    const dest = path3.join(opts.destDir, file);
+    fs3.copyFileSync(src, dest);
     written.push(dest);
   }
   return written;
 }
 function resolveBundledPayloadDir(runtime, baseDir) {
-  const dir = path2.join(baseDir, "plugins", runtime);
-  if (!fs2.existsSync(dir) || !fs2.statSync(dir).isDirectory()) {
+  const dir = path3.join(baseDir, "plugins", runtime);
+  if (!fs3.existsSync(dir) || !fs3.statSync(dir).isDirectory()) {
     throw new Error(
       `resolveBundledPayloadDir: no bundled payload for '${runtime}' at ${dir} \u2014 run the build (npm run build) so dist/plugins is staged.`
     );
@@ -154,10 +248,10 @@ function resolveBundledPayloadDir(runtime, baseDir) {
   return dir;
 }
 function missingPayloadFiles(runtime, baseDir, files) {
-  const dir = path2.join(baseDir, "plugins", runtime);
-  const dirOk = fs2.existsSync(dir) && fs2.statSync(dir).isDirectory();
+  const dir = path3.join(baseDir, "plugins", runtime);
+  const dirOk = fs3.existsSync(dir) && fs3.statSync(dir).isDirectory();
   if (!dirOk) return [...files];
-  return files.filter((f) => !fs2.existsSync(path2.join(dir, f)));
+  return files.filter((f) => !fs3.existsSync(path3.join(dir, f)));
 }
 function installBundledPayload(opts) {
   const srcDir = resolveBundledPayloadDir(opts.runtime, opts.baseDir);
@@ -165,8 +259,8 @@ function installBundledPayload(opts) {
 }
 
 // src/wizard/service.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function systemdUnit(spec) {
   return [
     "[Unit]",
@@ -213,7 +307,7 @@ function launchdPlist(spec, label) {
 }
 function planService(platform, spec) {
   if (platform === "linux") {
-    const unitPath = path3.join(
+    const unitPath = path4.join(
       spec.homeDir,
       ".config",
       "systemd",
@@ -230,7 +324,7 @@ function planService(platform, spec) {
   }
   if (platform === "darwin") {
     const label = darwinLabel(spec.serviceName);
-    const unitPath = path3.join(spec.homeDir, "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = path4.join(spec.homeDir, "Library", "LaunchAgents", `${label}.plist`);
     return {
       supported: true,
       unitPath,
@@ -250,23 +344,23 @@ function planService(platform, spec) {
 function writeService(platform, spec) {
   const plan = planService(platform, spec);
   if (plan.supported && plan.unitPath && plan.unitContent !== void 0) {
-    fs3.mkdirSync(path3.dirname(plan.unitPath), { recursive: true });
-    fs3.writeFileSync(plan.unitPath, plan.unitContent, { mode: 420 });
+    fs4.mkdirSync(path4.dirname(plan.unitPath), { recursive: true });
+    fs4.writeFileSync(plan.unitPath, plan.unitContent, { mode: 420 });
   }
   return plan;
 }
 
 // src/wizard/installers/hermes.ts
 function installHermes(inp) {
-  const daemonEnv = path4.join(inp.homeDir, ".kojee", "hermes.env");
-  const adapterEnv = path4.join(inp.homeDir, ".hermes", ".env");
-  const pluginDir = path4.join(inp.homeDir, ".hermes", "plugins", "kojee-tandem");
+  const daemonEnv = path5.join(inp.homeDir, ".kojee", "hermes.env");
+  const adapterEnv = path5.join(inp.homeDir, ".hermes", ".env");
+  const pluginDir = path5.join(inp.homeDir, ".hermes", "plugins", "kojee-tandem");
   if (!inp.skipPayload) {
     const missing = missingPayloadFiles("hermes", inp.payloadBaseDir, HERMES_PAYLOAD_FILES);
     if (missing.length > 0) {
       return {
         runtime: "hermes",
-        output: `hermes install ERROR: the bundled plugin payload is incomplete \u2014 missing ${missing.join(", ")} under ${path4.join(inp.payloadBaseDir, "plugins", "hermes")}. No changes were written. Run \`npm run build\` to stage dist/plugins/hermes, then retry.`,
+        output: `hermes install ERROR: the bundled plugin payload is incomplete \u2014 missing ${missing.join(", ")} under ${path5.join(inp.payloadBaseDir, "plugins", "hermes")}. No changes were written. Run \`npm run build\` to stage dist/plugins/hermes, then retry.`,
         exitCode: 2,
         secret: "",
         secretReused: false
@@ -325,66 +419,49 @@ function installHermes(inp) {
 
 // src/wizard/installers/openclaw.ts
 function installOpenclaw(inp) {
-  const gatewayUrl = inp.url ? inp.url.replace(/\/+$/, "") : void 0;
-  const block = {
-    enabled: true,
-    ...gatewayUrl ? { gatewayUrl } : {},
-    // Token-mode → credential lands here (config-first). Paired-mode → omitted.
-    ...inp.token ? { credential: inp.token } : {},
-    tandems: [],
-    selfPrincipals: [],
-    wake: { severities: [], mentionsOnly: false }
-  };
-  const stamp = (inp.now ? inp.now() : /* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-  const { backedUp } = writeOpenclawChannelConfig(inp.openclawConfigPath, block, { timestamp: stamp });
-  const installCmd = inp.pluginSourceDir ? `openclaw plugins install -l ${inp.pluginSourceDir}` : `openclaw plugins install npm:openclaw-channel-kojee-tandem  (available once published)`;
+  const r = writeOpenclawMcpConfig(inp.openclawConfigPath, {
+    ...inp.pairedConfigPath ? { pairedConfigPath: inp.pairedConfigPath } : {},
+    ...inp.now ? { now: inp.now } : {}
+  });
   const lines = [];
-  if (backedUp) {
+  if (r.backedUp) {
     lines.push(
-      `WARNING: ${inp.openclawConfigPath} was present but could not be parsed as JSON.`,
-      `         The original was backed up to ${backedUp} before writing the kojee-tandem block.`,
-      `         If it held other channels, recover them from that backup and re-merge by hand.`,
+      `WARNING: ${inp.openclawConfigPath} was present but unparseable; backed up to ${r.backedUp} before writing.`,
       ""
     );
   }
   lines.push(
-    "Configured runtime: openclaw (in-process channel plugin)",
-    "Wake mode: native OpenClaw channel \u2014 the plugin streams Tandem events while the gateway is up.",
-    `  channel config:  ${inp.openclawConfigPath} (channels.${CHANNEL_ID})`,
-    inp.token ? `  credential:      written into the channel block (owner-only perms; the plugin's config-first path)` : `  credential:      shared ~/.kojee/config.json (paired) \u2014 not duplicated into the channel block`,
+    "Configured runtime: openclaw (MCP server + /wake injector)",
+    "Wake mode: kojee-mcp runs as OpenClaw's MCP server; Tandem events POST to the local",
+    "           OpenClaw gateway /hooks/wake (Bearer hooks.token) \u2192 the agent wakes.",
+    `  mcp config:  ${inp.openclawConfigPath} (mcp.servers.kojee)`,
+    inp.pairedConfigPath ? `  credentials: per-runtime paired slot (${inp.pairedConfigPath})` : `  credentials: shared ~/.kojee/config.json (paired)`,
+    `  hooks token: ${r.hooksTokenGenerated ? "generated + hooks.enabled=true (new)" : "preserved existing"}`,
     "",
     "Next steps (openclaw):",
-    `  - Install the plugin via OpenClaw's own plugin manager:  ${installCmd}`,
-    "  - Reload the gateway to load the plugin:  openclaw gateway restart",
-    "  - Verify:  openclaw plugins inspect kojee-tandem  /  openclaw channels status"
+    "  - Run OpenClaw as its GATEWAY DAEMON (its default mode) \u2014 the /wake injector only",
+    "    wakes a running gateway. If the gateway is down, nudges are dropped until it restarts.",
+    "  - Restart the OpenClaw gateway to spawn the kojee MCP server: openclaw gateway restart",
+    "  - Verify: openclaw mcp list  (kojee should be listed)  /  kojee-mcp doctor"
   );
-  return {
-    runtime: "openclaw",
-    output: lines.join("\n"),
-    exitCode: 0,
-    configPath: inp.openclawConfigPath
-  };
+  return { runtime: "openclaw", output: lines.join("\n"), exitCode: 0, configPath: inp.openclawConfigPath };
 }
 function uninstallOpenclaw(inp) {
-  const removed = removeOpenclawChannel(inp.openclawConfigPath);
-  const lines = ["Uninstalling runtime: openclaw (in-process channel plugin)"];
-  lines.push(
-    removed ? `  removed channels.${CHANNEL_ID} from ${inp.openclawConfigPath} (sibling channels preserved)` : `  no channels.${CHANNEL_ID} block found in ${inp.openclawConfigPath} \u2014 nothing to remove`
-  );
-  lines.push("");
-  lines.push("Next steps (openclaw):");
-  lines.push("  - Remove the plugin via OpenClaw's own plugin manager:  openclaw plugins uninstall kojee-tandem");
-  lines.push("  - Reload the gateway:  openclaw gateway restart");
-  return {
-    runtime: "openclaw",
-    output: lines.join("\n"),
-    exitCode: 0,
-    configPath: inp.openclawConfigPath
-  };
+  const removed = removeOpenclawMcpServer(inp.openclawConfigPath);
+  const lines = [
+    "Uninstalling runtime: openclaw (MCP server + /wake injector)",
+    removed ? `  removed mcp.servers.kojee from ${inp.openclawConfigPath} (hooks + siblings preserved)` : `  no mcp.servers.kojee in ${inp.openclawConfigPath} \u2014 nothing to remove`,
+    "",
+    "Next steps (openclaw):",
+    "  - Restart the OpenClaw gateway: openclaw gateway restart",
+    "  - hooks.enabled/token were left intact (you may use hooks for other integrations)."
+  ];
+  return { runtime: "openclaw", output: lines.join("\n"), exitCode: 0, configPath: inp.openclawConfigPath };
 }
 
 // src/wizard/wizard.ts
 var DEFAULT_BROKER_URL = "https://rosie-staging.kojee.net";
+var HERMES_DEFAULT_WEBHOOK_URL = "http://127.0.0.1:8645/kojee-tandem";
 function generateWebhookSecret() {
   return crypto2.randomBytes(32).toString("hex");
 }
@@ -469,15 +546,25 @@ async function gatherGuidedInputs(runtime, opts) {
     } else {
       const code = opts.promptPairCode ? (await opts.promptPairCode()).trim() : "";
       if (!code) return { error: "No pair code entered. Re-run `kojee-mcp init` and enter a pair code, or choose token mode." };
-      const pair = opts.runPair ?? (async (a) => {
-        const { runPair } = await import("./pair-P4ILCMT7.js");
-        const { pairedConfigPath } = await import("./paired-config-JTFLHMZ2.js");
-        const { defaultPairedKeystorePath } = await import("./keystore-XLEV3FL5.js");
-        return runPair({ code: a.code, url: a.url, keystorePath: defaultPairedKeystorePath(), configPath: pairedConfigPath() });
+      const reconcile = reconcileConnectPairSlot(runtime, code);
+      if (!reconcile.ok) return { error: reconcile.output };
+      for (const m of reconcile.messages) preamble.push(m);
+      const slot = pairSlotFor(runtime, code);
+      const pair = opts.runPair ?? (async (o) => {
+        const { runPair } = await import("./pair-HTCVSMR6.js");
+        return runPair(o);
       });
       try {
-        const { message } = await pair({ code, url: brokerUrl });
+        const { message } = await pair({
+          code,
+          url: brokerUrl,
+          keystorePath: slot.keystorePath,
+          configPath: slot.configPath,
+          ...slot.runtime ? { runtime: slot.runtime } : {},
+          ...slot.allowOverwrite ? { allowOverwrite: true } : {}
+        });
         preamble.push(`Auth: pair mode \u2014 ${message}`);
+        if (slot.pairedConfigPath) next.pairedConfigPath = slot.pairedConfigPath;
       } catch (err) {
         return { error: `Pairing failed: ${err.message}` };
       }
@@ -524,6 +611,8 @@ function whatHappensNext(runtime, opts) {
   lines.push("  - Restart your runtime so it picks up the new kojee config.");
   if (opts.token) {
     lines.push("  - First boot enrolls this token's own keystore (~/.kojee/keypair-<hash>.json).");
+  } else if (opts.pairedConfigPath) {
+    lines.push(`  - The proxy uses your paired credentials (${opts.pairedConfigPath}).`);
   } else {
     lines.push("  - The proxy uses your paired credentials (~/.kojee/config.json + keypair.json).");
   }
@@ -531,13 +620,18 @@ function whatHappensNext(runtime, opts) {
   return lines.join("\n");
 }
 async function configureClaudeCode(opts) {
-  const { runInit } = await import("./install-LJY2CHKG.js");
+  const { runInit } = await import("./install-V7LSQCYZ.js");
   const report = runInit({
     ...opts.configPath ? { configPath: opts.configPath } : {},
     ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {},
     // Token mode threads --token/--url into the written args (per-token
     // keystore). Paired mode leaves both unset ⇒ args stay `["kojee-mcp"]`.
-    ...opts.token && opts.url ? { token: opts.token, url: opts.url } : {}
+    ...opts.token && opts.url ? { token: opts.token, url: opts.url } : {},
+    // Per-runtime paired mode (connect): embed --paired-config, overwrite a
+    // stale entry so a re-connect can never leave a launcher reading old creds,
+    // and ensureCli so a fresh box with no ~/.claude.json still gets the
+    // launcher WRITTEN (never a silent "not-found" that drops the wrong slot).
+    ...opts.pairedConfigPath ? { pairedConfigPath: opts.pairedConfigPath, overwrite: true, ensureCli: true } : {}
   });
   recordRuntime("claude-code");
   return { runtime: "claude-code", output: formatClaudeInit(report), exitCode: 0 };
@@ -546,6 +640,7 @@ function formatClaudeInit(report) {
   const tick = (s) => {
     if (s === "added") return "\u2713 added";
     if (s === "already-installed") return "\u21BB already installed";
+    if (s === "updated") return "\u21BB updated";
     if (s === "preserved-different") return "\u26A0 preserved (existing entry differs \u2014 left untouched)";
     if (s === "not-found") return "\u2014 not found";
     return s ?? "\u2014";
@@ -583,44 +678,60 @@ function configureCodex(opts) {
   if (wh.error) {
     return { runtime: "codex", output: `webhook env ERROR: ${wh.error}`, exitCode: 2 };
   }
-  const url = wh.url || "https://YOUR-CODEX-WEBHOOK-RECEIVER.local/kojee";
-  const secret = wh.secret || generateWebhookSecret();
+  const connectPairedMode = !!opts.pairedConfigPath && !wh.url && !wh.secret;
+  const hasRealUrl = !!wh.url;
+  const url = connectPairedMode || !hasRealUrl ? void 0 : wh.url;
+  const secret = connectPairedMode || !hasRealUrl ? void 0 : wh.secret || generateWebhookSecret();
   const tokenArgs = opts.token && opts.url ? { token: opts.token, url: opts.url } : {};
+  const pairedArgs = opts.pairedConfigPath ? { pairedConfigPath: opts.pairedConfigPath } : {};
   writeCodexConfig({
     ...opts.configPath ? { configPath: opts.configPath } : {},
     ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {},
-    webhookUrl: url,
-    webhookSecret: secret,
+    ...url !== void 0 ? { webhookUrl: url } : {},
+    ...secret !== void 0 ? { webhookSecret: secret } : {},
     ...wh.signatureEnv.length > 0 ? { signatureEnv: wh.signatureEnv } : {},
-    ...tokenArgs
+    ...tokenArgs,
+    ...pairedArgs
   });
   recordRuntime("codex");
   const lines = [];
   lines.push("Configured runtime: codex");
-  lines.push("Wake mode: webhook-sink + stop-hook peek (Codex has no channel injection).");
+  lines.push(
+    "Wake mode: self-contained (proxy-written pending marker) + stop-hook peek. Webhook OPTIONAL \u2014 an extra low-latency push path, never required."
+  );
   lines.push("");
   lines.push("Wrote [mcp_servers.kojee] to ~/.codex/config.toml:");
   lines.push(indent(buildCodexMcpServerTable({
-    webhookUrl: url,
-    webhookSecret: "<redacted>",
+    // In connectPairedMode the webhook env is left untouched — print neither key
+    // (they are preserved from the existing config, not owned this run).
+    ...url !== void 0 ? { webhookUrl: url } : {},
+    ...secret !== void 0 ? { webhookSecret: "<redacted>" } : {},
     ...wh.signatureEnv.length > 0 ? { signatureEnv: wh.signatureEnv } : {},
     // Redact the gateway token in the human-readable printed copy (it ends up
     // in result.output → cli.ts console.error). The WRITTEN config above keeps
     // the real token; only this printed report is redacted, like webhookSecret.
-    ...tokenArgs.token ? { token: "<redacted>", url: tokenArgs.url } : {}
+    ...tokenArgs.token ? { token: "<redacted>", url: tokenArgs.url } : {},
+    // A paired-config path is not a secret — print it verbatim.
+    ...pairedArgs
   })));
   if (wh.warning) lines.push(`webhook WARNING: ${wh.warning}`);
   lines.push("");
   lines.push("Wrote the Codex Stop hook (~/.codex/hooks.json; inline TOML form):");
   lines.push(indent(buildCodexStopHookBlock()));
   lines.push("");
-  lines.push(`webhook: ${wh.url ? wh.redactedSummary : "(receiver URL not set \u2014 fill KOJEE_WEBHOOK_URL above)"}`);
+  lines.push(
+    connectPairedMode ? "webhook: (unchanged \u2014 `connect` rewrites only the credential args, not the wake path)" : `webhook: ${wh.url ? wh.redactedSummary : "OPTIONAL \u2014 not configured (wake is self-contained; set KOJEE_WEBHOOK_URL only for an extra low-latency push path)"}`
+  );
   lines.push(`bounded-listen cap: ${CODEX_LISTEN_CAP_MS}ms (the model picks listen vs drain vs ignore).`);
   lines.push("");
   lines.push("Next steps (codex):");
   lines.push("  Restart Codex (or start a new `codex` / `codex exec` session) to load the MCP server and hook.");
-  lines.push("  Stand up your webhook receiver at KOJEE_WEBHOOK_URL \u2014 contract:");
-  lines.push(indent(buildWebhookReceiverNote({ header: wh.signatureHeader, prefix: wh.signaturePrefix })));
+  if (wh.url) {
+    lines.push("  Stand up your webhook receiver at KOJEE_WEBHOOK_URL \u2014 contract:");
+    lines.push(indent(buildWebhookReceiverNote({ header: wh.signatureHeader, prefix: wh.signaturePrefix })));
+  } else {
+    lines.push("  (Optional) For an extra low-latency push path, re-run with --webhook-url <receiver>; wake works without it.");
+  }
   lines.push("  Verify: kojee-mcp doctor");
   lines.push("");
   lines.push(CODEX_UNVERIFIED_NOTE);
@@ -649,7 +760,7 @@ function buildDaemonEnvBlock(runtime, wh, envFile) {
   return lines;
 }
 function distDir() {
-  return path5.dirname(fileURLToPath(import.meta.url));
+  return path6.dirname(fileURLToPath(import.meta.url));
 }
 function resolveBinPath() {
   const entry = process.argv[1];
@@ -657,14 +768,30 @@ function resolveBinPath() {
 }
 function configureHermes(opts) {
   const runtime = "hermes";
-  const wh = resolveWizardWebhook(opts);
+  const env0 = opts.env ?? process.env;
+  const suppliedUrl = (opts.webhookUrl ?? env0["KOJEE_WEBHOOK_URL"] ?? "").trim();
+  const effectiveOpts = suppliedUrl ? opts : { ...opts, webhookUrl: HERMES_DEFAULT_WEBHOOK_URL };
+  const wh = resolveWizardWebhook(effectiveOpts);
   if (wh.error) {
     return { runtime, output: `webhook env ERROR: ${wh.error}`, exitCode: 2 };
   }
+  opts = effectiveOpts;
   const lines = [];
   lines.push(`Configured runtime: ${runtime}`);
   lines.push("Wake mode: webhook sink (daemon-consumed). NO MCP-config file, NO hooks written.");
   lines.push("");
+  if (!suppliedUrl) {
+    lines.push(
+      "WARNING: no --webhook-url was supplied, so the webhook sink DEFAULTS to the fixed",
+      `loopback port ${HERMES_DEFAULT_WEBHOOK_URL} (the hermes-plugin listener). Every Tandem`,
+      "event body is POSTed there. On a multi-user host, another local user or process that",
+      "binds that port while the hermes plugin is down (before first start, or after a crash)",
+      "receives those event bodies plus valid signature/body pairs replayable against the real",
+      "receiver. If that risk applies to this host, re-run with an explicit --webhook-url",
+      "pointing at a receiver you control, and keep the hermes plugin running.",
+      ""
+    );
+  }
   if (wh.warning) lines.push(`webhook WARNING: ${wh.warning}`);
   if (wh.url) {
     const home = kojeeHomeDir();
@@ -694,7 +821,7 @@ function configureHermes(opts) {
       return { runtime, output: lines.join("\n"), exitCode: install.exitCode };
     }
     recordRuntime(runtime);
-    const envFile = path5.join(home, ".kojee", "hermes.env");
+    const envFile = path6.join(home, ".kojee", "hermes.env");
     lines.push(...buildDaemonEnvBlock(runtime, wh, envFile));
     lines.push("");
     lines.push(install.output);
@@ -710,30 +837,13 @@ function configureHermes(opts) {
   return { runtime, output: lines.join("\n"), exitCode: 0 };
 }
 function openclawConfigPath(opts) {
-  return opts.openclawConfigPath ?? path5.join(kojeeHomeDir(), ".openclaw", "config.json");
-}
-function resolveOpenclawPluginSourceDir() {
-  const candidates = [
-    path5.resolve(distDir(), "..", "..", "integrations", "openclaw-plugin"),
-    path5.resolve(distDir(), "..", "..", "..", "integrations", "openclaw-plugin")
-  ];
-  for (const dir of candidates) {
-    if (fs4.existsSync(path5.join(dir, "openclaw.plugin.json"))) return dir;
-  }
-  return void 0;
+  return opts.openclawConfigPath ?? path6.join(kojeeHomeDir(), ".openclaw", "openclaw.json");
 }
 function configureOpenclaw(opts) {
   const runtime = "openclaw";
-  const env = opts.env ?? process.env;
-  const token = (opts.token ?? "").trim();
-  const url = (opts.url ?? env["KOJEE_GATEWAY_URL"] ?? "").trim();
-  const pluginSourceDir = resolveOpenclawPluginSourceDir();
   const install = installOpenclaw({
-    homeDir: kojeeHomeDir(),
     openclawConfigPath: openclawConfigPath(opts),
-    ...url ? { url } : {},
-    ...token ? { token } : {},
-    ...pluginSourceDir ? { pluginSourceDir } : {}
+    ...opts.pairedConfigPath ? { pairedConfigPath: opts.pairedConfigPath } : {}
   });
   recordRuntime(runtime);
   return { runtime, output: install.output, exitCode: install.exitCode };
@@ -742,7 +852,7 @@ async function runWizardUninstall(runtime, opts) {
   const effective = opts.runtime !== void 0 ? runtime : readRecordedRuntime() ?? runtime;
   const lines = [`Uninstalling runtime: ${effective}`];
   if (effective === "claude-code") {
-    const { runUninstall } = await import("./install-LJY2CHKG.js");
+    const { runUninstall } = await import("./install-V7LSQCYZ.js");
     const report = runUninstall({
       ...opts.configPath ? { configPath: opts.configPath } : {},
       ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {}
@@ -771,9 +881,9 @@ async function runWizardUninstall(runtime, opts) {
   } else {
     lines.push("  (hermes writes no MCP-config or hooks \u2014 nothing to tear down.");
     lines.push("   Stop the daemon and unset KOJEE_WEBHOOK_URL/SECRET to disable the sink.)");
-    const envPath = path5.join(kojeeHomeDir(), ".kojee", `${effective}.env`);
+    const envPath = path6.join(kojeeHomeDir(), ".kojee", `${effective}.env`);
     try {
-      fs4.unlinkSync(envPath);
+      fs5.unlinkSync(envPath);
       lines.push(`  removed ${envPath}`);
     } catch {
     }
@@ -821,14 +931,13 @@ registerBuiltinInstaller(
 registerBuiltinInstaller(
   "openclaw",
   "OpenClaw",
-  ["pair-credential", "in-process-plugin"],
+  ["pair-credential", "mcp-config-write"],
   (o) => configureOpenclaw(o)
 );
+
 export {
-  CODEX_UNVERIFIED_NOTE,
+  reconcileConnectPairSlot,
+  pairSlotFor,
   DEFAULT_BROKER_URL,
-  generateWebhookSecret,
-  resolveRuntime,
-  resolveWizardWebhook,
   runWizard
 };