kojee-mcp 0.6.0 → 0.7.1

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

@@ -1,8 +1,12 @@
+import {
+  VERSION
+} from "./chunk-5DHIUN73.js";
 import {
   buildCatchUpNote,
+  buildCondensedTandemRules,
   buildMonitorSpawn,
   buildReplyRecipe
-} from "./chunk-Q7T3WAST.js";
+} from "./chunk-SSW5AQSR.js";
 import {
   translateToolCallResult
 } from "./chunk-PPTKGWFF.js";
@@ -14,31 +18,12 @@ import {
   ListToolsRequestSchema,
   CallToolRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-
-// src/version.ts
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-var FALLBACK_VERSION = "0.0.0-unknown";
-function resolveVersion() {
-  try {
-    const here = path.dirname(fileURLToPath(import.meta.url));
-    const parsed = JSON.parse(
-      fs.readFileSync(path.join(here, "..", "package.json"), "utf8")
-    );
-    return typeof parsed?.version === "string" && parsed.version ? parsed.version : FALLBACK_VERSION;
-  } catch (err) {
-    process.stderr.write(
-      `kojee-mcp: could not resolve version from package.json, falling back to ${FALLBACK_VERSION}: ${String(err)}
-`
-    );
-    return FALLBACK_VERSION;
-  }
+function buildNonChannelInstructions(runtime) {
+  const skillPointer = runtime === "codex" ? " Before working in rooms, read the using-tandems skill at ~/.agents/skills/using-tandems/SKILL.md (if present)." : "";
+  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.\n\n" + buildCondensedTandemRules() + skillPointer;
 }
-var VERSION = resolveVersion();
-
-// src/server.ts
 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 +34,8 @@ 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;
+  const skillPointer = "\n\nTeamwork guide: read the using-tandems skill at ~/.claude/skills/using-tandems/SKILL.md (if present) before working in rooms.";
+  return localProxyRule + intro + monitorSection + listenSection + advice + skillPointer;
 }
 function tandemIdArg(args) {
   return typeof args["tandem_id"] === "string" ? args["tandem_id"] : null;
@@ -75,7 +61,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(adapter.runtime) }
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -100,7 +86,7 @@ async function startMcpServer(server) {
 }
 
 export {
-  VERSION,
+  buildNonChannelInstructions,
   buildChannelInstructions,
   executeToolCall,
   createMcpServer,

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-65KRRDHP.js → chunk-KPMD72FY.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) {
@@ -48,6 +84,16 @@ function escapeTomlString(s) {
 }
 var KOJEE_TABLE_HEADER = "[mcp_servers.kojee]";
 var KOJEE_ENV_TABLE_HEADER = "[mcp_servers.kojee.env]";
+function isPlaceholderWebhookUrl(url) {
+  return /^https?:\/\/YOUR-[A-Z0-9-]*\.local(?=[/:?#]|$)/i.test(url.trim());
+}
+function scrubPlaceholderWebhookEnv(envKeys) {
+  const urlEntry = envKeys.find(([k]) => k === "KOJEE_WEBHOOK_URL");
+  if (!urlEntry) return envKeys;
+  const raw = urlEntry[1].trim().replace(/^"(.*)"$/s, "$1").replace(/^'(.*)'$/s, "$1");
+  if (!isPlaceholderWebhookUrl(raw)) return envKeys;
+  return envKeys.filter(([k]) => k !== "KOJEE_WEBHOOK_URL" && k !== "KOJEE_WEBHOOK_SECRET");
+}
 function writeCodexConfig(inputs) {
   const configPath = inputs.configPath ?? defaultCodexConfigPath();
   const hooksPath = inputs.hooksPath ?? defaultCodexHooksPath();
@@ -62,18 +108,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 +155,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 +167,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, [
+  const envKeys = upsertKeyLines(scrubPlaceholderWebhookEnv(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)}"`])
@@ -244,6 +309,7 @@ export {
   defaultCodexHooksPath,
   buildCodexMcpServerTable,
   buildCodexStopHookBlock,
+  isPlaceholderWebhookUrl,
   writeCodexConfig,
   removeCodexConfig
 };

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-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-Q7T3WAST.js → chunk-SSW5AQSR.js}

@@ -15,6 +15,9 @@ function buildReplyRecipe(event) {
 function buildCatchUpNote() {
   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 buildCondensedTandemRules() {
+  return "Tandem ground rules: (1) catch up before you speak \u2014 fetch messages since your last cursor (cursors are per-Tandem); never answer from a stale view. (2) close every loop \u2014 taking / done (with evidence) / blocked, said out loud; silence is a bug on a team. (3) your seat_name IS your room identity \u2014 keep it stable across sessions and reconnects. (4) plan your wake path per task and set your wake filter deliberately (heads-down \u2192 mentions; waiting on one reply \u2192 listen; co-working \u2192 all), and tell the room your posture.";
+}
 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,13 +30,15 @@ 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 {
   buildMonitorSpawn,
   buildReplyRecipe,
   buildCatchUpNote,
+  buildCondensedTandemRules,
   buildMonitorNudge,
   buildWebhookReceiverNote,
   CODEX_LISTEN_CAP_MS,