kojee-mcp 0.5.8 → 0.5.9

package/README.md

@@ -1,11 +1,17 @@
 # kojee-mcp
 
-> **First time using Kojee Tandem in Claude Code?** See [docs/getting-started-tandem.md](docs/getting-started-tandem.md) for the 3-command setup + verification walkthrough.
+> Published version **0.5.8**.
+>
+> **First time using Kojee Tandem in Claude Code?** Three commands get you from
+> zero to a woken agent — see the [Quick start (Claude Code + Tandem)](#quick-start-claude-code--tandem)
+> below, or [docs/getting-started-tandem.md](docs/getting-started-tandem.md) for
+> the full walkthrough.
 
-There are two ways to connect Kojee to an MCP-capable agent:
+There are three ways to connect Kojee to an MCP-capable agent:
 
-1. **Mobile, web & desktop (recommended)** — 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. **Power user / local proxy with DPoP** — run this stdio proxy locally with a gateway token. Strongest wire-level security (DPoP proof-of-possession, RFC 9449), but requires Node and a token you generate manually in the Kojee dashboard.
+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 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)
 
@@ -30,92 +36,156 @@ The OAuth login + consent flow takes care of everything — no token paste, no c
 | Discovery | `https://api.kojee.ai/.well-known/oauth-protected-resource` |
 | Scopes | `mcp:tools`, `mcp:read` |
 
-## Power User: Local Proxy with DPoP
+## Quick start (Claude Code + Tandem)
 
-The `kojee-mcp` stdio proxy holds a `gw_` gateway token + ES256 keypair locally and signs every request with DPoP (RFC 9449). This survives token-in-transit theft (TLS-terminating proxy logs, etc.) — strictly stronger wire-level posture than bearer-only OAuth, but requires a long-lived token.
+From zero to a woken agent — the recommended path for Claude Code:
 
-### Claude Code / Claude Desktop
+```bash
+# 1. Pair this machine + configure your runtime in one guided step.
+#    Run it in a terminal (TTY): it walks you through broker URL → auth
+#    (paste a token OR enter a pair code) → wake setup. Defaults to claude-code.
+npx -y kojee-mcp@latest init
 
-```json
-{
-  "mcpServers": {
-    "kojee": {
-      "command": "npx",
-      "args": ["kojee-mcp", "--token", "YOUR_TOKEN", "--url", "https://kojee.ai"]
-    }
-  }
-}
+# 2. Confirm the wake path is healthy.
+npx -y kojee-mcp@latest doctor
+
+# 3. Start a fresh Claude Code session.
+claude
 ```
 
-### Generic MCP Client
+`init` is a **guided wizard** when stdin is a TTY (and no `--runtime` flag is
+given). It prompts for, in order:
 
-Any MCP client that supports stdio transports can use kojee-mcp:
+1. **Runtime** — `claude-code` (default), `hermes`, `openclaw`, or `codex`.
+2. **Broker URL** — Enter accepts the default `https://rosie-staging.kojee.net`.
+3. **Auth** — paste an existing gateway token (**token mode**), or enter a
+   **pair code** from the dashboard (**pair mode** — runs the DPoP enrollment and
+   writes `~/.kojee/config.json` for you, so you don't run `pair` separately).
+4. **Webhook receiver** (codex/hermes/openclaw only) — Enter to skip and set it up later.
 
-```bash
-npx kojee-mcp --token gw_abc123... --url https://kojee.ai
-```
+For non-interactive / CI use, pass flags instead (see
+[Non-interactive `init`](#non-interactive-init-flags--ci) below). Either way the
+final wake check is `kojee-mcp doctor`.
 
-Or install globally:
+> **Already have a pair code and just want one command?**
+> `npx -y kojee-mcp@latest init --pair-code YOUR-CODE` pairs **and** configures
+> claude-code in a single non-interactive step (URL defaults to
+> `https://rosie-staging.kojee.net`; override with `--url`).
 
-```bash
-npm install -g kojee-mcp
-kojee-mcp --token gw_abc123... --url https://kojee.ai
-```
+### What `init` writes (claude-code)
 
-## CLI Flags
+It adds the MCP entry to **every detected Claude installation**:
 
-| Flag | Required | Default | Description |
-|------|----------|---------|-------------|
-| `--token` | yes | -- | Your Kojee gateway token (starts with `gw_`) |
-| `--url` | yes | -- | Kojee broker URL (e.g. `https://kojee.ai`) |
-| `--keystore-path` | no | `~/.kojee/keypair.json` | Path for DPoP keypair storage |
+- `~/.claude.json` → MCP server entry (terminal `claude` CLI **and** Claude.app).
+- `~/Library/Application Support/Claude/claude_desktop_config.json` (Claude.app on
+  macOS — Windows / Linux paths in the spec) if present.
+- `~/.claude/settings.json` → the **Stop + UserPromptSubmit hooks** (terminal CLI
+  only; Claude.app agent mode reads MCP servers but not hooks).
+
+The canonical MCP entry includes `env.KOJEE_RUNTIME=claude-code` so the proxy
+identifies as Claude Code even when the desktop app strips environment variables
+from MCP subprocesses. In **token mode** the entry launches the proxy with
+`--token`/`--url` (it enrolls its own per-token keystore); in **pair mode** the
+args stay `["kojee-mcp"]` and the proxy reads `~/.kojee/config.json` (mode 0600).
+Existing entries (other MCP servers, other hooks like babysitter wrappers) are
+preserved.
 
-## Pair Mode (Tandem)
+**Important for Claude.app users:** existing agent-mode sessions snapshot the MCP
+config at creation time and won't pick up changes from `init`. Start a NEW session
+(not a resumed one) to use the updated kojee config.
 
-If your token comes from the Kojee Tandem web wizard (a "pair code"), you can persist it for future runs:
+To remove kojee from your runtime (runtime-aware — uses the recorded runtime):
 
 ```bash
-# One-time setup:
-npx kojee-mcp pair ABCD-1234 --url https://rosie-server.kojee.net
-npx kojee-mcp init                              # adds the MCP entry to EVERY detected Claude installation
+npx kojee-mcp init --uninstall
 ```
 
-`init` writes to both `~/.claude.json` (terminal `claude` CLI) and `~/Library/Application Support/Claude/claude_desktop_config.json` (Claude.app on macOS — Windows / Linux paths in the spec) if either exists. The canonical MCP entry includes `env.KOJEE_RUNTIME=claude-code` so the proxy correctly identifies as Claude Code even when the desktop app strips environment variables from MCP subprocesses.
+### Verify the wake path — `kojee-mcp doctor`
 
-**Important for Claude.app users:** existing agent-mode sessions snapshot the MCP config at creation time and won't pick up changes from `init`. Start a NEW session (not a resumed one) to use the updated kojee config.
+`doctor` is the one-command health check for the whole wake path. It derives the
+same discovery key the hooks use, finds the running proxy, and walks every link
+in order — paired config, proxy process alive, hook-server `/health` + `/status`,
+the **SSE stream** (connected? heartbeat age? subscribed tandem count?), the
+event log, and whether a **Monitor** is reading it — then prints a one-screen
+`HEALTHY` / `DEGRADED` / `BROKEN` verdict **plus the exact wake recipe to spawn**.
+It's runtime-aware (a codex install gets the codex webhook-sink + stop-hook
+checks). Exit code is non-zero only when the verdict is `BROKEN`.
 
-Subsequent runs of `claude` will find kojee automatically. The proxy writes credentials to `~/.kojee/config.json` (mode 0600). Existing `--token` users are unaffected.
+```bash
+npx kojee-mcp doctor
+```
+
+### CLI command reference
+
+| Command | What it does |
+|---|---|
+| `kojee-mcp` *(default, no subcommand)* | Run the stdio MCP proxy. Token mode (`--token`/`--url`) or paired mode (reads `~/.kojee/config.json`). |
+| `kojee-mcp init` | Runtime-aware setup wizard (guided in a TTY; flag-driven in CI). |
+| `kojee-mcp pair <code> --url <broker>` | Pair this machine (DPoP enroll + write `~/.kojee/config.json`). |
+| `kojee-mcp doctor` | Diagnose the wake path and print the exact wake recipe. |
+| `kojee-mcp install-hooks` | Install/remove (`--uninstall`) just the Claude Code Stop + UserPromptSubmit hooks. |
+| `kojee-mcp send <tandem_id> --body <text>` | Send a Tandem message from outside the proxy using paired creds (see [Local Send Control Surface](#local-send-control-surface-054)). |
+| `kojee-mcp tail <path>` | Portable line-streamer (`tail -F` replacement) — the Monitor command on every platform. |
+| `kojee-mcp hook --type <stop\|user-prompt-submit\|codex-stop>` | Internal hook entry point (Claude Code / Codex invoke it; you don't run it directly). |
+
+## Standalone pairing — `kojee-mcp pair`
+
+The guided `init` pairs for you, but you can also pair as a separate step (then
+run `init` to configure your runtime). Use this when scripting, or to re-pair
+after a code expires:
 
-To remove kojee from Claude:
 ```bash
-npx kojee-mcp init --uninstall
+npx kojee-mcp pair ABCD-1234 --url https://rosie-staging.kojee.net
 ```
 
+This runs the DPoP enrollment and persists credentials to `~/.kojee/config.json`
+(mode 0600) + the keypair to `~/.kojee/keypair.json`. Subsequent runs of the
+proxy find them automatically. `--keystore-path` overrides the keypair location.
+
 ## Runtime-aware setup wizard (`init` selects the runtime)
 
 `kojee-mcp init` is a runtime-aware wizard. The runtime selector is its core — one
-proxy adapts to four harnesses. Bare `init` with no flag and no TTY still defaults
-to `claude-code` (unchanged), so existing setups have zero regression.
+proxy adapts to four harnesses (`claude-code | hermes | openclaw | codex`). Bare
+`init` with no flag and no TTY still defaults to `claude-code` (unchanged), so
+existing setups have zero regression.
+
+### Non-interactive `init` (flags / CI)
+
+Passing `--runtime` makes `init` non-interactive (the contract for CI). Auth and
+webhook details come from flags:
 
 ```bash
-npx kojee-mcp init                       # interactive (prompts when stdin is a TTY)
-npx kojee-mcp init --runtime claude-code # Claude Code (default): MCP entry + Stop/UserPromptSubmit hooks
+npx kojee-mcp init                       # interactive guided wizard (TTY, no --runtime)
+npx kojee-mcp init --pair-code ABCD-1234 # pair + configure claude-code in one shot
+npx kojee-mcp init --runtime claude-code --token gw_abc... --url https://rosie-staging.kojee.net
+                                         # claude-code, token mode (no pair step)
 npx kojee-mcp init --runtime codex --webhook-url https://your-receiver/kojee
                                          # Codex: writes ~/.codex/config.toml + a codex-stop hook
-npx kojee-mcp init --runtime hermes --webhook-url https://your-receiver/kojee
+npx kojee-mcp init --runtime hermes  --webhook-url https://your-receiver/kojee
 npx kojee-mcp init --runtime openclaw --webhook-url https://your-receiver/kojee
                                          # daemon runtimes: print/record the webhook-sink env to export
 ```
 
+Auth flags (all runtimes): `--token <gw_…>` + `--url <broker>` (token mode), or
+`--pair-code <code>` (runs the pair flow up front, then configures). `--url`
+defaults to `https://rosie-staging.kojee.net`. A non-interactive `init` with **no**
+credential at all (no paired config, no `--token`/`--pair-code`) errors and tells
+you to pair first.
+
+Per-runtime config-path / hooks-path overrides: `--config-path`, `--hooks-path`.
+
 - **codex** — writes `[mcp_servers.kojee]` (with `env.KOJEE_RUNTIME="codex"` + the
   webhook env) into `~/.codex/config.toml`, and a `codex-stop` Stop hook into
   `~/.codex/hooks.json`. A `KOJEE_WEBHOOK_SECRET` is generated if you don't supply
   one. Codex has no Claude-style channel injection, so its wake is the **webhook
   sink + a stop-hook fast PEEK + a model-chosen bounded `tandem_listen` (cap 8s,
   never a blanket long-poll)**. See `docs/RUNTIMES.md`.
-- **hermes / openclaw** — run the proxy as a daemon and consume the webhook sink;
-  the wizard writes no config/hooks of ours, validates the webhook env, and prints
-  + records the env to export (secret redacted).
+- **hermes / openclaw** — these runtimes have **native channel plugins** (see
+  [Native gateway runtimes](#native-gateway-runtimes-openclaw--hermes)). When you
+  instead run the proxy as a **daemon** feeding a webhook receiver, `init --runtime
+  hermes|openclaw` writes no MCP-config/hooks of ours, validates the webhook env,
+  and prints + records the env to export (secret redacted) into a source-able
+  `~/.kojee/<runtime>.env`.
 
 `kojee-mcp init --uninstall` is runtime-aware (uses the recorded runtime when
 `--runtime` is omitted). `kojee-mcp doctor` is runtime-aware too.
@@ -124,6 +194,75 @@ npx kojee-mcp init --runtime openclaw --webhook-url https://your-receiver/kojee
 > adapter + wizard are unit/integration-tested only. Live-Codex end-to-end is
 > unverified — the wizard prints this note after a `--runtime codex` install.
 
+## Direct proxy invocation (advanced / generic MCP clients)
+
+Most users let `init` write the launch command. If you manage the MCP config by
+hand, the proxy runs in **token mode** with `--token` + `--url`:
+
+```json
+{
+  "mcpServers": {
+    "kojee": {
+      "command": "npx",
+      "args": ["kojee-mcp", "--token", "YOUR_TOKEN", "--url", "https://rosie-staging.kojee.net"]
+    }
+  }
+}
+```
+
+Any stdio-capable MCP client works the same way:
+
+```bash
+npx kojee-mcp --token gw_abc123... --url https://rosie-staging.kojee.net
+# or install globally:
+npm install -g kojee-mcp
+kojee-mcp --token gw_abc123... --url https://rosie-staging.kojee.net
+```
+
+Run bare (no `--token`) and the proxy uses **paired** credentials from
+`~/.kojee/config.json` — that's what the claude-code MCP entry does in pair mode.
+
+### Proxy CLI flags (default command)
+
+| Flag | Required | Default | Description |
+|------|----------|---------|-------------|
+| `--token` | token mode only | — | Your Kojee gateway token (starts with `gw_`). Omit to use paired credentials. |
+| `--url` | with `--token` | paired `broker_url` | Kojee broker URL (e.g. `https://rosie-staging.kojee.net`). |
+| `--keystore-path` | no | per-token path under `~/.kojee/` | Path for DPoP keypair storage. |
+
+## How each runtime reaches Tandem
+
+| Runtime | How it connects | Wake path |
+|---|---|---|
+| **claude-code** | MCP stdio proxy (this package), wired by `init` | CC Channels (preview) · **Monitor** (`tail` of the event log) · **Stop/UserPromptSubmit hooks** — see below |
+| **cursor** & other MCP clients | MCP stdio proxy | poll/`tandem_listen`; no CC channel injection |
+| **codex** | MCP stdio proxy + `~/.codex` config/hook | webhook sink + stop-hook peek + bounded `tandem_listen` (cap 8s) |
+| **openclaw** | **native channel plugin** (not MCP) | OpenClaw's own routing/sessions wake the agent on each Tandem event |
+| **hermes** | **native channel plugin** (sidecar daemon + webhook) | Hermes gateway wakes the agent like a Telegram DM |
+
+## Native gateway runtimes (OpenClaw + Hermes)
+
+On OpenClaw and Hermes, Tandem is a **native channel** — peer to Telegram/Discord
+— not an MCP server. A plugin makes the agent *present* in its tandems whenever
+the gateway is up: it wakes on Tandem messages through the runtime's own
+routing/sessions and replies on the same channel. Both plugins wrap the **same**
+gateway client + DPoP auth + SSE event stream this proxy uses (`kojee-mcp/lib`);
+nothing is forked.
+
+- **OpenClaw** — `integrations/openclaw-plugin/` (`openclaw-channel-kojee-tandem`).
+  Imports `kojee-mcp/lib` directly; one SSE subscription covers all joined
+  tandems; outbound `sendText` → `tandem_send`. Shares the daemon's keystore so
+  pairing once works for both. See its [README](integrations/openclaw-plugin/README.md).
+- **Hermes** — `integrations/hermes-plugin/` (sidecar design v1). The kojee-mcp
+  proxy runs as a **daemon** and POSTs signed webhooks to a loopback adapter
+  listener; the adapter turns each event into a Hermes message. Configure the
+  daemon side with `kojee-mcp init --runtime hermes --webhook-url …`. See its
+  [README](integrations/hermes-plugin/README.md).
+
+Pair once (`kojee-mcp pair`, or any kojee-mcp-attached session), and the agent
+must be a member of the tandem (`tandem_join` once, or be invited); after that,
+presence is zero-config — gateway up ⇒ agent reachable in the tandem.
+
 ## Claude Code Channels Support
 
 When this proxy detects it's running under Claude Code, it declares the `claude/channel` capability and pushes Tandem messages directly into the Claude session via `notifications/claude/channel`. Other MCP clients (Cursor, Codex, Openclaw, etc.) see no behavior change.

package/dist/{chunk-2TUAFAIW.js → chunk-DS26OORG.js}

@@ -117,11 +117,22 @@ function startEventLog(opts) {
 function formatStatusLine(fields) {
   return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${STATUS_LINE_PREFIX} ${fields}`;
 }
+function oneLineField(value) {
+  return String(value ?? "").replace(/[\u0000-\u001f\u007f]/g, "");
+}
 function formatLine(event) {
   const body = (event.content?.body ?? "").replace(/[\r\n]+/g, " ").slice(0, MAX_BODY_CHARS + 1);
   const truncated = body.length > MAX_BODY_CHARS;
-  const safeBody = truncated ? body.slice(0, MAX_BODY_CHARS) + "\u2026" : body;
-  return `[${event.time}] tandem=${event.tandem_id} from=${event.from.displayname} (${event.from.principal}) kind=${event.kind} cursor=${event.cursor} msg=${event.id}: ${safeBody}`;
+  const safeBody = oneLineField(truncated ? body.slice(0, MAX_BODY_CHARS) + "\u2026" : body);
+  const time = oneLineField(event.time);
+  const tandemId = oneLineField(event.tandem_id);
+  const displayname = oneLineField(event.from.displayname);
+  const principal = oneLineField(event.from.principal);
+  const kind = oneLineField(event.kind);
+  const cursor = oneLineField(event.cursor);
+  const id = oneLineField(event.id);
+  const wakeReason = event.wake_reason ? ` wake_reason=${oneLineField(event.wake_reason)}` : "";
+  return `[${time}] tandem=${tandemId} from=${displayname} (${principal}) kind=${kind}${wakeReason} cursor=${cursor} msg=${id}: ${safeBody}`;
 }
 function monitorHeartbeatPath(eventLogPath) {
   const dir = path.dirname(eventLogPath);

package/dist/{chunk-UEGQGXPY.js → chunk-MKDMAAMN.js}

@@ -231,6 +231,7 @@ async function consumeSse(body, opts, controller, state, onCursor) {
             const raw = JSON.parse(evt.data);
             const parsed = normalizeBackendEvent(raw, evt.event);
             onCursor(parsed.tandem_id, parsed.cursor);
+            if (parsed.wake === false) continue;
             opts.queue?.push(parsed);
             if (opts.eventLog) {
               try {
@@ -340,8 +341,13 @@ function resolveDisplayname(rawDisplay, principal) {
 }
 function normalizeBackendEvent(raw, sseEventType) {
   const obj = raw ?? {};
+  const rawWake = obj["wake"];
+  const wake = typeof rawWake === "boolean" ? rawWake : void 0;
+  const rawWakeReason = obj["wake_reason"];
+  const wakeReason = typeof rawWakeReason === "string" && rawWakeReason.trim() ? sanitizeDisplayname(rawWakeReason) : void 0;
+  const senderPresent = typeof obj === "object" && obj !== null && "sender" in obj;
   const maybeFrom = obj["from"];
-  if (maybeFrom && typeof maybeFrom["principal"] === "string") {
+  if (!senderPresent && maybeFrom && typeof maybeFrom["principal"] === "string") {
     const canonical = raw;
     const canonicalPrincipal = sanitizeDisplayname(maybeFrom["principal"]);
     return {
@@ -350,7 +356,9 @@ function normalizeBackendEvent(raw, sseEventType) {
         ...canonical.from,
         principal: canonicalPrincipal,
         displayname: resolveDisplayname(maybeFrom["displayname"], canonicalPrincipal)
-      }
+      },
+      ...wake !== void 0 ? { wake } : {},
+      ...wakeReason !== void 0 ? { wake_reason: wakeReason } : {}
     };
   }
   const sender = obj["sender"] ?? {};
@@ -383,7 +391,9 @@ function normalizeBackendEvent(raw, sseEventType) {
     },
     ...Array.isArray(obj["mentions"]) ? { mentions: obj["mentions"] } : {},
     ...obj["reply_to"] !== void 0 ? { reply_to: obj["reply_to"] } : {},
-    ...severity ? { severity } : {}
+    ...severity ? { severity } : {},
+    ...wake !== void 0 ? { wake } : {},
+    ...wakeReason !== void 0 ? { wake_reason: wakeReason } : {}
   };
 }
 

package/dist/chunk-PHXO5P25.js

@@ -0,0 +1,20 @@
+// src/hooks/format-channel.ts
+function sanitizeChannelAttr(value) {
+  return String(value ?? "").replace(/["<>\u0000-\u001f\u007f]/g, "");
+}
+function formatChannelEvents(events) {
+  const header = `[${events.length} unread Tandem ${events.length === 1 ? "event" : "events"}]
+
+`;
+  const bodies = events.map((evt) => {
+    const attrs = Object.entries(evt.meta).map(([k, v]) => `${k}="${sanitizeChannelAttr(v)}"`).join(" ");
+    return `<channel source="kojee-mcp" ${attrs}>
+${evt.content}
+</channel>`;
+  });
+  return header + bodies.join("\n\n");
+}
+
+export {
+  formatChannelEvents
+};

package/dist/{chunk-JWSIR6KV.js → chunk-SCDWPGH3.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-HSR3GXCL.js";
 import {
   startEventStream
-} from "./chunk-UEGQGXPY.js";
+} from "./chunk-MKDMAAMN.js";
 import {
   translateToolCallResult
 } from "./chunk-LDZXU3DW.js";
@@ -245,6 +245,7 @@ var claudeCodeAdapter = {
       from_display: event.from.displayname,
       severity: computeSeverity(event)
     };
+    if (event.wake_reason) meta.wake_reason = event.wake_reason;
     return { content: formatBody(event), meta };
   }
 };
@@ -377,7 +378,7 @@ async function startProxy(config) {
       cleanupDiscoveryByKey,
       sweepStaleDiscovery
     } = await import("./session-discovery-FNMJGFPM.js");
-    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-RSTM4PLL.js");
+    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-B27VVEMK.js");
     const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");
     const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
     const { createWebhookSink } = await import("./webhook-sink-NWGCUDGY.js");
@@ -514,7 +515,7 @@ async function startProxy(config) {
     activeStreamHandle = streamHandle;
     joinReconnect.notifyReady();
   } else if (needsWebhookEventStream()) {
-    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-RSTM4PLL.js");
+    const { startEventLog, sweepStaleEventLogs } = await import("./event-log-B27VVEMK.js");
     const { resolveWebhookConfig } = await import("./webhook-config-O4WMQ532.js");
     const { createWebhookSink } = await import("./webhook-sink-NWGCUDGY.js");
     const { resubscribeMemberships } = await import("./resubscribe-G5OGDZJD.js");

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
 import {
   VERSION,
   startProxy
-} from "./chunk-JWSIR6KV.js";
+} from "./chunk-SCDWPGH3.js";
 import "./chunk-X672ZN7V.js";
 import "./chunk-BJMASMKX.js";
 import {
@@ -13,7 +13,7 @@ import {
 } from "./chunk-YH27B6SW.js";
 import "./chunk-JXMVZEQ7.js";
 import "./chunk-HSR3GXCL.js";
-import "./chunk-UEGQGXPY.js";
+import "./chunk-MKDMAAMN.js";
 import "./chunk-2MIISF2W.js";
 import {
   defaultPairedKeystorePath,
@@ -42,11 +42,11 @@ program.command("pair <code>").description("Pair this machine against Kojee usin
 });
 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, or codex-stop").action(async (opts) => {
   if (opts.type === "stop") {
-    const { runStopHook } = await import("./stop-hook-SNPOFG4Q.js");
+    const { runStopHook } = await import("./stop-hook-GEJF47SN.js");
     await runStopHook();
     process.exit(0);
   } else if (opts.type === "user-prompt-submit") {
-    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-J7XZSDST.js");
+    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-DGRRFHOB.js");
     await runUserPromptSubmitHook();
     process.exit(0);
   } else if (opts.type === "codex-stop") {
@@ -87,7 +87,7 @@ program.command("send <tandem_id>").description(
   process.exit(exitCode);
 });
 program.command("tail <path>").description("Stream a file's contents and follow appends (portable replacement for `tail -F`)").action(async (filePath) => {
-  const { runTail } = await import("./tail-stream-HDM7BZDZ.js");
+  const { runTail } = await import("./tail-stream-JNR4WFW3.js");
   try {
     await runTail(filePath);
   } catch (err) {
@@ -96,7 +96,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-QRATEOFD.js");
+  const { runDoctor } = await import("./doctor-XK335W7B.js");
   const code = await runDoctor();
   process.exit(code);
 });

package/dist/{doctor-QRATEOFD.js → doctor-XK335W7B.js}

@@ -1,7 +1,7 @@
 import {
   monitorHeartbeatPath,
   statusLogPath
-} from "./chunk-2TUAFAIW.js";
+} from "./chunk-DS26OORG.js";
 import {
   discoveryPathForKey,
   readSessionDiscoveryByKey

package/dist/{event-log-RSTM4PLL.js → event-log-B27VVEMK.js}

@@ -5,7 +5,7 @@ import {
   startEventLog,
   statusLogPath,
   sweepStaleEventLogs
-} from "./chunk-2TUAFAIW.js";
+} from "./chunk-DS26OORG.js";
 import "./chunk-DO42NPNR.js";
 import "./chunk-BLEGIR35.js";
 export {

package/dist/index.js

@@ -1,12 +1,12 @@
 import {
   listTandemIds,
   startProxy
-} from "./chunk-JWSIR6KV.js";
+} from "./chunk-SCDWPGH3.js";
 import "./chunk-X672ZN7V.js";
 import "./chunk-BJMASMKX.js";
 import "./chunk-JXMVZEQ7.js";
 import "./chunk-HSR3GXCL.js";
-import "./chunk-UEGQGXPY.js";
+import "./chunk-MKDMAAMN.js";
 import "./chunk-2MIISF2W.js";
 import "./chunk-CH32ELFX.js";
 import "./chunk-BLEGIR35.js";

package/dist/lib.d.ts

@@ -38,6 +38,8 @@ interface TandemEvent {
     }>;
     reply_to?: string | null;
     severity?: string;
+    wake?: boolean;
+    wake_reason?: string;
 }
 
 /**

package/dist/lib.js

@@ -15,7 +15,7 @@ import {
   normalizeBackendEvent,
   sanitizeDisplayname,
   startEventStream
-} from "./chunk-UEGQGXPY.js";
+} from "./chunk-MKDMAAMN.js";
 import {
   createDPoPProof
 } from "./chunk-2MIISF2W.js";

package/dist/{stop-hook-SNPOFG4Q.js → stop-hook-GEJF47SN.js}

@@ -1,10 +1,13 @@
+import {
+  formatChannelEvents
+} from "./chunk-PHXO5P25.js";
 import {
   readHookStdin
 } from "./chunk-LSUB6QMP.js";
 import {
   monitorHeartbeatPath,
   nudgeSentinelPath
-} from "./chunk-2TUAFAIW.js";
+} from "./chunk-DS26OORG.js";
 import {
   readSessionDiscoveryByKey
 } from "./chunk-DO42NPNR.js";
@@ -37,7 +40,7 @@ async function decideStopHook(deps) {
   if (!deps.discovery) return "{}";
   const body = await deps.pollEvents().catch(() => null);
   if (body && body.count > 0) {
-    return JSON.stringify({ decision: "block", reason: formatEvents(body.events) });
+    return JSON.stringify({ decision: "block", reason: formatChannelEvents(body.events) });
   }
   const logPath = deps.discovery.eventLogPath;
   if (logPath && deps.logHasContent(logPath) && !deps.monitorIsLive(logPath)) {
@@ -109,18 +112,6 @@ function monitorIsLive(logPath) {
     return false;
   }
 }
-function formatEvents(events) {
-  const header = `[${events.length} unread Tandem ${events.length === 1 ? "event" : "events"}]
-
-`;
-  const bodies = events.map((evt) => {
-    const attrs = Object.entries(evt.meta).map(([k, v]) => `${k}="${v}"`).join(" ");
-    return `<channel source="kojee-mcp" ${attrs}>
-${evt.content}
-</channel>`;
-  });
-  return header + bodies.join("\n\n");
-}
 export {
   decideStopHook,
   runStopHook

package/dist/{tail-stream-HDM7BZDZ.js → tail-stream-JNR4WFW3.js}

@@ -2,11 +2,11 @@ import {
   STATUS_LINE_PREFIX,
   monitorHeartbeatPath,
   statusLogPath
-} from "./chunk-2TUAFAIW.js";
+} from "./chunk-DS26OORG.js";
 import "./chunk-DO42NPNR.js";
 import {
   createAdaptiveWatchdog
-} from "./chunk-UEGQGXPY.js";
+} from "./chunk-MKDMAAMN.js";
 import "./chunk-2MIISF2W.js";
 import "./chunk-BLEGIR35.js";
 

package/dist/{user-prompt-submit-hook-J7XZSDST.js → user-prompt-submit-hook-DGRRFHOB.js}

@@ -1,3 +1,6 @@
+import {
+  formatChannelEvents
+} from "./chunk-PHXO5P25.js";
 import {
   readHookStdin
 } from "./chunk-LSUB6QMP.js";
@@ -42,19 +45,7 @@ async function runUserPromptSubmitHook() {
     process.stdout.write("{}");
     return;
   }
-  process.stdout.write(JSON.stringify({ additionalContext: formatEvents(body.events) }));
-}
-function formatEvents(events) {
-  const header = `[${events.length} unread Tandem ${events.length === 1 ? "event" : "events"}]
-
-`;
-  const bodies = events.map((evt) => {
-    const attrs = Object.entries(evt.meta).map(([k, v]) => `${k}="${v}"`).join(" ");
-    return `<channel source="kojee-mcp" ${attrs}>
-${evt.content}
-</channel>`;
-  });
-  return header + bodies.join("\n\n");
+  process.stdout.write(JSON.stringify({ additionalContext: formatChannelEvents(body.events) }));
 }
 export {
   runUserPromptSubmitHook

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kojee-mcp",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "type": "module",
   "main": "dist/index.js",
   "exports": {