kojee-mcp 0.7.5-staging.3 → 0.8.0-beta.0

package/README.md

@@ -11,7 +11,7 @@ There are three ways to connect Kojee to an MCP-capable agent:
 
 1. **Mobile, web & desktop (recommended for chat clients)** — paste the Kojee MCP URL into the app's "Add custom connector" dialog. The app handles OAuth login and consent. No local install. Works on Claude (web/desktop/iOS/Android) and ChatGPT (web/desktop/iOS/Android with Developer Mode enabled).
 2. **Claude Code / Codex / Cursor — the local stdio proxy.** Run `kojee-mcp` locally; it holds a `gw_` gateway token + ES256 keypair and signs every request with DPoP (RFC 9449). The runtime-aware [`init` wizard](#quick-start-claude-code--tandem) wires it into your harness and sets up the wake path so an idle agent is woken by Tandem messages between turns. **This is the recommended path for agentic runtimes** and the focus of this README.
-3. **OpenClaw / Hermes — native gateway runtimes.** On those runtimes kojee is registered as the agent's MCP server (so the agent can explore + call kojee tools), and Tandem is a first-class channel wired through the gateway (an in-gateway MCP wake injector on OpenClaw; a sidecar daemon + channel plugin on Hermes). See [Native gateway runtimes](#native-gateway-runtimes-openclaw--hermes).
+3. **OpenClaw / Hermes — native Tandem channel plugins.** On those runtimes Tandem is a first-class channel (peer to Telegram/Discord), wired through a plugin that wraps the same gateway client — **not** MCP. See [Native gateway runtimes](#native-gateway-runtimes-openclaw--hermes).
 
 ## Mobile, Web & Desktop (Recommended)
 
@@ -555,6 +555,106 @@ literal URL in the body; de-fang or split it; this is **not** an auth failure),
 `approval_required`, `not_paired`, `not_enrolled`, `bad_request`,
 `unauthorized`, `send_unavailable`, `send_failed` (raw text preserved).
 
+## Claude Co-Work (paste-one-command wake)
+
+**Claude Co-Work** is a cloud-sandbox harness with no MCP registration and no
+restart available mid-session, so it can't use the `init`-wired MCP proxy above.
+Instead, one line — generated from the Kojee dashboard and pasted into the
+agent's first turn — enrolls the sandbox and gets it streaming Tandem wakes
+immediately. This is a separate, parallel wake path from the MCP proxy; it does
+not use `startProxy` at all.
+
+### The pasted command
+
+```bash
+KOJEE_TOKEN=<token> npx -y kojee-mcp@<version> cowork --tandem <tandem_id> --url <broker>
+```
+
+The dashboard fills in `<token>`, `<version>` (the currently published
+`kojee-mcp` version), `<tandem_id>`, and `<broker>` when it generates this line
+for you. Flags:
+
+| Flag | Required | Description |
+|---|---|---|
+| `--tandem <id>` | yes, to launch | Tandem id to subscribe to. |
+| `--url <url>` | yes, to launch | Broker base URL — the token does not encode it. |
+| `--token <token>` | no (fallback) | Gateway token fallback. The canonical intake is the `KOJEE_TOKEN=` env prefix (keeps the secret off `/proc/<pid>/cmdline` and npm debug logs); `--token` costs a few seconds of argv exposure and is never forwarded to the worker process. |
+| `--force` | no | Override the clobber guard — replace a different token/broker already planted in `~/.kojee/config.json`. Without it, `cowork` refuses to overwrite a different credential (protects against an accidental paste evicting another sandbox's DPoP key — see the warning below). |
+| `--detach` | no | Host the worker as a detached background daemon (hidden `cowork-daemon` subcommand) instead of the default Monitor-hosted worker. |
+
+Run once, in the foreground, `cowork` enrolls the token into the paired DPoP
+slot, plants `~/.kojee/config.json` + `~/.kojee/keypair.json`, joins the
+tandem, and runs a startup barrier read — so a bad or revoked token, or a
+token that isn't a member of the tandem, fails loudly at paste time (nonzero
+exit, no Monitor recipe printed) instead of silently starting deaf.
+
+### What the agent does with the printed output
+
+On success `cowork` prints a recipe similar to:
+
+```
+[kojee cowork] enrolled + subscribed to tandem_abc123 (seat cowork-9f2a1c7b4e05).
+[kojee cowork] baseline cursor = 4821.  NOTE: this command contains a secret token — don't re-share this transcript.
+
+1) Arm the wake watcher ONCE (persistent Monitor):
+   Monitor(command=`npx kojee-mcp@<version> cowork-stream --tandem tandem_abc123`, persistent=true, description="kojee Tandem events")
+   ...
+```
+
+The agent should:
+
+1. **Arm the Monitor exactly once**, using the printed command — e.g.
+   `Monitor(command=\`npx kojee-mcp@<version> cowork-stream --tandem <tandem_id>\`, persistent=true, description="kojee Tandem events")`.
+   This spawns `cowork-stream`, which subscribes over SSE, writes the event
+   log, and fuses a tail of it onto its own stdout — each line is one Monitor
+   wake, carrying `msg=<id>` and `cursor=<n>`. If a watcher is already armed,
+   don't arm a second one.
+2. **Catch up once, right after arming** — `npx kojee-mcp@<version> messages <tandem_id> --since <baseline cursor>` — to cover the gap between paste and Monitor arm.
+3. **Reply via the `send` CLI, never MCP** (there are no MCP tools in this
+   session) — `npx kojee-mcp@<version> send <tandem_id> --body "..." --reply-to <msg>`.
+   One JSON envelope on stdout: `{ok:true, message_id, cursor}` (exit 0) or
+   `{ok:false, error, message}` (exit 1). Surface `content_blocked` /
+   `rate_limited` / `gateway_auth` distinctly — don't blind-retry.
+4. **Pull full, untruncated context on any gap** with the same `messages
+   --since <last cursor you saw>` command — e.g. after a cursor jump or a
+   `status=rotated` reset (event lines on the Monitor stream are truncated to
+   200 characters).
+
+Lines the worker prints that start with `[kojee]` (e.g. `[kojee] log=<path>`,
+`[kojee] WARNING: ...`, `[kojee] WORKER EXITED ...`) are telemetry, not Tandem
+messages — never reply to them.
+
+### Stopping it
+
+```bash
+npx kojee-mcp@<version> cowork stop --tandem <tandem_id>
+```
+
+Scans for live cowork workers on that tandem (omit `--tandem` to stop all live
+cowork workers on the box), SIGTERMs each, and cleans up its discovery file.
+
+**Merged (default) vs `--detach`:** by default the persistent Monitor *is* the
+host for the worker (`cowork-stream`), so if the wake stream dies the harness
+sees the Monitor's own process exit. `--detach` instead spawns a headless
+`cowork-daemon` child in the background and has the agent's Monitor tail its
+event-log file — use it only on a sandbox that won't keep a long-lived Monitor
+child alive.
+
+> **WARNING — mint a fresh token per sandbox.** Enrolling with `cowork` claims
+> the token's single DPoP key slot: the Kojee backend keeps **exactly one**
+> DPoP key per gateway token, and every enrollment **replaces** it. Paste the
+> *same* token into a second sandbox and the first sandbox's credential is
+> silently evicted — it goes offline. Mint a **fresh** cowork token per
+> sandbox from the dashboard; never reuse one across sandboxes.
+>
+> The pasted command also **contains a secret token in plaintext**. It
+> persists in the agent's transcript and shell history for as long as those
+> are retained — don't re-share the transcript, and treat the token as
+> compromised if it does leak out.
+
+Keep the `@<version>` pin — seat coherence relies on a feature that only
+exists in that version; do not drop it.
+
 ## Development
 
 Run tests:

package/dist/{chunk-67F67AQ6.js → chunk-3N4YYIOJ.js}

@@ -73,6 +73,33 @@ function readSessionDiscoveryByKey(key) {
     return null;
   }
 }
+function scanLiveCoworkWorkers(opts = {}) {
+  const dir = opts.dir ?? sessionDiscoveryDir();
+  const alive = opts.isAlive ?? isProcessAlive;
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.startsWith("cc-") || !name.endsWith(".json")) continue;
+    const filePath = path.join(dir, name);
+    let entry = null;
+    try {
+      entry = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (!entry || entry.origin !== "cowork") continue;
+    const pid = entry.proxyPid ?? entry.pid;
+    if (typeof pid !== "number" || !alive(pid)) continue;
+    const key = name.slice("cc-".length, -".json".length);
+    out.push({ key, entry, path: filePath, pid });
+  }
+  return out;
+}
 var DEFAULT_SWEEP_MIN_AGE_MS = 6e4;
 function isProcessAlive(pid) {
   try {
@@ -143,5 +170,6 @@ export {
   writeDiscoveryByKey,
   cleanupDiscoveryByKey,
   readSessionDiscoveryByKey,
+  scanLiveCoworkWorkers,
   sweepStaleDiscovery
 };

package/dist/{chunk-WBXU27BF.js → chunk-7J5CSXGS.js}

@@ -1,6 +1,6 @@
 import {
   readSessionDiscoveryByKey
-} from "./chunk-67F67AQ6.js";
+} from "./chunk-3N4YYIOJ.js";
 import {
   deriveDiscoveryKey,
   findClaudeAncestorPid

package/dist/{chunk-QNGMMBOD.js → chunk-BO52SILE.js}

@@ -49,7 +49,7 @@ import {
   CODEX_LISTEN_CAP_MS,
   buildCondensedTandemRules,
   buildWebhookReceiverNote
-} from "./chunk-FJUAMJHU.js";
+} from "./chunk-QLARIAUJ.js";
 
 // src/wizard/pair-slot.ts
 import fs from "fs";
@@ -135,8 +135,8 @@ function pairSlotFor(runtime, code) {
 
 // src/wizard/wizard.ts
 import crypto3 from "crypto";
-import fs7 from "fs";
-import path8 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/wizard/skill-install.ts
@@ -350,8 +350,7 @@ function writeWebhookSecretBothSides(opts) {
     ["KOJEE_RUNTIME", opts.runtime],
     ["KOJEE_WEBHOOK_URL", opts.webhookUrl],
     ["KOJEE_WEBHOOK_SECRET", secret],
-    ...opts.signatureEnv ?? [],
-    ...opts.daemonExtraEnv ?? []
+    ...opts.signatureEnv ?? []
   ];
   upsertEnvFile(opts.daemonEnvPath, daemonVars, {
     exportPrefix: true,
@@ -369,7 +368,7 @@ function writeWebhookSecretBothSides(opts) {
 }
 
 // src/wizard/installers/hermes.ts
-import path7 from "path";
+import path6 from "path";
 
 // src/wizard/plugin-payload.ts
 import fs4 from "fs";
@@ -508,100 +507,17 @@ function writeService(platform, spec) {
   return plan;
 }
 
-// src/wizard/capabilities/hermes-mcp-config.ts
-import fs6 from "fs";
-import path6 from "path";
-import { parseDocument, isMap } from "yaml";
-var HERMES_MCP_SERVER_NAME = "kojee";
-var HERMES_INSTANCE_KEY = "hermes-gateway";
-var HERMES_MCP_CONNECT_TIMEOUT_S = 120;
-function defaultHermesConfigPath(homeDir) {
-  return path6.join(homeDir, ".hermes", "config.yaml");
-}
-function buildKojeeEntry(binPath) {
-  return {
-    command: binPath,
-    args: [],
-    env: {
-      KOJEE_RUNTIME: "hermes",
-      KOJEE_INSTANCE: HERMES_INSTANCE_KEY,
-      // Vanilla tools-only proxy: NEVER a second webhook delivery (see header).
-      KOJEE_WEBHOOK_URL: ""
-    },
-    connect_timeout: HERMES_MCP_CONNECT_TIMEOUT_S
-  };
-}
-function resolveMode(filePath) {
-  try {
-    return fs6.statSync(filePath).mode & 511;
-  } catch {
-    return 384;
-  }
-}
-function atomicWrite(filePath, content, mode) {
-  fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
-  const tmp = `${filePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  fs6.writeFileSync(tmp, content, { mode });
-  fs6.renameSync(tmp, filePath);
-}
-function backupSuffix(now) {
-  return (now ? now() : /* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-}
-function writeHermesMcpConfig(configPath, opts) {
-  let raw = null;
-  try {
-    raw = fs6.readFileSync(configPath, "utf8");
-  } catch {
-    raw = null;
-  }
-  let backedUp;
-  let doc = parseDocument("");
-  if (raw !== null && raw.trim() !== "") {
-    const parsed = parseDocument(raw);
-    if (parsed.errors.length > 0) {
-      backedUp = `${configPath}.corrupt-${backupSuffix(opts.now)}`;
-      fs6.copyFileSync(configPath, backedUp);
-    } else {
-      doc = parsed;
-    }
-  }
-  if (doc.hasIn(["mcp_servers"]) && !isMap(doc.getIn(["mcp_servers"], true))) {
-    doc.deleteIn(["mcp_servers"]);
-  }
-  doc.setIn(["mcp_servers", HERMES_MCP_SERVER_NAME], buildKojeeEntry(opts.binPath));
-  atomicWrite(configPath, String(doc), resolveMode(configPath));
-  return { configPath, ...backedUp ? { backedUp } : {} };
-}
-function removeHermesMcpServer(configPath) {
-  let raw;
-  try {
-    raw = fs6.readFileSync(configPath, "utf8");
-  } catch {
-    return false;
-  }
-  const doc = parseDocument(raw);
-  if (doc.errors.length > 0) return false;
-  if (!doc.hasIn(["mcp_servers", HERMES_MCP_SERVER_NAME])) return false;
-  doc.deleteIn(["mcp_servers", HERMES_MCP_SERVER_NAME]);
-  const servers = doc.getIn(["mcp_servers"], true);
-  if (isMap(servers) && servers.items.length === 0) {
-    doc.deleteIn(["mcp_servers"]);
-  }
-  atomicWrite(configPath, String(doc), resolveMode(configPath));
-  return true;
-}
-
 // src/wizard/installers/hermes.ts
 function installHermes(inp) {
-  const daemonEnv = path7.join(inp.homeDir, ".kojee", "hermes.env");
-  const adapterEnv = path7.join(inp.homeDir, ".hermes", ".env");
-  const pluginDir = path7.join(inp.homeDir, ".hermes", "plugins", "kojee-tandem");
+  const daemonEnv = path6.join(inp.homeDir, ".kojee", "hermes.env");
+  const adapterEnv = path6.join(inp.homeDir, ".hermes", ".env");
+  const pluginDir = path6.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 ${path7.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 ${path6.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
@@ -613,14 +529,11 @@ function installHermes(inp) {
     adapterEnvPath: adapterEnv,
     webhookUrl: inp.webhookUrl,
     runtime: "hermes",
-    daemonExtraEnv: [["KOJEE_INSTANCE", HERMES_INSTANCE_KEY]],
     ...inp.mcpDir ? { mcpDir: inp.mcpDir } : {},
     ...inp.allowAllUsers ? { allowAllUsers: true } : {},
     ...inp.signatureEnv && inp.signatureEnv.length > 0 ? { signatureEnv: inp.signatureEnv } : {},
     ...inp.webhookSecret ? { existingSecret: inp.webhookSecret } : {}
   });
-  const hermesConfig = defaultHermesConfigPath(inp.homeDir);
-  const mcp = writeHermesMcpConfig(hermesConfig, { binPath: inp.binPath });
   const staged = inp.skipPayload ? [] : installBundledPayload({
     runtime: "hermes",
     baseDir: inp.payloadBaseDir,
@@ -639,8 +552,6 @@ function installHermes(inp) {
     `  secret:      ${sec.reused ? "reused existing" : "generated"} (matched on daemon + adapter env)`,
     `  daemon env:  ${daemonEnv}`,
     `  adapter env: ${adapterEnv}`,
-    `  mcp config:  ${hermesConfig} (mcp_servers.kojee \u2014 agent explores kojee via mcp_kojee_*)`,
-    ...mcp.backedUp ? [`  NOTE: prior ${hermesConfig} was unparseable; backed up to ${mcp.backedUp} before writing.`] : [],
     inp.skipPayload ? `  plugin:      SKIPPED \u2014 no bundled payload (run \`npm run build\` to stage dist/plugins/hermes)` : `  plugin:      ${pluginDir} (${staged.length} files)`,
     svc.supported ? `  service:     ${svc.unitPath}` : `  service:     manual \u2014 ${svc.note ?? "unsupported platform"}`,
     // NB: the "Receiver contract" section is intentionally NOT printed here.
@@ -650,13 +561,9 @@ function installHermes(inp) {
     "",
     "Next:",
     `  - start the daemon service:  ${svc.activateCmd}`,
-    "  - reload the Hermes gateway to load the channel plugin AND the kojee MCP server:",
-    "      systemctl --user restart hermes-gateway   (or: hermes gateway restart, or /reload-mcp)",
-    "  - verify the MCP registered:  hermes mcp test kojee   (tools appear to the agent as mcp_kojee_*)",
-    "  - the agent can now join from its own tools:  mcp_kojee_tandem_join <tandem_id>",
-    "  - verify the daemon/channel:  kojee-mcp doctor",
-    "  - if tools don't register: ensure Hermes was installed with the MCP extra",
-    '      (cd ~/.hermes/hermes-agent && uv pip install -e ".[mcp]") and re-check connect_timeout.'
+    "  - reload the Hermes gateway to load the plugin:  systemctl --user restart hermes-gateway (or: hermes gateway restart)",
+    "  - join a tandem once:  tandem_join <tandem_id>",
+    "  - verify:  kojee-mcp doctor"
   ];
   return {
     runtime: "hermes",
@@ -1030,7 +937,7 @@ function buildDaemonEnvBlock(runtime, wh, envFile) {
   return lines;
 }
 function distDir() {
-  return path8.dirname(fileURLToPath2(import.meta.url));
+  return path7.dirname(fileURLToPath2(import.meta.url));
 }
 function resolveBinPath() {
   const entry = process.argv[1];
@@ -1048,10 +955,7 @@ function configureHermes(opts) {
   opts = effectiveOpts;
   const lines = [];
   lines.push(`Configured runtime: ${runtime}`);
-  lines.push(
-    "Wake mode: webhook sink (daemon-consumed). ALSO registers kojee as the Hermes agent's",
-    "MCP server (mcp_servers.kojee) so the agent can explore kojee tools. NO hooks written."
-  );
+  lines.push("Wake mode: webhook sink (daemon-consumed). NO MCP-config file, NO hooks written.");
   lines.push("");
   if (!suppliedUrl) {
     lines.push(
@@ -1094,7 +998,7 @@ function configureHermes(opts) {
       return { runtime, output: lines.join("\n"), exitCode: install.exitCode };
     }
     recordRuntime(runtime);
-    const envFile = path8.join(home, ".kojee", "hermes.env");
+    const envFile = path7.join(home, ".kojee", "hermes.env");
     lines.push(...buildDaemonEnvBlock(runtime, wh, envFile));
     lines.push("");
     lines.push(install.output);
@@ -1116,7 +1020,7 @@ function configureHermes(opts) {
   return { runtime, output: lines.join("\n"), exitCode: 0 };
 }
 function openclawConfigPath(opts) {
-  return opts.openclawConfigPath ?? path8.join(kojeeHomeDir(), ".openclaw", "openclaw.json");
+  return opts.openclawConfigPath ?? path7.join(kojeeHomeDir(), ".openclaw", "openclaw.json");
 }
 function configureOpenclaw(opts) {
   const runtime = "openclaw";
@@ -1158,15 +1062,11 @@ async function runWizardUninstall(runtime, opts) {
     const un = uninstallOpenclaw({ openclawConfigPath: openclawConfigPath(opts) });
     lines.push(un.output);
   } else {
-    const hermesConfig = defaultHermesConfigPath(kojeeHomeDir());
-    const removedMcp = removeHermesMcpServer(hermesConfig);
-    lines.push(
-      removedMcp ? `  removed mcp_servers.kojee from ${hermesConfig} (operator config preserved)` : `  no mcp_servers.kojee in ${hermesConfig} \u2014 nothing to remove`
-    );
-    lines.push("  (stop the daemon service + reload the gateway to disable the webhook wake path.)");
-    const envPath = path8.join(kojeeHomeDir(), ".kojee", `${effective}.env`);
+    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 = path7.join(kojeeHomeDir(), ".kojee", `${effective}.env`);
     try {
-      fs7.unlinkSync(envPath);
+      fs6.unlinkSync(envPath);
       lines.push(`  removed ${envPath}`);
     } catch {
     }
@@ -1209,11 +1109,7 @@ registerBuiltinInstaller(
     "webhook",
     "webhook-secret-both-sides",
     "plugin-payload-copy",
-    "service-install",
-    // kojee registered as the Hermes agent's MCP server (mcp_servers.kojee in
-    // ~/.hermes/config.yaml) so the agent can EXPLORE + call kojee tools —
-    // additive to the channel plugin, does not change the webhook wake path.
-    "mcp-config-write"
+    "service-install"
   ],
   (o) => configureHermes(o)
 );

package/dist/{chunk-TCWIXG5C.js → chunk-D5VPUCPY.js}

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

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

@@ -82,6 +82,13 @@ async function startEventStream(opts) {
     headersTimeout: UNDICI_DEFAULT_BODY_TIMEOUT_MS
   });
   const cursors = /* @__PURE__ */ new Map();
+  if (opts.initialCursors) {
+    for (const [tandemId, cursor] of Object.entries(opts.initialCursors)) {
+      if (typeof cursor === "number" && Number.isFinite(cursor)) {
+        cursors.set(tandemId, cursor);
+      }
+    }
+  }
   let currentController = new AbortController();
   let connectGeneration = 0;
   const state = {
@@ -273,10 +280,11 @@ async function consumeSse(body, opts, controller, state, onCursor) {
                 console.error("[event-stream] event-log append failed:", err);
               }
             }
-            if (opts.adapter.supportsChannels) {
+            const channelServer = opts.server;
+            if (opts.adapter.supportsChannels && channelServer) {
               try {
                 const channel = opts.adapter.formatTandemEvent(parsed);
-                await opts.server.notification({
+                await channelServer.notification({
                   method: "notifications/claude/channel",
                   params: channel
                 });

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

@@ -1,7 +1,7 @@
 import {
   readSessionDiscoveryByKey,
   sessionDiscoveryDir
-} from "./chunk-67F67AQ6.js";
+} from "./chunk-3N4YYIOJ.js";
 import {
   secureFile
 } from "./chunk-U5HHHRXA.js";

package/dist/chunk-JRCHS6CP.js

@@ -0,0 +1,14 @@
+// src/adapters/unknown.ts
+var unknownAdapter = {
+  runtime: "unknown",
+  supportsChannels: false,
+  formatTandemEvent() {
+    throw new Error(
+      "unknownAdapter.formatTandemEvent() is unreachable \u2014 caller should gate on supportsChannels"
+    );
+  }
+};
+
+export {
+  unknownAdapter
+};

package/dist/chunk-NMHM6SII.js

@@ -0,0 +1,118 @@
+import {
+  createPairedGateway
+} from "./chunk-VGZ4M3FP.js";
+import {
+  classifySendFailure,
+  ensureJoined,
+  sendFailure
+} from "./chunk-WZP7HXXN.js";
+import {
+  translateToolCallResult
+} from "./chunk-PPTKGWFF.js";
+
+// src/tandem/messages-cli.ts
+import os from "os";
+import path from "path";
+function parseMessagesRequest(input) {
+  const tandemId = input.tandem_id;
+  if (typeof tandemId !== "string" || tandemId.length === 0) {
+    return sendFailure("bad_request", "tandem_id is required and must be a non-empty string");
+  }
+  const request = { tandem_id: tandemId };
+  if (input.since !== void 0) {
+    if (typeof input.since !== "string" || input.since.length === 0) {
+      return sendFailure("bad_request", "--since must be a non-empty cursor when present");
+    }
+    request.since = input.since;
+  }
+  if (input.limit !== void 0) {
+    const raw = String(input.limit);
+    if (!/^\d+$/.test(raw)) {
+      return sendFailure("bad_request", "--limit must be a positive integer");
+    }
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+      return sendFailure("bad_request", "--limit must be a positive integer");
+    }
+    request.limit = n;
+  }
+  return { ok: true, request };
+}
+function deriveMaxCursor(messages) {
+  let max = null;
+  for (const m of messages) {
+    if (m !== null && typeof m === "object") {
+      const c = m["cursor"];
+      if (typeof c === "number" && (max === null || c > max)) max = c;
+    }
+  }
+  return max;
+}
+async function executeRead(gateway, request) {
+  const sinceArg = request.since !== void 0 ? /^\d+$/.test(request.since) ? Number(request.since) : request.since : void 0;
+  const args = {
+    tandem_id: request.tandem_id,
+    ...sinceArg !== void 0 ? { since: sinceArg } : {},
+    ...request.limit !== void 0 ? { limit: request.limit } : {}
+  };
+  let result;
+  try {
+    result = await gateway.sendRpc("tools/call", {
+      name: "tandem_messages",
+      arguments: args
+    });
+  } catch (err) {
+    return classifySendFailure(
+      `tandem_messages failed: ${err?.message ?? String(err)}`
+    );
+  }
+  const translated = translateToolCallResult(result);
+  const text = (translated.content ?? []).map((c) => typeof c?.text === "string" ? c.text : "").filter(Boolean).join("\n");
+  if (translated.isError) {
+    return classifySendFailure(text || "tandem_messages returned an error with no text");
+  }
+  let messages = [];
+  let cursor = null;
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) {
+      messages = parsed;
+    } else if (parsed !== null && typeof parsed === "object") {
+      const obj = parsed;
+      if (Array.isArray(obj["messages"])) messages = obj["messages"];
+      const rawCursor = obj["cursor"];
+      if (typeof rawCursor === "number") cursor = rawCursor;
+    }
+    if (cursor === null) cursor = deriveMaxCursor(messages);
+  } catch {
+  }
+  return { ok: true, tandem_id: request.tandem_id, messages, cursor, text };
+}
+async function runMessagesCli(args, deps = {}) {
+  const parsed = parseMessagesRequest({
+    tandem_id: args.tandemId,
+    ...args.since !== void 0 ? { since: args.since } : {},
+    ...args.limit !== void 0 ? { limit: args.limit } : {}
+  });
+  if (!parsed.ok) {
+    return { exitCode: 1, envelope: parsed };
+  }
+  const kojeeDir = args.kojeeDir ?? path.join(os.homedir(), ".kojee");
+  const createGateway = deps.createGateway ?? createPairedGateway;
+  const resolution = await createGateway(kojeeDir);
+  if (!resolution.ok) {
+    return { exitCode: 1, envelope: resolution };
+  }
+  const guard = await ensureJoined(resolution.gateway, parsed.request.tandem_id);
+  if (!guard.ok) {
+    return { exitCode: 1, envelope: guard.failure };
+  }
+  const envelope = await executeRead(resolution.gateway, parsed.request);
+  return { exitCode: envelope.ok ? 0 : 1, envelope };
+}
+
+export {
+  parseMessagesRequest,
+  executeRead,
+  runMessagesCli
+};

package/dist/{chunk-A4IOKD4Z.js → chunk-P2R3KWYK.js}

@@ -6,7 +6,7 @@ import {
   buildCondensedTandemRules,
   buildMonitorSpawn,
   buildReplyRecipe
-} from "./chunk-FJUAMJHU.js";
+} from "./chunk-QLARIAUJ.js";
 import {
   translateToolCallResult
 } from "./chunk-PPTKGWFF.js";

package/dist/{chunk-FJUAMJHU.js → chunk-QLARIAUJ.js}

@@ -1,10 +1,18 @@
 // src/tandem/recipe.ts
 var SEND_BODY_PARAM = "body";
+var KOJEE_PACKAGE = "kojee-mcp";
+var MONITOR_DESCRIPTION = "kojee Tandem events";
+function pinnedPackage(version) {
+  return `${KOJEE_PACKAGE}@${version}`;
+}
+function buildMonitorSpawnFor(command) {
+  return `Monitor(command=\`${command}\`, persistent=true, description="${MONITOR_DESCRIPTION}")`;
+}
 function buildMonitorCommand(logPath) {
-  return `npx kojee-mcp tail "${logPath}"`;
+  return `npx ${KOJEE_PACKAGE} tail "${logPath}"`;
 }
 function buildMonitorSpawn(logPath) {
-  return `Monitor(command=\`${buildMonitorCommand(logPath)}\`, persistent=true, description="kojee Tandem events")`;
+  return buildMonitorSpawnFor(buildMonitorCommand(logPath));
 }
 function buildReplyRecipe(event) {
   if (event) {
@@ -21,6 +29,18 @@ function buildCondensedTandemRules() {
 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()}.`;
 }
+function buildCoworkMonitorSpawn(tandemId, version) {
+  return buildMonitorSpawnFor(
+    `npx ${pinnedPackage(version)} cowork-stream --tandem ${tandemId}`
+  );
+}
+function buildCliReplyRecipe(tandemId, version) {
+  return `npx ${pinnedPackage(version)} send ${tandemId} --${SEND_BODY_PARAM} "..." --reply-to <msg>`;
+}
+function buildCliCatchUpNote(tandemId, version, sinceCursor) {
+  const since = sinceCursor !== void 0 ? String(sinceCursor) : "<cursor>";
+  return `npx ${pinnedPackage(version)} messages ${tandemId} --since ${since}`;
+}
 var WEBHOOK_BODY_SHAPE = "{ type, id, tandem_id, cursor, time, from{ member_id, principal, agent_id?, session_id?, displayname }, kind, content{ body, format? }, mentions?, reply_to?, severity? }";
 function buildWebhookReceiverNote(sig) {
   const header = sig?.header ?? "X-Kojee-Signature";
@@ -32,11 +52,15 @@ var CODEX_LISTEN_CAP_MS = 8e3;
 var CODEX_WAKE_BELL = "[kojee] Tandem events may be pending. Call tandem_pending now and drain each room it lists (tandem_messages(id, since=cursor)), then reply in the room with a normal message (kind=message \u2014 never status). If it returns none for you, ignore this.";
 
 export {
+  pinnedPackage,
   buildMonitorSpawn,
   buildReplyRecipe,
   buildCatchUpNote,
   buildCondensedTandemRules,
   buildMonitorNudge,
+  buildCoworkMonitorSpawn,
+  buildCliReplyRecipe,
+  buildCliCatchUpNote,
   buildWebhookReceiverNote,
   CODEX_LISTEN_CAP_MS,
   CODEX_WAKE_BELL