kojee-mcp 0.7.5-staging.7 → 0.7.5-staging.9

package/dist/{chunk-RTYRJAJO.js → chunk-7DCZNZSP.js}

@@ -1,11 +1,12 @@
 import {
+  CODEX_TRUST_FIX_STEPS,
   buildCodexMcpServerTable,
   buildCodexPromptSubmitHookBlock,
   buildCodexStopHookBlock,
   isPlaceholderWebhookUrl,
   removeCodexConfig,
   writeCodexConfig
-} from "./chunk-T6QANUS2.js";
+} from "./chunk-7LKCTUBY.js";
 import {
   removeOpenclawMcpServer,
   writeOpenclawMcpConfig
@@ -16,10 +17,6 @@ import {
   removeHermesMcpServer,
   writeHermesMcpConfig
 } from "./chunk-GEGUWQYT.js";
-import {
-  WIZARD_RUNTIMES,
-  isWizardRuntime
-} from "./chunk-77HWBSRH.js";
 import {
   CONNECT_RUNTIMES
 } from "./chunk-EIH2LNF4.js";
@@ -28,6 +25,10 @@ import {
   readRecordedRuntime,
   recordRuntime
 } from "./chunk-RDLF4NQC.js";
+import {
+  WIZARD_RUNTIMES,
+  isWizardRuntime
+} from "./chunk-77HWBSRH.js";
 import {
   kojeeHomeDir
 } from "./chunk-SQL56SEB.js";
@@ -422,9 +423,18 @@ function installBundledPayload(opts) {
 // src/wizard/service.ts
 import fs5 from "fs";
 import path5 from "path";
+function shQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function wrapperEnvEntries(spec) {
+  const marker = spec.wrapperEnv ?? { KOJEE_WEBHOOK_EXPECTED: "1" };
+  return [["KOJEE_RUNTIME", spec.runtime], ...Object.entries(marker)];
+}
 function daemonSourceExecCommand(spec) {
   const target = spec.nodePath ? `${spec.nodePath} ${spec.binPath}` : spec.binPath;
-  return `set -a; . ${spec.envFile}; set +a; exec ${target}`;
+  const withArgs = spec.binArgs && spec.binArgs.length > 0 ? `${target} ${spec.binArgs.map(shQuote).join(" ")}` : target;
+  const source = spec.envFile ? `set -a; . ${spec.envFile}; set +a; ` : "";
+  return `${source}exec ${withArgs}`;
 }
 function xmlEscape(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -443,7 +453,7 @@ function systemdUnit(spec) {
     // otherwise kill the marker too. It lets startProxy tell the "webhook was
     // meant to be here" daemon apart from the tools-only child (which never sets
     // it) when the sourced URL is absent → null delivery.
-    `Environment=KOJEE_RUNTIME=${spec.runtime} KOJEE_WEBHOOK_EXPECTED=1`,
+    `Environment=${wrapperEnvEntries(spec).map(([k, v]) => `${k}=${v}`).join(" ")}`,
     // §2a: source the env file inside a shell wrapper (replaces EnvironmentFile=).
     `ExecStart=/bin/sh -c '${daemonSourceExecCommand(spec)}'`,
     "Restart=always",
@@ -478,7 +488,7 @@ function launchdPlist(spec, label) {
     "  </array>",
     // §2b: KOJEE_WEBHOOK_EXPECTED in the wrapper env (NOT the sourced file).
     "  <key>EnvironmentVariables</key>",
-    `  <dict><key>KOJEE_RUNTIME</key><string>${xmlEscape(spec.runtime)}</string><key>KOJEE_WEBHOOK_EXPECTED</key><string>1</string></dict>`,
+    `  <dict>${wrapperEnvEntries(spec).map(([k, v]) => `<key>${xmlEscape(k)}</key><string>${xmlEscape(v)}</string>`).join("")}</dict>`,
     "  <key>RunAtLoad</key><true/>",
     "  <key>KeepAlive</key><true/>",
     "</dict>",
@@ -530,6 +540,15 @@ function writeService(platform, spec) {
   }
   return plan;
 }
+function removeService(platform, spec) {
+  const plan = planService(platform, spec);
+  let removed = false;
+  if (plan.unitPath && fs5.existsSync(plan.unitPath)) {
+    fs5.unlinkSync(plan.unitPath);
+    removed = true;
+  }
+  return { removed, deactivateCmd: plan.deactivateCmd };
+}
 
 // src/wizard/installers/hermes.ts
 function installHermes(inp) {
@@ -617,6 +636,16 @@ function installOpenclaw(inp) {
     ...inp.pairedConfigPath ? { pairedConfigPath: inp.pairedConfigPath } : {},
     ...inp.now ? { now: inp.now } : {}
   });
+  const platform = inp.platform ?? process.platform;
+  const svc = !inp.skipService && inp.binPath && inp.homeDir ? writeService(platform, {
+    serviceName: "kojee-openclaw",
+    binPath: inp.binPath,
+    ...inp.nodePath ? { nodePath: inp.nodePath } : {},
+    runtime: "openclaw",
+    homeDir: inp.homeDir,
+    binArgs: ["--paired-config", inp.pairedConfigPath ?? perRuntimeConfigPath("openclaw")],
+    wrapperEnv: { KOJEE_HEADLESS: "1" }
+  }) : null;
   const lines = [];
   if (r.backedUp) {
     lines.push(
@@ -625,17 +654,22 @@ function installOpenclaw(inp) {
     );
   }
   lines.push(
-    "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)`,
+    "Configured runtime: openclaw (MCP server + standing /hooks/agent wake daemon)",
+    "Wake mode: the kojee-openclaw DAEMON holds the Tandem SSE stream and, on an @mention,",
+    "           POSTs the local OpenClaw gateway /hooks/agent (Bearer hooks.token) \u2192 a FULL",
+    "           agent run (kojee tools mounted) so the agent can reply via tandem_send.",
+    `  mcp config:  ${inp.openclawConfigPath} (mcp.servers.kojee \u2014 per-run tools; no SSE stream)`,
     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"}`,
+    svc ? svc.supported ? `  wake daemon: ${svc.unitPath}` : `  wake daemon: manual \u2014 ${svc.note ?? "unsupported platform"}` : "  wake daemon: NOT installed (no launch path resolved) \u2014 run connect from the CLI",
     "",
     "Next steps (openclaw):",
-    "  - 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",
+    ...svc && svc.supported ? [
+      `  - Start the standing wake daemon:  ${svc.activateCmd}`,
+      "    (it holds the SSE stream so an IDLE agent is still woken on @mentions)."
+    ] : svc ? [`  - Start the standing wake daemon:  ${svc.activateCmd}`] : [],
+    "  - Ensure the OpenClaw gateway is running (the daemon POSTs /hooks/agent to it).",
+    "  - Restart the OpenClaw gateway to spawn the kojee MCP tools server: openclaw gateway restart",
     "  - Verify: openclaw mcp list  (kojee should be listed)  /  kojee-mcp doctor",
     "",
     // Belt-and-suspenders: the same condensed rules ride the kojee MCP server's
@@ -650,11 +684,21 @@ function installOpenclaw(inp) {
 }
 function uninstallOpenclaw(inp) {
   const removed = removeOpenclawMcpServer(inp.openclawConfigPath);
+  const svc = inp.homeDir ? removeService(inp.platform ?? process.platform, {
+    serviceName: "kojee-openclaw",
+    binPath: "",
+    runtime: "openclaw",
+    homeDir: inp.homeDir
+  }) : null;
   const lines = [
-    "Uninstalling runtime: openclaw (MCP server + /wake injector)",
+    "Uninstalling runtime: openclaw (MCP server + wake daemon)",
     removed ? `  removed mcp.servers.kojee from ${inp.openclawConfigPath} (hooks + siblings preserved)` : `  no mcp.servers.kojee in ${inp.openclawConfigPath} \u2014 nothing to remove`,
+    ...svc ? [
+      svc.removed ? `  removed the kojee-openclaw wake-daemon unit (stop it: ${svc.deactivateCmd})` : "  no kojee-openclaw wake-daemon unit found"
+    ] : [],
     "",
     "Next steps (openclaw):",
+    "  - Stop the wake daemon if still running (see the deactivate command above).",
     "  - Restart the OpenClaw gateway: openclaw gateway restart",
     "  - hooks.enabled/token were left intact (you may use hooks for other integrations)."
   ];
@@ -827,7 +871,7 @@ function whatHappensNext(runtime, opts) {
   return lines.join("\n");
 }
 async function configureClaudeCode(opts) {
-  const { runInit } = await import("./install-JQNDGAAQ.js");
+  const { runInit } = await import("./install-NG366AOQ.js");
   const report = runInit({
     ...opts.configPath ? { configPath: opts.configPath } : {},
     ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {},
@@ -929,7 +973,7 @@ function configureCodex(opts) {
   lines.push("");
   if (writeResult.hooksChanged) {
     lines.push(
-      "IMPORTANT: Codex will re-prompt to trust hooks on its next launch \u2014 approve it, or wakes silently stop."
+      `IMPORTANT: this rewrite invalidated Codex's hook trust \u2014 the hooks are now UNTRUSTED and wakes stay silent until you re-trust them: ${CODEX_TRUST_FIX_STEPS}.`
     );
     lines.push("");
   }
@@ -1086,18 +1130,35 @@ function openclawConfigPath(opts) {
 }
 function configureOpenclaw(opts) {
   const runtime = "openclaw";
+  const daemonExec = resolveDaemonExec();
   const install = installOpenclaw({
     openclawConfigPath: openclawConfigPath(opts),
-    ...opts.pairedConfigPath ? { pairedConfigPath: opts.pairedConfigPath } : {}
+    ...opts.pairedConfigPath ? { pairedConfigPath: opts.pairedConfigPath } : {},
+    // Launch coords for the standing kojee-openclaw wake daemon (holds the SSE
+    // stream so an idle agent is reachable). Absent → installer writes only the
+    // MCP config (the shape tests).
+    binPath: daemonExec.binPath,
+    nodePath: daemonExec.nodePath,
+    homeDir: kojeeHomeDir(),
+    platform: process.platform
   });
   recordRuntime(runtime);
-  return { runtime, output: install.output, exitCode: install.exitCode };
+  const lines = [install.output];
+  if (daemonExec.ephemeral) {
+    lines.push(
+      "",
+      "\u26A0 DURABILITY: this ran from an ephemeral npx cache, so the wake daemon points at a",
+      "  path npx will eventually delete (the daemon would then fail to start). For a durable",
+      "  daemon:  npm i -g kojee-mcp && kojee-mcp connect <code> --runtime openclaw"
+    );
+  }
+  return { runtime, output: lines.join("\n"), exitCode: install.exitCode };
 }
 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-JQNDGAAQ.js");
+    const { runUninstall } = await import("./install-NG366AOQ.js");
     const report = runUninstall({
       ...opts.configPath ? { configPath: opts.configPath } : {},
       ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {}
@@ -1121,7 +1182,11 @@ async function runWizardUninstall(runtime, opts) {
     lines.push(`  config.toml [mcp_servers.kojee]: ${removed.mcpServer ? "removed" : "not found"}`);
     lines.push(`  hooks.json Stop: ${removed.stopHook ? "removed" : "not found"}`);
   } else if (effective === "openclaw") {
-    const un = uninstallOpenclaw({ openclawConfigPath: openclawConfigPath(opts) });
+    const un = uninstallOpenclaw({
+      openclawConfigPath: openclawConfigPath(opts),
+      homeDir: kojeeHomeDir(),
+      platform: process.platform
+    });
     lines.push(un.output);
   } else {
     const hermesConfig = defaultHermesConfigPath(kojeeHomeDir());

package/dist/{chunk-T6QANUS2.js → chunk-7LKCTUBY.js}

@@ -1,11 +1,11 @@
+import {
+  wrapNpxLauncher
+} from "./chunk-D6JKFJ6A.js";
 import {
   buildHookCommand,
   isKojeeHookCommand,
   npxHookCommand
-} from "./chunk-TMCNB4JH.js";
-import {
-  wrapNpxLauncher
-} from "./chunk-D6JKFJ6A.js";
+} from "./chunk-COM6435C.js";
 import {
   kojeeHomeDir
 } from "./chunk-SQL56SEB.js";
@@ -32,6 +32,7 @@ function defaultCodexConfigPath() {
 function defaultCodexHooksPath() {
   return win32DriveQualified(path.join(kojeeHomeDir(), ".codex", "hooks.json"), ".codex", "hooks.json");
 }
+var CODEX_TRUST_FIX_STEPS = 'to trust it, run `codex`, then type `/hooks` and press `t` on the entry \u2014 Codex only prints a "hooks need review" warning at startup, it does not auto-prompt';
 var CODEX_STOP_HOOK_COMMAND = npxHookCommand("codex-stop");
 function codexStopHookCommand() {
   return buildHookCommand("codex-stop");
@@ -345,6 +346,7 @@ function writeFile600(p, content) {
 export {
   defaultCodexConfigPath,
   defaultCodexHooksPath,
+  CODEX_TRUST_FIX_STEPS,
   buildCodexMcpServerTable,
   buildCodexStopHookBlock,
   buildCodexPromptSubmitHookBlock,

package/dist/chunk-COM6435C.js

@@ -0,0 +1,65 @@
+// 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}`;
+}
+var NPX_CACHE_RE = /[\\/]_npx[\\/]/;
+function resolveCliEntry(moduleUrl = import.meta.url) {
+  try {
+    const here = fileURLToPath(moduleUrl);
+    const candidate = path.join(path.dirname(here), "cli.js");
+    if (!fs.existsSync(candidate)) return null;
+    if (NPX_CACHE_RE.test(candidate)) return null;
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+function stableExecPath(execPath = process.execPath) {
+  const m = /^(.*)\/Cellar\/node(?:@[^/]+)?\/[^/]+\/bin\/node$/.exec(execPath);
+  if (!m || !m[1]) return execPath;
+  const alias = path.join(m[1], "bin", "node");
+  try {
+    if (!fs.existsSync(alias)) return execPath;
+    const real = fs.realpathSync(alias);
+    return /[\\/]Cellar[\\/]node(@[^/]+)?[\\/]/.test(real) ? alias : execPath;
+  } catch {
+    return execPath;
+  }
+}
+function buildHookCommand(type, opts = {}) {
+  const cliEntry = opts.cliEntry !== void 0 ? opts.cliEntry : resolveCliEntry();
+  if (!cliEntry) return npxHookCommand(type);
+  const execPath = stableExecPath(opts.execPath ?? process.execPath);
+  return `"${execPath}" "${cliEntry}" hook --type=${type}`;
+}
+var PINNED_HOOK_RE = /^"[^"]+" "[^"]+" hook --type=(stop|user-prompt-submit|codex-stop|codex-prompt-submit)$/;
+function isKojeeHookCommand(command) {
+  if (command.startsWith("npx -y kojee-mcp hook --type=")) return true;
+  return PINNED_HOOK_RE.test(command);
+}
+function classifyHookCommand(command, deps = {}) {
+  if (command.startsWith("npx -y kojee-mcp hook --type=")) return "npx";
+  if (!PINNED_HOOK_RE.test(command)) return "foreign";
+  const paths = [...command.matchAll(/"([^"]+)"/g)].map((m) => m[1] ?? "");
+  const cliPath = paths[1] ?? "";
+  if (NPX_CACHE_RE.test(cliPath)) return "pinned-ephemeral";
+  const exists = deps.exists ?? ((p) => {
+    try {
+      return fs.existsSync(p);
+    } catch {
+      return true;
+    }
+  });
+  if (cliPath && !exists(cliPath)) return "pinned-broken";
+  return "pinned-durable";
+}
+
+export {
+  npxHookCommand,
+  buildHookCommand,
+  isKojeeHookCommand,
+  classifyHookCommand
+};

package/dist/{chunk-TUDC4GY5.js → chunk-EF466Y7P.js}

@@ -295,9 +295,11 @@ async function startProxy(config) {
   }
   console.error(`[kojee-mcp] Tandem memberships: ${tandemMembershipCount === -1 ? "unknown" : tandemMembershipCount}`);
   let server;
-  const { selectDelivery } = await import("./registry-ACVPVDCS.js");
+  const isHeadlessDaemon = !!process.env["KOJEE_HEADLESS"] || !!process.env["KOJEE_WEBHOOK_EXPECTED"];
+  const { selectDelivery } = await import("./registry-PNL4VGNK.js");
   const delivery = selectDelivery(adapter.runtime, {
     supportsChannels: adapter.supportsChannels,
+    headless: isHeadlessDaemon,
     // Per-window delivered mirror for the tandem_pending tool (codex only —
     // other runtimes' deliveries ignore this even when passed).
     ...pendingState ? { onDelivered: (e) => pendingState.noteDelivered(e.tandem_id, e.cursor) } : {}
@@ -338,13 +340,12 @@ async function startProxy(config) {
     }
     server = createMcpServer(registry, adapter, tandemMembershipCount);
   }
-  const isHeadlessDaemon = !!process.env["KOJEE_WEBHOOK_EXPECTED"];
   if (!isHeadlessDaemon) {
     process.stdin.on("end", () => shutdown("stdin end"));
     process.stdin.on("close", () => shutdown("stdin close"));
   } else {
     console.error(
-      "[kojee-mcp] headless daemon (KOJEE_WEBHOOK_EXPECTED=1): stdin EOF ignored; lifecycle owned by the service manager (SIGTERM/SIGINT/SIGHUP)."
+      "[kojee-mcp] headless daemon (KOJEE_HEADLESS / KOJEE_WEBHOOK_EXPECTED): stdin EOF ignored; lifecycle owned by the service manager (SIGTERM/SIGINT/SIGHUP)."
     );
   }
   process.on("SIGHUP", () => shutdown("SIGHUP"));
@@ -363,6 +364,33 @@ async function startProxy(config) {
       "[kojee-mcp] no resolvable Claude ancestor (Windows fallback) \u2014 parent-liveness watchdog not armed; stdin close/end + SIGHUP/SIGINT/SIGTERM cover shutdown, and per-window wake is preserved via the session-id discovery key."
     );
   }
+  if (isHeadlessDaemon && activeStreamHandle) {
+    const { createStreamWatchdog } = await import("./stream-watchdog-CLRS2VMV.js");
+    const { recordFlap } = await import("./flap-log-D4KG7RK4.js");
+    const handleForWatchdog = activeStreamHandle;
+    const bootAt = Date.now();
+    const streamWatchdog = createStreamWatchdog({
+      getState: () => {
+        const s = handleForWatchdog.getState();
+        return { connected: s.connected, lastEventAt: s.lastEventAt };
+      },
+      onUnhealthy: ({ disconnectedForMs, reason }) => {
+        recordFlap({
+          ts: Date.now(),
+          instanceKey,
+          reason,
+          disconnectedForMs,
+          uptimeMs: Date.now() - bootAt
+        });
+        console.error(
+          `[kojee-mcp] stream-liveness watchdog: ${reason} \u2014 self-exiting(1); the service manager (Restart=always) will start a fresh process. Repeated exits are recorded and surfaced by \`kojee-mcp doctor\` (flap detection).`
+        );
+        process.exit(1);
+      }
+    });
+    streamWatchdog.start();
+    teardownSteps.push(() => streamWatchdog.stop());
+  }
   await startMcpServer(server);
 }
 async function enrollAndDiscover(config, keystorePath, isRetry = false) {

package/dist/{chunk-NE2F5CKS.js → chunk-LKGKDZSO.js}

@@ -87,18 +87,22 @@ function createCachedOpenclawWakeResolver(opts = {}) {
     return resolution;
   };
 }
-async function postOpenclawWake(target, body, deps = {}) {
+function openclawAgentUrl(wakeUrl) {
+  return wakeUrl.replace(/\/wake$/, "/agent");
+}
+async function postOpenclawAgent(target, body, deps = {}) {
   const doFetch = deps.fetch ?? fetch;
+  const url = openclawAgentUrl(target.url);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), deps.timeoutMs ?? 4e3);
   try {
-    const res = await doFetch(target.url, {
+    const res = await doFetch(url, {
       method: "POST",
       headers: { "content-type": "application/json", authorization: `Bearer ${target.token}` },
-      body: JSON.stringify(body),
+      body: JSON.stringify({ name: "Kojee", wakeMode: "now", ...body }),
       signal: controller.signal
     });
-    return res.ok ? { ok: true, status: res.status } : { ok: false, status: res.status, error: `wake POST ${res.status}` };
+    return res.ok ? { ok: true, status: res.status } : { ok: false, status: res.status, error: `agent POST ${res.status}` };
   } catch (err) {
     return { ok: false, error: err.message };
   } finally {
@@ -109,5 +113,5 @@ async function postOpenclawWake(target, body, deps = {}) {
 export {
   resolveOpenclawWakeTarget,
   createCachedOpenclawWakeResolver,
-  postOpenclawWake
+  postOpenclawAgent
 };

package/dist/chunk-P64UR3SE.js

@@ -0,0 +1,86 @@
+import {
+  kojeeHomeDir
+} from "./chunk-SQL56SEB.js";
+
+// src/runtime/flap-log.ts
+import fs from "fs";
+import path from "path";
+var MAX_FLAP_ENTRIES = 25;
+function defaultFlapLogPath() {
+  return path.join(kojeeHomeDir(), ".kojee", "daemon-flaps.json");
+}
+function realRead(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+function realWrite(p, content) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, content, "utf8");
+}
+function readFlaps(deps = {}) {
+  const p = deps.filePath ?? defaultFlapLogPath();
+  const raw = (deps.readFile ?? realRead)(p);
+  if (raw === null) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (e) => !!e && typeof e.ts === "number" && typeof e.instanceKey === "string"
+    );
+  } catch {
+    return [];
+  }
+}
+function recordFlap(entry, deps = {}) {
+  try {
+    const p = deps.filePath ?? defaultFlapLogPath();
+    const existing = readFlaps(deps);
+    const next = [...existing, entry].slice(-MAX_FLAP_ENTRIES);
+    (deps.writeFile ?? realWrite)(p, JSON.stringify(next, null, 2));
+  } catch {
+  }
+}
+function flapRateExceeds(flaps, opts) {
+  const cutoff = opts.now - opts.windowMs;
+  return flaps.filter((f) => f.ts >= cutoff).length >= opts.count;
+}
+function recentFlapCount(flaps, windowMs, now) {
+  const cutoff = now - windowMs;
+  return flaps.filter((f) => f.ts >= cutoff).length;
+}
+var FLAP_WINDOW_MS = 15 * 6e4;
+var FLAP_WARN_COUNT = 3;
+function buildFlapDoctorCheck(deps = {}) {
+  const name = deps.name ?? "daemon flapping";
+  const history = (deps.readFlaps ?? readFlaps)();
+  const now = deps.now?.() ?? Date.now();
+  const recent = recentFlapCount(history, FLAP_WINDOW_MS, now);
+  if (flapRateExceeds(history, { count: FLAP_WARN_COUNT, windowMs: FLAP_WINDOW_MS, now })) {
+    const last = history[history.length - 1];
+    return {
+      name,
+      ok: "warn",
+      detail: `the stream-liveness watchdog self-exited ${recent} times in the last 15min \u2014 the SSE reconnect loop is repeatedly wedging. This is a CHRONIC failure being masked by auto-restart; root-cause it (last reason: "${last?.reason ?? "unknown"}").`
+    };
+  }
+  return {
+    name,
+    ok: true,
+    detail: recent === 0 ? "no stream-liveness self-exits recently (healthy)" : `${recent} self-exit(s) in the last 15min \u2014 below the ${FLAP_WARN_COUNT}-in-15min chronic threshold`
+  };
+}
+
+export {
+  MAX_FLAP_ENTRIES,
+  defaultFlapLogPath,
+  readFlaps,
+  recordFlap,
+  flapRateExceeds,
+  recentFlapCount,
+  FLAP_WINDOW_MS,
+  FLAP_WARN_COUNT,
+  buildFlapDoctorCheck
+};

package/dist/{chunk-CUOJHP2S.js → chunk-QDQGN5XP.js}

@@ -11,6 +11,7 @@ var STALE_FLOOR_MS = 9e4;
 var STALE_INTERVAL_MULTIPLIER = 3;
 var STALE_CHECK_INTERVAL_MS = 5e3;
 var UNARMED_FALLBACK_MS = 12 * 6e4;
+var CONNECT_TIMEOUT_MS = 3e4;
 var UNDICI_DEFAULT_BODY_TIMEOUT_MS = 3e5;
 function createAdaptiveWatchdog(options = {}) {
   const floorMs = options.floorMs ?? STALE_FLOOR_MS;
@@ -165,10 +166,16 @@ async function startEventStream(opts) {
 }
 async function connectAndConsume(opts, cursors, controller, isReconnect, state, dispatcher, onCursor, onOpen) {
   const mapSince = cursors.size > 0 ? serializeCursorMap(cursors) : null;
-  let res = await openStream(opts, controller, mapSince, dispatcher);
-  if (res.status === 400 && mapSince !== null) {
-    console.error("[event-stream] per-room ?since rejected (400) \u2014 falling back to bare cursor");
-    res = await openStream(opts, controller, String(Math.min(...cursors.values())), dispatcher);
+  const connectTimer = setTimeout(() => controller.abort(), CONNECT_TIMEOUT_MS);
+  let res;
+  try {
+    res = await openStream(opts, controller, mapSince, dispatcher);
+    if (res.status === 400 && mapSince !== null) {
+      console.error("[event-stream] per-room ?since rejected (400) \u2014 falling back to bare cursor");
+      res = await openStream(opts, controller, String(Math.min(...cursors.values())), dispatcher);
+    }
+  } finally {
+    clearTimeout(connectTimer);
   }
   if (!res.ok) throw new Error(`SSE connect failed: ${res.status}`);
   if (!res.body) throw new Error("SSE response has no body");
@@ -448,6 +455,7 @@ function normalizeBackendEvent(raw, sseEventType) {
 export {
   undiciFetch,
   UNARMED_FALLBACK_MS,
+  CONNECT_TIMEOUT_MS,
   UNDICI_DEFAULT_BODY_TIMEOUT_MS,
   createAdaptiveWatchdog,
   createBackoffController,

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-EIAUW6KO.js";
 import {
   startProxy
-} from "./chunk-TUDC4GY5.js";
+} from "./chunk-EF466Y7P.js";
 import "./chunk-XYDNRVOU.js";
 import {
   pairedConfigPath
@@ -47,7 +47,7 @@ program.command("pair <code>").description("Pair this machine against Kojee usin
 program.command("connect <code>").description(
   "Connect this runtime to Kojee with a per-agent pair code from the dashboard (claude-code | codex | openclaw | hermes). claude-code/codex/openclaw write a per-runtime paired slot (~/.kojee/agents/<runtime>/config.json) and point the runtime launcher at it via --paired-config; hermes writes the global ~/.kojee/config.json (its daemon + `kojee-mcp send` read that). Idempotent."
 ).requiredOption("--runtime <id>", "Target runtime: claude-code | codex | openclaw | hermes").option("--url <url>", "Broker base URL (default: the canonical staging broker)").action(async (code, opts) => {
-  const { runConnect } = await import("./connect-handler-W7EAIU4R.js");
+  const { runConnect } = await import("./connect-handler-J5RA3EJJ.js");
   const result = await runConnect({
     code,
     runtime: opts.runtime,
@@ -57,6 +57,15 @@ program.command("connect <code>").description(
   console.error(result.output);
   process.exit(result.exitCode);
 });
+program.command("reconnect").description(
+  "Re-run configure for an already-paired runtime, KEEPING the token + enrolled key (no re-pair). Re-writes configs/hooks to this install and refreshes the agent instructions."
+).option("--runtime <id>", "Target runtime (defaults to the recorded runtime from the last connect/init)").action(async (opts) => {
+  const { runReconnect } = await import("./connect-handler-J5RA3EJJ.js");
+  const result = await runReconnect({ ...opts.runtime ? { runtime: opts.runtime } : {} });
+  for (const m of result.messages) console.error(m);
+  console.error(result.output);
+  process.exit(result.exitCode);
+});
 program.command("hook").description("Run a kojee MCP hook script (called by Claude Code via ~/.claude/settings.json)").requiredOption(
   "--type <type>",
   "Hook type: stop, user-prompt-submit, codex-stop, or codex-prompt-submit"
@@ -85,7 +94,7 @@ program.command("hook").description("Run a kojee MCP hook script (called by Clau
   }
 });
 program.command("install-hooks").description("Install kojee Stop + UserPromptSubmit hooks in ~/.claude/settings.json (idempotent)").option("--hooks-path <path>", "Override default ~/.claude/settings.json").option("--uninstall", "Remove kojee hook entries instead of installing them").action(async (opts) => {
-  const { installHooks, uninstallHooks } = await import("./install-JQNDGAAQ.js");
+  const { installHooks, uninstallHooks } = await import("./install-NG366AOQ.js");
   if (opts.uninstall) {
     const removed = uninstallHooks({ hooksPath: opts.hooksPath });
     console.error(removed ? "Removed kojee hook entries." : "No kojee hook entries found.");
@@ -117,7 +126,7 @@ program.command("tail <path>").description("Stream a file's contents and follow
   "--wake-only",
   "Suppress routine heartbeat warn/recover telemetry; surface only a sustained stream outage"
 ).action(async (filePath, opts) => {
-  const { runTail } = await import("./tail-stream-HG4BKJOG.js");
+  const { runTail } = await import("./tail-stream-EIMLRRUP.js");
   try {
     await runTail(filePath, { wakeOnly: opts.wakeOnly === true });
   } catch (err) {
@@ -126,7 +135,7 @@ program.command("tail <path>").description("Stream a file's contents and follow
   }
 });
 program.command("doctor").description("Diagnose the kojee wake path (proxy, hook-server, SSE stream, event log, Monitor) and print the exact wake recipe").action(async () => {
-  const { runDoctor } = await import("./doctor-O7MLJEMO.js");
+  const { runDoctor } = await import("./doctor-7Y7PWE54.js");
   const code = await runDoctor();
   process.exit(code);
 });
@@ -145,7 +154,7 @@ function addInstallOptions(cmd, runtimeHelp) {
 function makeInstallAction(verb) {
   return async (opts) => {
     const interactive = process.stdin.isTTY === true && opts.runtime === void 0;
-    const { runSetup, resolvePairCode } = await import("./setup-handler-6T7Q6DYQ.js");
+    const { runSetup, resolvePairCode } = await import("./setup-handler-VWP6D74B.js");
     const pairCode = resolvePairCode(opts);
     const result = await runSetup({
       verb,

package/dist/{connect-handler-W7EAIU4R.js → connect-handler-J5RA3EJJ.js}

@@ -2,17 +2,19 @@ import {
   DEFAULT_BROKER_URL,
   reconcileConnectPairSlot,
   runWizard
-} from "./chunk-RTYRJAJO.js";
-import "./chunk-T6QANUS2.js";
+} from "./chunk-7DCZNZSP.js";
+import "./chunk-7LKCTUBY.js";
 import "./chunk-E6WMFMM2.js";
 import "./chunk-GEGUWQYT.js";
-import "./chunk-77HWBSRH.js";
-import "./chunk-TMCNB4JH.js";
-import "./chunk-D6JKFJ6A.js";
 import {
   CONNECT_RUNTIMES
 } from "./chunk-EIH2LNF4.js";
-import "./chunk-RDLF4NQC.js";
+import {
+  readRecordedRuntime
+} from "./chunk-RDLF4NQC.js";
+import "./chunk-77HWBSRH.js";
+import "./chunk-D6JKFJ6A.js";
+import "./chunk-COM6435C.js";
 import "./chunk-SQL56SEB.js";
 import "./chunk-V5VZPYMZ.js";
 import {
@@ -33,6 +35,7 @@ import "./chunk-U5HHHRXA.js";
 import "./chunk-O4JQY7IF.js";
 
 // src/wizard/connect-handler.ts
+import fs from "fs";
 import os from "os";
 import path from "path";
 function absConfigPath(runtime) {
@@ -139,7 +142,63 @@ Start (or restart) the hermes daemon to pick up the connection.`,
     exitCode: 0
   };
 }
+async function runReconnect(opts = {}) {
+  const messages = [];
+  const runtime = opts.runtime ?? readRecordedRuntime() ?? null;
+  if (!runtime) {
+    return {
+      messages,
+      output: `reconnect: no runtime recorded on this box \u2014 pass --runtime (${CONNECT_RUNTIMES.join(" | ")} | hermes), or run \`kojee-mcp connect <code> --runtime <id>\` first.`,
+      exitCode: 2
+    };
+  }
+  const isHermes = runtime === "hermes";
+  if (!isHermes && !CONNECT_RUNTIMES.includes(runtime)) {
+    return {
+      messages,
+      output: `reconnect supports: ${CONNECT_RUNTIMES.join(", ")}, hermes. Unknown --runtime "${runtime}".`,
+      exitCode: 2
+    };
+  }
+  const configPath = isHermes ? pairedConfigPath() : absConfigPath(runtime);
+  const paired = loadPairedConfig(configPath);
+  if (!paired?.token) {
+    return {
+      messages,
+      output: `reconnect: no paired config at ${configPath} \u2014 nothing to keep. Run \`kojee-mcp connect <code> --runtime ${runtime}\` to pair first.`,
+      exitCode: 2
+    };
+  }
+  const keystorePath = isHermes ? defaultPairedKeystorePath() : deriveKeystorePath(paired.token);
+  if (!fs.existsSync(keystorePath)) {
+    messages.push(
+      `\u26A0 enrolled keystore MISSING at ${keystorePath} \u2014 configs will be refreshed, but the proxy cannot authenticate with a new key on this token (backend rejects double-enroll). If sends fail, re-pair with a fresh code.`
+    );
+  }
+  const wizard = opts.runWizard ?? runWizard;
+  const wiz = await wizard({
+    runtime,
+    ...isHermes ? {} : { pairedConfigPath: configPath },
+    interactive: false
+  });
+  if (wiz.exitCode !== 0) {
+    return { messages, output: wiz.output, exitCode: wiz.exitCode };
+  }
+  const label = identityLabel(paired);
+  return {
+    messages,
+    output: [
+      `\u21BB reconfigured ${runtime} as ${label} \u2014 token KEPT (no re-pair, no key re-enrollment).`,
+      "Configs + hooks re-written to this install; agent instructions refreshed below.",
+      `Restart ${runtime} to pick up the changes.`,
+      "",
+      wiz.output
+    ].join("\n"),
+    exitCode: 0
+  };
+}
 export {
   runConnect,
-  runConnectHermes
+  runConnectHermes,
+  runReconnect
 };

package/dist/{doctor-O7MLJEMO.js → doctor-7Y7PWE54.js}

@@ -1,3 +1,7 @@
+import {
+  classifyHookCommand,
+  isKojeeHookCommand
+} from "./chunk-COM6435C.js";
 import "./chunk-XLKGPGZT.js";
 import {
   loadControlToken
@@ -149,6 +153,53 @@ async function resolveDefaultPairedScope() {
   }
   return { scope: resolution.scope, present, ...runtime ? { runtime } : {} };
 }
+function defaultReadHookCommands() {
+  try {
+    const p = path.join(os.homedir(), ".claude", "settings.json");
+    const raw = fs.readFileSync(p, "utf8");
+    const cfg = JSON.parse(raw);
+    const out = [];
+    for (const event of ["Stop", "UserPromptSubmit"]) {
+      for (const matcher of cfg.hooks?.[event] ?? []) {
+        for (const h of matcher.hooks ?? []) {
+          if (typeof h.command === "string" && isKojeeHookCommand(h.command)) out.push(h.command);
+        }
+      }
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+var HOOK_REPIN_FIX = "fix: `npm i -g kojee-mcp` then re-run `kojee-mcp setup` (re-pins in place, no re-pair)";
+function hookPinCheck(commands) {
+  const name = "hook pin (settings.json Stop/UserPromptSubmit)";
+  if (commands === null) {
+    return { name, ok: "warn", detail: `no ~/.claude/settings.json readable \u2014 run \`kojee-mcp setup\` to install the wake hooks` };
+  }
+  if (commands.length === 0) {
+    return { name, ok: "warn", detail: `no kojee hooks installed \u2014 run \`kojee-mcp setup\` (the stop-hook is the Monitor self-heal)` };
+  }
+  const states = commands.map((c) => classifyHookCommand(c));
+  if (states.includes("pinned-broken")) {
+    return { name, ok: false, detail: `pinned cli.js is GONE \u2014 hooks are failing with exit 127 RIGHT NOW; ${HOOK_REPIN_FIX}` };
+  }
+  if (states.includes("pinned-ephemeral")) {
+    return {
+      name,
+      ok: false,
+      detail: `pinned INTO the npx cache (~/.npm/_npx/\u2026) \u2014 npx cache GC will silently kill the hooks (exit 127 every turn); ${HOOK_REPIN_FIX}`
+    };
+  }
+  if (states.includes("npx")) {
+    return {
+      name,
+      ok: "warn",
+      detail: `unpinned (npx -y) \u2014 pays npx resolution every turn and can stall on a registry fetch; ${HOOK_REPIN_FIX}`
+    };
+  }
+  return { name, ok: true, detail: `pinned to a durable binary (${commands.length} hook${commands.length === 1 ? "" : "s"})` };
+}
 async function collectDoctorReport(deps = {}) {
   const fetchFn = deps.fetchFn ?? fetch;
   const isPidAlive = deps.isPidAlive ?? defaultIsPidAlive;
@@ -183,6 +234,8 @@ async function collectDoctorReport(deps = {}) {
       detail: pairedScope.present ? "present (legacy global slot)" : "MISSING \u2014 run `kojee-mcp connect <code> --runtime <id>` (or `kojee-mcp pair`)"
     });
   }
+  const hookCommands = (deps.readHookCommands ?? defaultReadHookCommands)();
+  checks.push(hookPinCheck(hookCommands));
   let logPath = null;
   if (!discovery) {
     checks.push({
@@ -354,18 +407,18 @@ function formatDoctorReport(report) {
 async function runDoctor() {
   const { readRecordedRuntime } = await import("./runtime-record-OXRLTOLC.js");
   if (readRecordedRuntime() === "codex") {
-    const { collectCodexDoctorReport, formatCodexDoctorReport } = await import("./doctor-codex-D4BOWIAA.js");
+    const { collectCodexDoctorReport, formatCodexDoctorReport } = await import("./doctor-codex-OEYUM7DE.js");
     const report2 = collectCodexDoctorReport();
     console.error(formatCodexDoctorReport(report2));
     return report2.verdict === "broken" ? 1 : 0;
   }
   if (readRecordedRuntime() === "openclaw") {
-    const { collectOpenclawDoctorReport, formatOpenclawDoctorReport } = await import("./doctor-openclaw-LL6NSPLC.js");
+    const { collectOpenclawDoctorReport, formatOpenclawDoctorReport } = await import("./doctor-openclaw-B5KADVHD.js");
     const report2 = collectOpenclawDoctorReport();
     console.error(formatOpenclawDoctorReport(report2));
     return report2.verdict === "broken" ? 1 : 0;
   }
-  const { hermesArtifactsPresent, collectHermesDoctorReport, formatHermesDoctorReport } = await import("./doctor-hermes-WLDI4R6P.js");
+  const { hermesArtifactsPresent, collectHermesDoctorReport, formatHermesDoctorReport } = await import("./doctor-hermes-KMHM27Y3.js");
   if (hermesArtifactsPresent()) {
     const hermesReport = collectHermesDoctorReport();
     console.error(formatHermesDoctorReport(hermesReport));

package/dist/{doctor-codex-D4BOWIAA.js → doctor-codex-OEYUM7DE.js}

@@ -1,10 +1,14 @@
 import {
+  CODEX_TRUST_FIX_STEPS,
   defaultCodexConfigPath,
   defaultCodexHooksPath,
   isPlaceholderWebhookUrl
-} from "./chunk-T6QANUS2.js";
-import "./chunk-TMCNB4JH.js";
+} from "./chunk-7LKCTUBY.js";
 import "./chunk-D6JKFJ6A.js";
+import {
+  classifyHookCommand,
+  isKojeeHookCommand
+} from "./chunk-COM6435C.js";
 import {
   CODEX_STATUS_STALE_MS,
   readAllCodexStatusRaw,
@@ -22,6 +26,7 @@ import {
 
 // src/doctor-codex.ts
 import fs from "fs";
+import path from "path";
 
 // src/hooks/codex-trust-hash.ts
 import crypto from "crypto";
@@ -127,15 +132,33 @@ function extractPairedConfigPath(toml) {
   const m = toml.match(/args\s*=\s*\[[^\]]*"--paired-config"\s*,\s*"([^"]+)"/);
   return m ? m[1].replace(/\\\\/g, "\\") : null;
 }
-function defaultReadFile(path) {
+function defaultReadFile(filePath) {
   return () => {
     try {
-      return fs.readFileSync(path, "utf8");
+      return fs.readFileSync(filePath, "utf8");
     } catch {
       return null;
     }
   };
 }
+function defaultDiscoverProjectCodexConfigs(cwd = process.cwd()) {
+  const globalToml = path.resolve(defaultCodexConfigPath());
+  const found = [];
+  let dir = cwd;
+  for (let hops = 0; hops < 64; hops++) {
+    const candidate = path.join(dir, ".codex", "config.toml");
+    if (path.resolve(candidate) !== globalToml) {
+      try {
+        found.push({ path: candidate, toml: fs.readFileSync(candidate, "utf8") });
+      } catch {
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return found;
+}
 function collectCodexDoctorReport(deps = {}) {
   const readConfigToml = deps.readConfigToml ?? defaultReadFile(defaultCodexConfigPath());
   const readHooksJson = deps.readHooksJson ?? defaultReadFile(defaultCodexHooksPath());
@@ -150,6 +173,25 @@ function collectCodexDoctorReport(deps = {}) {
     ok: configOk,
     detail: configOk ? 'present with env.KOJEE_RUNTIME="codex" (Tier-1 contract)' : `MISSING [mcp_servers.kojee] or env.KOJEE_RUNTIME="codex" \u2014 ${WIZARD_RERUN}`
   });
+  const projectConfigs = deps.discoverProjectCodexConfigs?.() ?? defaultDiscoverProjectCodexConfigs();
+  const shadowing = projectConfigs.filter(
+    (c) => c.toml.includes("[mcp_servers.kojee]") || /\[hooks\.state/.test(c.toml) || /hook --type=codex-/.test(c.toml)
+  );
+  if (shadowing.length > 0) {
+    const pins = shadowing.map((s) => /kojee-mcp@([^\s"']+)/.exec(s.toml)?.[1]).filter((v) => !!v);
+    const pinNote = pins.length ? ` (pins kojee-mcp@${[...new Set(pins)].join(", ")})` : "";
+    checks.push({
+      name: "Codex config shadowing",
+      ok: "warn",
+      detail: `project-local ${shadowing.map((s) => s.path).join(", ")} defines Kojee/hook config${pinNote} that OVERLAYS the global ~/.codex/config.toml \u2014 Codex may run it instead of the reconnected global entry (split-brain), and this doctor's other checks read only the global file so they may not reflect what Codex actually runs. Reconcile or move the project file(s) aside (e.g. rename to config.toml.bak) so the global reconnect takes effect.`
+    });
+  } else {
+    checks.push({
+      name: "Codex config shadowing",
+      ok: true,
+      detail: "no project-local .codex/config.toml overlaying the global"
+    });
+  }
   const hooksRaw = readHooksJson() ?? "{}";
   let hooksJson = {};
   try {
@@ -173,6 +215,39 @@ function collectCodexDoctorReport(deps = {}) {
     ok: upsPresent ? true : "warn",
     detail: upsPresent ? "present (pending-wake catch-up at the next prompt)" : `MISSING \u2014 a silently-dropped Stop block is never re-surfaced. ${WIZARD_RERUN}`
   });
+  const codexHookCommands = [];
+  for (const event of ["Stop", "UserPromptSubmit"]) {
+    for (const e of hooksJson.hooks?.[event] ?? []) {
+      for (const h of e.hooks ?? []) {
+        if (typeof h.command === "string" && isKojeeHookCommand(h.command)) codexHookCommands.push(h.command);
+      }
+    }
+  }
+  if (codexHookCommands.length > 0) {
+    const states = codexHookCommands.map((c) => classifyHookCommand(c));
+    const repin = "fix: `npm i -g kojee-mcp` then re-run connect for codex (re-pins in place, no re-pair)";
+    if (states.includes("pinned-broken")) {
+      checks.push({
+        name: "hook pin (hooks.json)",
+        ok: false,
+        detail: `pinned cli.js is GONE \u2014 hooks fail with exit 127 RIGHT NOW; ${repin}`
+      });
+    } else if (states.includes("pinned-ephemeral")) {
+      checks.push({
+        name: "hook pin (hooks.json)",
+        ok: false,
+        detail: `pinned INTO the npx cache (~/.npm/_npx/\u2026) \u2014 cache GC will silently kill the hooks (exit 127 every turn); ${repin}`
+      });
+    } else if (states.includes("npx")) {
+      checks.push({
+        name: "hook pin (hooks.json)",
+        ok: "warn",
+        detail: `unpinned (npx -y) \u2014 pays npx resolution every turn and can stall on a registry fetch; ${repin}`
+      });
+    } else {
+      checks.push({ name: "hook pin (hooks.json)", ok: true, detail: "pinned to a durable binary" });
+    }
+  }
   const featureHooks = parseCodexFeatureHooks(toml);
   if (featureHooks !== true) {
     checks.push({
@@ -210,13 +285,13 @@ function collectCodexDoctorReport(deps = {}) {
           checks.push({
             name: `hook trust (${event})`,
             ok: "warn",
-            detail: `${label} is UNTRUSTED \u2014 no [hooks.state]."${key}" trusted_hash. Codex will NOT run it (wakes silently stop) until you launch Codex and APPROVE its trust prompt.`
+            detail: `${label} is UNTRUSTED \u2014 no [hooks.state]."${key}" trusted_hash. Codex will NOT run it (wakes silently stop) \u2014 ${CODEX_TRUST_FIX_STEPS}.`
           });
         } else {
           checks.push({
             name: `hook trust (${event})`,
             ok: "warn",
-            detail: `${label} trust is STALE \u2014 trusted_hash no longer matches the current hooks.json entry (a rewrite invalidated it). Codex will NOT run it until you re-approve the trust prompt.`
+            detail: `${label} trust is STALE \u2014 trusted_hash no longer matches the current hooks.json entry (a rewrite invalidated it). Codex will NOT run it \u2014 ${CODEX_TRUST_FIX_STEPS}.`
           });
         }
       }
@@ -363,6 +438,7 @@ function formatCodexDoctorReport(report) {
 }
 export {
   collectCodexDoctorReport,
+  defaultDiscoverProjectCodexConfigs,
   formatCodexDoctorReport,
   parseCodexEnvFromToml
 };

package/dist/{doctor-hermes-WLDI4R6P.js → doctor-hermes-KMHM27Y3.js}

@@ -2,6 +2,10 @@ import {
   HERMES_INSTANCE_KEY,
   HERMES_MCP_SERVER_NAME
 } from "./chunk-GEGUWQYT.js";
+import {
+  buildFlapDoctorCheck
+} from "./chunk-P64UR3SE.js";
+import "./chunk-SQL56SEB.js";
 
 // src/doctor-hermes.ts
 import fs from "fs";
@@ -513,6 +517,19 @@ function collectHermesDoctorReport(deps = {}) {
       );
     }
   }
+  const flapCheck = buildFlapDoctorCheck({
+    name: "webhook.daemon-flapping",
+    // hermes namespaces every check `webhook.*`
+    ...deps.readFlaps ? { readFlaps: deps.readFlaps } : {},
+    ...deps.now ? { now: deps.now } : {}
+  });
+  emit(
+    checks,
+    collector,
+    flapCheck.name,
+    flapCheck.ok === "warn" ? "warn" : "ok",
+    flapCheck.detail
+  );
   return { checks, findings: collector.findings, verdict: collector.verdict() };
 }
 var CHECK_GROUP = {

package/dist/{doctor-openclaw-LL6NSPLC.js → doctor-openclaw-B5KADVHD.js}

@@ -5,7 +5,10 @@ import {
 import "./chunk-D6JKFJ6A.js";
 import {
   resolveOpenclawWakeTarget
-} from "./chunk-NE2F5CKS.js";
+} from "./chunk-LKGKDZSO.js";
+import {
+  buildFlapDoctorCheck
+} from "./chunk-P64UR3SE.js";
 import "./chunk-SQL56SEB.js";
 import {
   loadPairedConfig,
@@ -60,6 +63,7 @@ function collectOpenclawDoctorReport(deps = {}) {
     ok: paired !== null,
     detail: paired ? `resolves \u2014 source: ${paired.source} paired slot (token value never printed)` : `NONE resolves (no ~/.kojee/agents/openclaw/config.json or ~/.kojee/config.json token) \u2014 ${WIZARD_RERUN}`
   });
+  checks.push(buildFlapDoctorCheck({ ...deps.readFlaps ? { readFlaps: deps.readFlaps } : {}, ...deps.now ? { now: deps.now } : {} }));
   const verdict = checks.some((c) => c.ok === false) ? "broken" : checks.some((c) => c.ok === "warn") ? "degraded" : "healthy";
   return { checks, verdict };
 }

package/dist/{event-stream-ATKYXDBV.js → event-stream-KQHPW42G.js}

@@ -1,4 +1,5 @@
 import {
+  CONNECT_TIMEOUT_MS,
   LOG_HEARTBEAT_INTERVAL_MS,
   UNARMED_FALLBACK_MS,
   UNDICI_DEFAULT_BODY_TIMEOUT_MS,
@@ -10,10 +11,11 @@ import {
   startEventStream,
   statusReason,
   undiciFetch
-} from "./chunk-CUOJHP2S.js";
+} from "./chunk-QDQGN5XP.js";
 import "./chunk-Z5LPNJQ6.js";
 import "./chunk-MIEI4PLB.js";
 export {
+  CONNECT_TIMEOUT_MS,
   LOG_HEARTBEAT_INTERVAL_MS,
   UNARMED_FALLBACK_MS,
   UNDICI_DEFAULT_BODY_TIMEOUT_MS,

package/dist/flap-log-D4KG7RK4.js

@@ -0,0 +1,23 @@
+import {
+  FLAP_WARN_COUNT,
+  FLAP_WINDOW_MS,
+  MAX_FLAP_ENTRIES,
+  buildFlapDoctorCheck,
+  defaultFlapLogPath,
+  flapRateExceeds,
+  readFlaps,
+  recentFlapCount,
+  recordFlap
+} from "./chunk-P64UR3SE.js";
+import "./chunk-SQL56SEB.js";
+export {
+  FLAP_WARN_COUNT,
+  FLAP_WINDOW_MS,
+  MAX_FLAP_ENTRIES,
+  buildFlapDoctorCheck,
+  defaultFlapLogPath,
+  flapRateExceeds,
+  readFlaps,
+  recentFlapCount,
+  recordFlap
+};

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   listTandemIds,
   startProxy
-} from "./chunk-TUDC4GY5.js";
+} from "./chunk-EF466Y7P.js";
 import "./chunk-XYDNRVOU.js";
 import "./chunk-TBVJOXIR.js";
 import "./chunk-Z5LPNJQ6.js";

package/dist/{install-JQNDGAAQ.js → install-NG366AOQ.js}

@@ -1,10 +1,10 @@
-import {
-  buildHookCommand,
-  isKojeeHookCommand
-} from "./chunk-TMCNB4JH.js";
 import {
   wrapNpxLauncher
 } from "./chunk-D6JKFJ6A.js";
+import {
+  buildHookCommand,
+  isKojeeHookCommand
+} from "./chunk-COM6435C.js";
 import {
   secureFile
 } from "./chunk-U5HHHRXA.js";

package/dist/lib.js

@@ -2,7 +2,7 @@ import {
   normalizeBackendEvent,
   sanitizeDisplayname,
   startEventStream
-} from "./chunk-CUOJHP2S.js";
+} from "./chunk-QDQGN5XP.js";
 import {
   resubscribeMemberships
 } from "./chunk-OT2GILXC.js";

package/dist/{registry-ACVPVDCS.js → registry-PNL4VGNK.js}

@@ -5,8 +5,8 @@ import {
 } from "./chunk-XLRF5ATG.js";
 import {
   createCachedOpenclawWakeResolver,
-  postOpenclawWake
-} from "./chunk-NE2F5CKS.js";
+  postOpenclawAgent
+} from "./chunk-LKGKDZSO.js";
 import "./chunk-PHXO5P25.js";
 import {
   recordDelivered
@@ -125,7 +125,7 @@ function createClaudeCodeDelivery() {
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
       const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
       const { createWebhookSink } = await import("./webhook-sink-N6AUTFL3.js");
-      const { startEventStream } = await import("./event-stream-ATKYXDBV.js");
+      const { startEventStream } = await import("./event-stream-KQHPW42G.js");
       const { createMcpServer } = await import("./server-RK4UK6SP.js");
       const { deriveDiscoveryKey } = await import("./ancestry-A2F5KQ6A.js");
       const { resolveSharedSessionId } = await import("./cc-session-id-NNCZCHZZ.js");
@@ -322,7 +322,7 @@ function createWebhookDelivery(name, pendingLedger) {
       const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
       const { createWebhookSink } = await import("./webhook-sink-N6AUTFL3.js");
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
-      const { startEventStream } = await import("./event-stream-ATKYXDBV.js");
+      const { startEventStream } = await import("./event-stream-KQHPW42G.js");
       const { createMcpServer } = await import("./server-RK4UK6SP.js");
       sweepStaleEventLogs();
       eventLog = startEventLog({
@@ -500,14 +500,13 @@ function createCodexDelivery(onDelivered) {
 }
 
 // src/delivery/openclaw.ts
-function formatOpenclawNudge(event) {
-  const who = event.from?.member_id ?? "someone";
-  const body = (event.content?.body ?? "").replace(/\s+/g, " ").slice(0, 160);
-  return `New Kojee Tandem activity in ${event.tandem_id} from ${who}: "${body}". Catch up with tandem_messages / tandem_listen and reply via tandem_send.`;
+function formatOpenclawAgentPrompt(event) {
+  const since = Math.max(0, (event.cursor ?? 1) - 1);
+  return `You were mentioned in Kojee Tandem ${event.tandem_id}. Read it to see who and what \u2014 tandem_messages(tandem_id="${event.tandem_id}", since=${since}) \u2014 then REPLY IN THE FORUM now with tandem_send(tandem_id="${event.tandem_id}", body=..., reply_to="${event.id}"). Do this now; don't just read or ack.`;
 }
 function createOpenclawDelivery(deps = {}) {
   const resolveTarget = deps.resolveTarget ?? createCachedOpenclawWakeResolver();
-  const postWake = deps.postWake ?? postOpenclawWake;
+  const postAgent = deps.postAgent ?? postOpenclawAgent;
   let eventLog = null;
   let streamHandle = null;
   let warnedUnconfigured = false;
@@ -516,7 +515,7 @@ function createOpenclawDelivery(deps = {}) {
     async start(ctx) {
       const { startEventLog, sweepStaleEventLogs } = await import("./event-log-2NBJEIEP.js");
       const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
-      const { startEventStream } = await import("./event-stream-ATKYXDBV.js");
+      const { startEventStream } = await import("./event-stream-KQHPW42G.js");
       const { createMcpServer } = await import("./server-RK4UK6SP.js");
       sweepStaleEventLogs();
       eventLog = startEventLog({
@@ -586,8 +585,13 @@ function createOpenclawDelivery(deps = {}) {
           return;
         }
         warnedUnconfigured = false;
-        const res = await postWake(r.target, { text: formatOpenclawNudge(event), mode: "now" });
-        if (!res.ok) console.error(`[openclaw] wake POST failed: ${res.error ?? res.status}`);
+        const res = await postAgent(r.target, {
+          message: formatOpenclawAgentPrompt(event),
+          channel: "last",
+          name: "Kojee",
+          wakeMode: "now"
+        });
+        if (!res.ok) console.error(`[openclaw] agent wake POST failed: ${res.error ?? res.status}`);
       })().catch((err) => {
         console.error("[openclaw] wake delivery failed:", err);
       });
@@ -614,7 +618,7 @@ function selectDelivery(runtime, opts) {
     return createCodexDelivery(opts.onDelivered);
   }
   if (runtime === "openclaw") {
-    return createOpenclawDelivery();
+    return opts.headless ? createOpenclawDelivery() : null;
   }
   if (!needsWebhookEventStream(opts.env)) {
     return null;

package/dist/{setup-handler-6T7Q6DYQ.js → setup-handler-VWP6D74B.js}

@@ -3,17 +3,17 @@ import {
   pairSlotFor,
   reconcileConnectPairSlot,
   runWizard
-} from "./chunk-RTYRJAJO.js";
-import "./chunk-T6QANUS2.js";
+} from "./chunk-7DCZNZSP.js";
+import "./chunk-7LKCTUBY.js";
 import "./chunk-E6WMFMM2.js";
 import "./chunk-GEGUWQYT.js";
+import "./chunk-EIH2LNF4.js";
+import "./chunk-RDLF4NQC.js";
 import {
   isWizardRuntime
 } from "./chunk-77HWBSRH.js";
-import "./chunk-TMCNB4JH.js";
 import "./chunk-D6JKFJ6A.js";
-import "./chunk-EIH2LNF4.js";
-import "./chunk-RDLF4NQC.js";
+import "./chunk-COM6435C.js";
 import "./chunk-SQL56SEB.js";
 import "./chunk-V5VZPYMZ.js";
 import {

package/dist/stream-watchdog-CLRS2VMV.js

@@ -0,0 +1,59 @@
+// src/runtime/stream-watchdog.ts
+var DEFAULT_STREAM_THRESHOLD_MS = 9e4;
+var DEFAULT_STREAM_INTERVAL_MS = 15e3;
+function createStreamWatchdog(opts) {
+  const thresholdMs = opts.thresholdMs ?? DEFAULT_STREAM_THRESHOLD_MS;
+  const intervalMs = opts.intervalMs ?? DEFAULT_STREAM_INTERVAL_MS;
+  const now = opts.now ?? Date.now;
+  let timer = null;
+  let fired = false;
+  let lastHealthyAt = now();
+  let lastSeenEventAt = null;
+  function stop() {
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  function check() {
+    if (fired) return;
+    let state;
+    try {
+      state = opts.getState();
+    } catch {
+      return;
+    }
+    const t = now();
+    const eventAdvanced = state.lastEventAt !== null && state.lastEventAt !== lastSeenEventAt;
+    if (state.lastEventAt !== null) lastSeenEventAt = state.lastEventAt;
+    if (state.connected || eventAdvanced) {
+      lastHealthyAt = t;
+      return;
+    }
+    const disconnectedForMs = t - lastHealthyAt;
+    if (disconnectedForMs > thresholdMs) {
+      fired = true;
+      stop();
+      try {
+        opts.onUnhealthy({
+          disconnectedForMs,
+          reason: `SSE stream unhealthy for ${Math.round(disconnectedForMs / 1e3)}s (connected=false, no new events) \u2014 reconnect loop presumed wedged`
+        });
+      } catch {
+      }
+    }
+  }
+  return {
+    start() {
+      if (timer !== null || fired) return;
+      timer = setInterval(() => check(), intervalMs);
+      timer.unref?.();
+    },
+    stop
+  };
+}
+export {
+  DEFAULT_STREAM_INTERVAL_MS,
+  DEFAULT_STREAM_THRESHOLD_MS,
+  createStreamWatchdog
+};

package/dist/{tail-stream-HG4BKJOG.js → tail-stream-EIMLRRUP.js}

@@ -9,7 +9,7 @@ import {
   LOG_HEARTBEAT_INTERVAL_MS,
   UNARMED_FALLBACK_MS,
   createAdaptiveWatchdog
-} from "./chunk-CUOJHP2S.js";
+} from "./chunk-QDQGN5XP.js";
 import "./chunk-Z5LPNJQ6.js";
 import "./chunk-MIEI4PLB.js";
 import "./chunk-U5HHHRXA.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kojee-mcp",
-  "version": "0.7.5-staging.7",
+  "version": "0.7.5-staging.9",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/dist/chunk-TMCNB4JH.js

@@ -1,33 +0,0 @@
-// 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|codex-prompt-submit)$/;
-function isKojeeHookCommand(command) {
-  if (command.startsWith("npx -y kojee-mcp hook --type=")) return true;
-  return PINNED_HOOK_RE.test(command);
-}
-
-export {
-  npxHookCommand,
-  buildHookCommand,
-  isKojeeHookCommand
-};