jefrichat-mcp 0.48.9 → 0.48.11

package/dist/http.js

@@ -98,7 +98,7 @@ var require_depd = __commonJS({
       var site = callSiteLocation(stack[1]);
       var file = site[0];
       function deprecate(message) {
-        log2.call(deprecate, message);
+        log3.call(deprecate, message);
       }
       deprecate._file = file;
       deprecate._ignored = isignored(namespace);
@@ -127,7 +127,7 @@ var require_depd = __commonJS({
       var str = process.env.TRACE_DEPRECATION || "";
       return containsNamespace(str, namespace);
     }
-    function log2(message, site) {
+    function log3(message, site) {
       var haslisteners = eehaslisteners(process, "deprecation");
       if (!haslisteners && this._ignored) {
         return;
@@ -267,7 +267,7 @@ var require_depd = __commonJS({
         "message",
         "site",
         '"use strict"\nreturn function (' + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}"
-      )(fn, log2, this, message, site);
+      )(fn, log3, this, message, site);
       return deprecatedfn;
     }
     function wrapproperty(obj, prop, message) {
@@ -292,13 +292,13 @@ var require_depd = __commonJS({
       var set = descriptor.set;
       if (typeof get === "function") {
         descriptor.get = function getter() {
-          log2.call(deprecate, message, site);
+          log3.call(deprecate, message, site);
           return get.apply(this, arguments);
         };
       }
       if (typeof set === "function") {
         descriptor.set = function setter() {
-          log2.call(deprecate, message, site);
+          log3.call(deprecate, message, site);
           return set.apply(this, arguments);
         };
       }
@@ -1135,7 +1135,7 @@ var require_debug = __commonJS({
 var require_browser = __commonJS({
   "../../node_modules/.pnpm/debug@2.6.9/node_modules/debug/src/browser.js"(exports, module) {
     exports = module.exports = require_debug();
-    exports.log = log2;
+    exports.log = log3;
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -1183,7 +1183,7 @@ var require_browser = __commonJS({
       });
       args.splice(lastC, 0, c);
     }
-    function log2() {
+    function log3() {
       return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
     }
     function save(namespaces) {
@@ -1224,7 +1224,7 @@ var require_node = __commonJS({
     var util2 = __require("util");
     exports = module.exports = require_debug();
     exports.init = init;
-    exports.log = log2;
+    exports.log = log3;
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -1275,7 +1275,7 @@ var require_node = __commonJS({
         args[0] = (/* @__PURE__ */ new Date()).toUTCString() + " " + name + " " + args[0];
       }
     }
-    function log2() {
+    function log3() {
       return stream.write(util2.format.apply(util2, arguments) + "\n");
     }
     function save(namespaces) {
@@ -27279,11 +27279,11 @@ var require_core = __commonJS({
     Ajv2.ValidationError = validation_error_1.default;
     Ajv2.MissingRefError = ref_error_1.default;
     exports.default = Ajv2;
-    function checkOptions(checkOpts, options, msg, log2 = "error") {
+    function checkOptions(checkOpts, options, msg, log3 = "error") {
       for (const key in checkOpts) {
         const opt = key;
         if (opt in options)
-          this.logger[log2](`${msg}: option ${key}. ${checkOpts[opt]}`);
+          this.logger[log3](`${msg}: option ${key}. ${checkOpts[opt]}`);
       }
     }
     function getSchEnv(keyRef) {
@@ -32012,7 +32012,7 @@ var require_websocket = __commonJS({
     var http2 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash2 } = __require("crypto");
+    var { randomBytes, createHash: createHash3 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -32680,7 +32680,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -33049,7 +33049,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http2 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash2 } = __require("crypto");
+    var { createHash: createHash3 } = __require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -33356,7 +33356,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -33549,7 +33549,7 @@ for (const [k, v] of snapshot) {
 
 // src/http.ts
 import http from "node:http";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/session-auth.ts
 import { createHash, timingSafeEqual } from "node:crypto";
@@ -49051,7 +49051,7 @@ var wrapper_default = import_websocket.default;
 import fs from "node:fs";
 import os from "node:os";
 import path2 from "node:path";
-import { webcrypto } from "node:crypto";
+import { webcrypto, randomUUID as randomUUID2 } from "node:crypto";
 
 // ../../node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js
 function bail(error2) {
@@ -60649,6 +60649,238 @@ function groupConversationId(groupId) {
   return "group:" + groupId;
 }
 
+// ../sdk/src/http-client.ts
+import { randomUUID } from "node:crypto";
+function idem(key) {
+  return { "idempotency-key": key || `sdk-${randomUUID()}` };
+}
+var JefriHttpError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "JefriHttpError";
+  }
+  status;
+  body;
+  /** The hub's machine-readable state field, when it sent one. */
+  get state() {
+    return this.body?.state;
+  }
+};
+var UnsupportedOverHttp = class extends Error {
+  constructor(what, why) {
+    super(`${what} is not available without a live connection \u2014 ${why}`);
+    this.name = "UnsupportedOverHttp";
+  }
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var JefriHttpClient = class {
+  base;
+  /** Discriminant for callers that accept either client: `stateless` is true
+   *  here and absent on the socket client, so shared code can branch without
+   *  instanceof (which breaks across duplicated package instances). */
+  stateless = true;
+  /** PUBLIC, like JefriClient.token: the connector's HTTP upload/download
+   *  helpers authenticate raw fetches with it. */
+  token;
+  f;
+  timeoutMs;
+  /** Populated by whoami(); mirrors JefriClient.identity for callers that read it. */
+  identity = null;
+  constructor(opts) {
+    this.base = opts.server.replace(/\/+$/, "");
+    this.token = opts.token;
+    this.f = opts.fetchImpl ?? fetch;
+    const t = Number(opts.timeoutMs);
+    this.timeoutMs = Number.isFinite(t) && t > 0 ? t : DEFAULT_TIMEOUT_MS;
+  }
+  async call(method, path3, body, query, extraHeaders) {
+    const url = new URL(this.base + path3);
+    for (const [k, v] of Object.entries(query ?? {})) if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await this.f(url.toString(), {
+        method,
+        signal: ac.signal,
+        headers: {
+          authorization: `Bearer ${this.token}`,
+          ...body !== void 0 ? { "content-type": "application/json" } : {},
+          ...extraHeaders ?? {}
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+    } catch (e) {
+      clearTimeout(timer);
+      if (e?.name === "AbortError") throw new Error(`${method} ${path3} timed out after ${this.timeoutMs}ms`);
+      throw e;
+    }
+    let text5;
+    try {
+      text5 = await res.text();
+    } catch (e) {
+      if (e?.name === "AbortError") throw new Error(`${method} ${path3} timed out after ${this.timeoutMs}ms reading the body`);
+      throw e;
+    } finally {
+      clearTimeout(timer);
+    }
+    let parsed = null;
+    try {
+      parsed = text5 ? JSON.parse(text5) : null;
+    } catch {
+    }
+    if (!res.ok) {
+      throw new JefriHttpError(parsed?.error ?? `${method} ${path3} failed with ${res.status}`, res.status, parsed);
+    }
+    return parsed;
+  }
+  // --- identity ------------------------------------------------------------
+  /** /api/me answers `{ identity, online }`, NOT a bare Identity — unwrapping is
+   *  the caller's job and getting it wrong is silent: every field reads as
+   *  undefined and the object still looks like an Identity. Caught by running
+   *  this against the real hub; a stubbed test would have returned whatever
+   *  shape the stub was written to expect. */
+  async whoami() {
+    const body = await this.call("GET", "/api/me");
+    const me = body?.identity ?? body;
+    if (!me?.username) throw new Error("unexpected /api/me response shape");
+    this.identity = me;
+    return me;
+  }
+  // --- reads ---------------------------------------------------------------
+  identities() {
+    return this.call("GET", "/api/identities");
+  }
+  groups() {
+    return this.call("GET", "/api/groups");
+  }
+  inbox(since) {
+    return this.call("GET", "/api/inbox", void 0, { since });
+  }
+  search(query) {
+    return this.call("GET", "/api/search", void 0, { q: query });
+  }
+  history(conversationId, before) {
+    return this.call("GET", "/api/history", void 0, { conversationId, before });
+  }
+  // --- writes --------------------------------------------------------------
+  /** Sends carry an idempotency key.
+   *
+   *  The hub persists the key in the SAME transaction as the message, so a retry
+   *  is exactly-once rather than at-least-once. This matters far more for a
+   *  stateless client than a socket one: a timed-out or connection-reset POST
+   *  gives no evidence of whether the send landed, and the natural response — retry
+   *  — is precisely what produces duplicates during a deployment.
+   *
+   *  Callers may pass their own key when a retry must reuse it; otherwise one is
+   *  minted per call. */
+  message(to, content3, idempotencyKey) {
+    return this.call("POST", "/api/messages", { to, content: content3 }, void 0, idem(idempotencyKey));
+  }
+  groupMessage(groupId, content3, idempotencyKey) {
+    return this.call("POST", "/api/messages", { groupId, content: content3 }, void 0, idem(idempotencyKey));
+  }
+  /** DECLARE a status — a user-level choice that hits every connection the
+   *  identity holds. The returned status is the SETTLED one, which may differ
+   *  from the request if another lease outvoted it. */
+  /** `declId` (optional) makes the declaration retry-safe: a re-POST of the
+   *  same id replays — answering the CURRENT settled state — instead of
+   *  reapplying, so a stale retry can never overwrite a status another device
+   *  chose in between. Reusing an id with a DIFFERENT status is a 409. */
+  presence(status, declId) {
+    return this.call("POST", "/api/presence", declId ? { status, declId } : { status });
+  }
+  /** KEEPALIVE — "still here", declaring nothing. This is the call for a timer.
+   *  Heartbeating through presence("online") instead is a declaration on a
+   *  timer, and it silently undoes an appear-offline chosen elsewhere.
+   *
+   *  REJECTS (409, "signed off") when the identity has signed off: the beat was
+   *  refused and no lease exists, so the timer should STOP and the client must
+   *  declare a presence to resume. The refusal used to arrive as ok:true with a
+   *  full TTL — a lease lifetime that did not exist. */
+  async heartbeat() {
+    try {
+      return await this.call("POST", "/api/presence", { keepalive: true });
+    } catch (e) {
+      if (e instanceof JefriHttpError && e.status === 409 && e.state === "signedOff")
+        return { ok: false, state: "signedOff", status: String(e.body?.status ?? "offline"), expiresInMs: 0 };
+      throw e;
+    }
+  }
+  addFriend(to) {
+    return this.call("POST", "/api/friends/request", { to });
+  }
+  /** Upload and deliver a file. The hub's raw-body route takes the bytes
+   *  directly, so there is no base64 round-trip. */
+  async sendFile(target, fileName, mime, bytes, idempotencyKey) {
+    const url = new URL(this.base + "/api/files");
+    if (target.to) url.searchParams.set("to", target.to);
+    if (target.groupId) url.searchParams.set("groupId", target.groupId);
+    url.searchParams.set("fileName", fileName);
+    if (target.caption) url.searchParams.set("caption", target.caption);
+    const uploadTimeout = Math.max(this.timeoutMs, 3e4 + bytes.length / 20);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), uploadTimeout);
+    let res;
+    try {
+      res = await this.f(url.toString(), {
+        method: "POST",
+        signal: ac.signal,
+        headers: {
+          authorization: `Bearer ${this.token}`,
+          "content-type": mime || "application/octet-stream",
+          ...idem(idempotencyKey)
+        },
+        body: bytes
+      });
+    } catch (e) {
+      clearTimeout(timer);
+      if (e?.name === "AbortError") throw new Error(`file upload timed out after ${Math.round(uploadTimeout)}ms`);
+      throw e;
+    }
+    let text5;
+    try {
+      text5 = await res.text();
+    } catch (e) {
+      if (e?.name === "AbortError") throw new Error(`file upload timed out after ${Math.round(uploadTimeout)}ms reading the response`);
+      throw e;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      let msg = `upload failed with ${res.status}`;
+      try {
+        msg = JSON.parse(text5)?.error ?? msg;
+      } catch {
+      }
+      throw new Error(msg);
+    }
+    return text5 ? JSON.parse(text5) : null;
+  }
+  // --- deliberately unsupported -------------------------------------------
+  /** Realtime delivery needs a socket. A stateless caller polls /api/inbox. */
+  on() {
+    throw new UnsupportedOverHttp("Realtime events", "this client holds no socket; poll the inbox instead");
+  }
+  off() {
+    throw new UnsupportedOverHttp("Realtime events", "this client holds no socket; poll the inbox instead");
+  }
+  /** E2E sends are excluded until key custody is durable — see the file header.
+   *  Throwing names the reason so the next person does not "fix" it by wiring the
+   *  call through and shipping unreadable ciphertext. */
+  privateMessage() {
+    throw new UnsupportedOverHttp("End-to-end encrypted send", "private keys are not durably held; use the stateful connector");
+  }
+  privateGroupMessage() {
+    throw new UnsupportedOverHttp("End-to-end encrypted send", "private keys are not durably held; use the stateful connector");
+  }
+  /** Nothing to close — kept so callers can treat both clients alike. */
+  close() {
+  }
+};
+
 // ../sdk/src/index.ts
 var subtle = webcrypto.subtle;
 var enc = new TextEncoder();
@@ -60659,6 +60891,9 @@ var b64 = (bytes) => Buffer.from(bytes instanceof Uint8Array ? bytes : new Uint8
 var fromB64 = (s) => new Uint8Array(Buffer.from(s, "base64"));
 var safeName = (s) => s.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var canonicalJwk = (jwk) => JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });
+function newDeclId() {
+  return "d-" + randomUUID2();
+}
 var JefriAuthError = class extends Error {
   code = "ACP_AUTH_FAILED";
   constructor(message = "invalid or expired Jefri Chat token") {
@@ -60693,6 +60928,9 @@ var JefriClient = class _JefriClient {
    *  life of the process, stomping whatever a newer device had chosen since.
    *  The same stale-overwrite, one level down. */
   pendingPresence = null;
+  /** The id minted for the pending declaration. Its ECHO on a presence_update
+   *  is the only genuine acknowledgment — see notePresenceAck. */
+  pendingDeclId = null;
   /** The self statusRev BASELINE captured when the pending declaration was made.
    *  An ack must be CAUSALLY newer than this — the audit reproduced a delayed
    *  rev-9 event spending intent declared at a rev-10 baseline, after which the
@@ -60718,11 +60956,12 @@ var JefriClient = class _JefriClient {
    *  deleted, which is how the previous round's test enshrined the bug. */
   notePresenceAck(ev) {
     if (ev?.event !== "presence_update" || ev.username !== this.identity?.username) return;
-    const frontier = this.selfStatusRev;
     if (typeof ev.rev === "number" && ev.rev > this.selfStatusRev) this.selfStatusRev = ev.rev;
-    if (this.pendingPresence === null || ev.status !== this.pendingPresence) return;
-    if (typeof ev.rev !== "number" || ev.rev <= this.pendingBaselineRev || ev.rev < frontier) return;
-    this.pendingPresence = null;
+    if (this.pendingPresence === null) return;
+    if (this.pendingDeclId !== null && ev.declId === this.pendingDeclId) {
+      this.pendingPresence = null;
+      this.pendingDeclId = null;
+    }
   }
   clientInfo;
   // handshake, re-sent on reconnect
@@ -60819,7 +61058,7 @@ var JefriClient = class _JefriClient {
         this.startPing();
         try {
           if (this.pendingPresence !== null)
-            this.ws.send(JSON.stringify({ type: "presence", status: this.pendingPresence }));
+            this.ws.send(JSON.stringify({ type: "presence", status: this.pendingPresence, declId: this.pendingDeclId ?? void 0 }));
           if (this.clientInfo)
             this.ws.send(JSON.stringify({ type: "client_info", ...this.clientInfo }));
         } catch {
@@ -60947,7 +61186,8 @@ var JefriClient = class _JefriClient {
   presence(status) {
     this.pendingPresence = status;
     this.pendingBaselineRev = this.selfStatusRev;
-    this.send({ type: "presence", status });
+    this.pendingDeclId = newDeclId();
+    this.send({ type: "presence", status, declId: this.pendingDeclId });
   }
   message(to, content3) {
     this.send({ type: "message", to, content: content3 });
@@ -61277,6 +61517,96 @@ var JefriClient = class _JefriClient {
 };
 var serveDir = path2.join(os.homedir(), ".acp", "serve");
 
+// src/stateless-presence.ts
+var log = (...a) => console.error("[jefrichat-mcp-http]", ...a);
+async function statelessPresenceBringUp(acp) {
+  try {
+    const hb = await acp.heartbeat();
+    if (hb.state === "signedOff") await acp.presence("online");
+    return true;
+  } catch (e) {
+    log("stateless presence bring-up failed (the sweep retries it):", e?.message ?? e);
+    return false;
+  }
+}
+async function statelessSweepBeat(acp, pool, onAuthRevoked) {
+  if (pool.closed || pool.hbSignedOff) return;
+  try {
+    const hb = await acp.heartbeat();
+    if (hb.state === "signedOff") pool.hbSignedOff = true;
+  } catch (e) {
+    if (e instanceof JefriHttpError && (e.status === 401 || e.status === 403)) {
+      onAuthRevoked();
+      return;
+    }
+  }
+}
+
+// src/stateless-mcp.ts
+var rpcError = (res, status, code3, message) => res.status(status).json({ jsonrpc: "2.0", error: { code: code3, message }, id: null });
+function statelessMcpHandler(deps) {
+  return async (req, res) => {
+    if (deps.isDraining()) {
+      res.setHeader("retry-after", "1");
+      return rpcError(res, 503, -32e3, "server is shutting down \u2014 retry; another instance will answer");
+    }
+    const token = deps.bearer(req);
+    if (!token)
+      return rpcError(res, 401, -32001, "Missing Jefri Chat token \u2014 every request must include Authorization: Bearer <token> (or ?token=).");
+    if (!deps.tryAcquireInflight(token))
+      return rpcError(res, 429, -32003, "too many concurrent requests \u2014 slow down.");
+    try {
+      let acp;
+      try {
+        ({ acp } = await deps.acquire(token));
+      } catch (e) {
+        if (deps.classifyError(e) === "auth")
+          return rpcError(
+            res,
+            401,
+            -32001,
+            "Invalid or expired Jefri Chat token. Rotate it in the Jefri Chat web app (the agent's owner \u2192 \u{1F511} connect) and reconnect with the fresh command."
+          );
+        return rpcError(res, 502, -32002, `Hub unreachable: ${e?.message ?? e}`);
+      }
+      const mcp = new McpServer({ name: "jefrichat", version: "0.1.0" });
+      const deferred = [];
+      deps.registerTools(mcp, acp, { deferUntilDelivered: (fn) => deferred.push(fn) });
+      const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+      res.on("finish", () => {
+        for (const fn of deferred) {
+          try {
+            void Promise.resolve(fn()).catch((e) => deps.log?.("deferred post-delivery work failed:", e?.message ?? e));
+          } catch (e) {
+            deps.log?.("deferred post-delivery work failed:", e?.message ?? e);
+          }
+        }
+        deferred.length = 0;
+      });
+      res.on("close", () => {
+        try {
+          transport.close();
+        } catch {
+        }
+        try {
+          void mcp.close();
+        } catch {
+        }
+      });
+      await mcp.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+    } catch (e) {
+      deps.log?.("stateless request failed:", e?.message ?? e);
+      if (!res.headersSent) rpcError(res, 500, -32603, "internal error handling the request");
+    } finally {
+      deps.releaseInflight(token);
+    }
+  };
+}
+function statelessMethodNotAllowed(_req, res) {
+  res.status(405).json({ jsonrpc: "2.0", error: { code: -32e3, message: "stateless server: POST only (no SSE stream, no session to terminate)" }, id: null });
+}
+
 // src/conn-pool.ts
 function attachRef(c, id) {
   if (c.closed) return false;
@@ -61315,7 +61645,8 @@ function createKeyedPool() {
       return v;
     },
     has: (key) => ready.has(key),
-    size: () => ready.size
+    size: () => ready.size,
+    keys: () => [...ready.keys()]
   };
 }
 
@@ -61343,6 +61674,7 @@ import cp3 from "node:child_process";
 import os4 from "node:os";
 import nnet from "node:net";
 import ndns from "node:dns/promises";
+import { createHash as createHash2 } from "node:crypto";
 import nhttp from "node:http";
 import nhttps from "node:https";
 
@@ -61750,6 +62082,35 @@ var debateJobs = /* @__PURE__ */ new Map();
 var DEBATE_SEQ_TTL_MS = 10 * 60 * 1e3;
 
 // src/tools.ts
+var isStateless = (c) => c.stateless === true;
+async function confirmWrite(c, fire) {
+  if (isStateless(c)) {
+    try {
+      await fire();
+      return {};
+    } catch (e2) {
+      return { error: e2?.message ?? String(e2) };
+    }
+  }
+  const err = waitFor(c, "error", () => true, 800);
+  fire();
+  const e = await err;
+  return e ? { error: e.message } : {};
+}
+function retryKey(extra, parts) {
+  const rid = extra?.requestId;
+  if (rid === void 0 || rid === null) return void 0;
+  const h = extra?.requestInfo?.headers;
+  const ua = String((typeof h?.get === "function" ? h.get("user-agent") : h?.["user-agent"]) ?? "");
+  const bucket = Math.floor(Date.now() / 6e5);
+  return "mcp-" + createHash2("sha256").update(JSON.stringify([bucket, ua, rid, ...parts])).digest("hex").slice(0, 40);
+}
+async function fetchHistory(c, convId) {
+  if (isStateless(c)) return c.history(convId);
+  const p = waitFor(c, "history", (e) => e.conversationId === convId, 4e3);
+  c.history(convId);
+  return p;
+}
 var MIME = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -62085,7 +62446,7 @@ function saveWatermark() {
 }
 function registerAcpTools(server2, ctx) {
   const ENABLE_E2E = process.env.JEFRI_ENABLE_E2E === "true";
-  const e2eServer = ENABLE_E2E ? server2 : { registerTool: () => void 0 };
+  const e2eServer = ENABLE_E2E && !ctx.stateless ? server2 : { registerTool: () => void 0 };
   const withClient = async (fn) => {
     try {
       const c = await ctx.ensureClient();
@@ -62202,11 +62563,12 @@ Use jefri_agent_apps with agent=<name> to see its live app + active state.`);
         text: external_exports.string().describe("the message body")
       }
     },
-    async ({ to, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      c.message(to, text5);
-      const e = await err;
-      if (e) return fail(`Message rejected: ${e.message}`);
+    async ({ to, text: text5 }, extra) => withClient(async (c) => {
+      const r = await confirmWrite(
+        c,
+        () => isStateless(c) ? c.message(to, text5, retryKey(extra, ["message", to, text5])) : c.message(to, text5)
+      );
+      if (r.error) return fail(`Message rejected: ${r.error}`);
       return ok3(`Sent to @${to}: "${text5}"`);
     })
   );
@@ -62221,8 +62583,9 @@ Use jefri_agent_apps with agent=<name> to see its live app + active state.`);
       }
     },
     async ({ to, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      await c.privateMessage(to, text5);
+      const sc = c;
+      const err = waitFor(sc, "error", () => true, 800);
+      await sc.privateMessage(to, text5);
       const e = await err;
       if (e) return fail(`Private message rejected: ${e.message}`);
       return ok3(`Sent private E2E message to @${to}.`);
@@ -62279,8 +62642,9 @@ ${fp}`);
       } else {
         return fail("provide a local file `path` (or `dataUrl` + `fileName`)");
       }
-      await c.privateFile(to, name, mime, url);
-      if (caption) await c.privateMessage(to, caption);
+      const sc = c;
+      await sc.privateFile(to, name, mime, url);
+      if (caption) await sc.privateMessage(to, caption);
       return ok3(`Sent private E2E file to @${to}.`);
     })
   );
@@ -62295,8 +62659,9 @@ ${fp}`);
       }
     },
     async ({ groupId, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      await c.privateGroupMessage(groupId, text5);
+      const sc = c;
+      const err = waitFor(sc, "error", () => true, 800);
+      await sc.privateGroupMessage(groupId, text5);
       const e = await err;
       if (e) return fail(`Private group message rejected: ${e.message}`);
       return ok3(`Sent private E2E group message.`);
@@ -62359,7 +62724,7 @@ ${fp}`);
         fileName: external_exports.string().optional().describe("file name (used with dataUrl, or to name a fileUrl download)")
       }
     },
-    async ({ to, path: path3, caption, dataUrl, fileUrl, fileName }) => withClient(async (c) => {
+    async ({ to, path: path3, caption, dataUrl, fileUrl, fileName }, extra) => withClient(async (c) => {
       let name, mime, url;
       if (path3) {
         if (!ctx.local) {
@@ -62411,9 +62776,23 @@ ${psCmd}
         return fail("provide a local file `path`, a `dataUrl` + `fileName`, or a public `fileUrl`");
       }
       const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
+      if (rawBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c)) {
+        try {
+          await c.sendFile(
+            { to, caption },
+            name,
+            mime,
+            rawBytes,
+            retryKey(extra, ["file", to, name, createHash2("sha256").update(rawBytes).digest("hex")])
+          );
+        } catch (e2) {
+          return fail(`Rejected: ${e2?.message ?? e2}`);
+        }
+        return ok3(`Sent \u{1F4CE} ${name} (${MB(rawBytes.length)} MB) to @${to}${caption ? ` \u2014 "${caption}"` : ""}`);
+      }
       if (rawBytes.length > WS_SAFE_FILE_BYTES) {
-        if (rawBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
         try {
           await uploadFileHttp(c, ctx.serverUrl, { to }, name, mime, rawBytes, caption);
         } catch (e2) {
@@ -62441,13 +62820,27 @@ ${psCmd}
         caption: external_exports.string().optional()
       }
     },
-    async ({ to, fileName, content: content3, caption }) => withClient(async (c) => {
+    async ({ to, fileName, content: content3, caption }, extra) => withClient(async (c) => {
       const known = mimeOf(fileName);
       const mime = known === "application/octet-stream" ? "text/plain" : known;
       const contentBytes = Buffer.from(content3, "utf8");
+      if (contentBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`That content is ${MB(contentBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c)) {
+        try {
+          await c.sendFile(
+            { to, caption },
+            fileName,
+            mime,
+            contentBytes,
+            retryKey(extra, ["file", to, fileName, createHash2("sha256").update(contentBytes).digest("hex")])
+          );
+        } catch (e2) {
+          return fail(`Rejected: ${e2?.message ?? e2}`);
+        }
+        return ok3(`Sent \u{1F4C4} ${fileName} (${MB(contentBytes.length)} MB) to @${to}${caption ? ` \u2014 "${caption}"` : ""}`);
+      }
       if (contentBytes.length > WS_SAFE_FILE_BYTES) {
-        if (contentBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`That content is ${MB(contentBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
         try {
           await uploadFileHttp(c, ctx.serverUrl, { to }, fileName, mime, contentBytes, caption);
         } catch (e2) {
@@ -62578,9 +62971,7 @@ ${psCmd}
       if (!from && !groupId) return fail("Give `from` (a username, for a DM) or `groupId` (for a group file).");
       const convId = groupId ? groupConversationId(groupId) : dmConversationId(c.identity.username, from);
       const where = groupId ? "this group" : `@${from}`;
-      const p = waitFor(c, "history", (e) => e.conversationId === convId, 4e3);
-      c.history(convId);
-      const res = await p;
+      const res = await fetchHistory(c, convId);
       const files = (res?.messages ?? []).filter((m) => m.kind === "file");
       if (!files.length) return fail(`No files in ${where} yet.`);
       const match = fileName ? [...files].reverse().find((m) => m.fileName === fileName || m.fileName?.includes(fileName)) : files[files.length - 1];
@@ -62617,10 +63008,8 @@ It downloads the file to your machine (current folder unless you set a path). Fi
       inputSchema: { to: external_exports.string().describe("username to connect with") }
     },
     async ({ to }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      c.addFriend(to);
-      const e = await err;
-      if (e) return fail(`Request rejected: ${e.message}`);
+      const r = await confirmWrite(c, () => c.addFriend(to));
+      if (r.error) return fail(`Request rejected: ${r.error}`);
       return ok3(`\u{1F91D} Connection request sent to @${to}. They (or their owner) must approve before you can message.`);
     })
   );
@@ -62842,7 +63231,7 @@ Or just upload ${fname} from the agent's page in the web app.`
     },
     async () => withClient(async (c) => {
       const me = c.identity.username;
-      const since = inboxWatermark.get(me);
+      const since = ctx.stateless ? "stored" : inboxWatermark.get(me);
       const url = `${ctx.serverUrl.replace(/\/$/, "")}/api/inbox` + (since ? `?since=${encodeURIComponent(since)}` : "");
       let msgs = [];
       try {
@@ -62856,8 +63245,24 @@ Or just upload ${fname} from the agent's page in the web app.`
       }
       if (!msgs.length) return ok3("\u{1F4ED} No new messages.");
       msgs.sort((a, b) => a.createdAt < b.createdAt ? -1 : 1);
-      inboxWatermark.set(me, msgs[msgs.length - 1].createdAt);
-      saveWatermark();
+      if (ctx.stateless) {
+        const last = msgs[msgs.length - 1];
+        const ack = async () => {
+          try {
+            await fetch(`${ctx.serverUrl.replace(/\/$/, "")}/api/inbox/seen`, {
+              method: "POST",
+              headers: { authorization: `Bearer ${c.token}`, "content-type": "application/json" },
+              body: JSON.stringify({ until: last.createdAt, untilId: last.id })
+            });
+          } catch {
+          }
+        };
+        if (ctx.deferUntilDelivered) ctx.deferUntilDelivered(ack);
+        else await ack();
+      } else {
+        inboxWatermark.set(me, msgs[msgs.length - 1].createdAt);
+        saveWatermark();
+      }
       const groupNames = /* @__PURE__ */ new Map();
       if (msgs.some((m) => m.groupId)) {
         try {
@@ -62915,11 +63320,12 @@ Or just upload ${fname} from the agent's page in the web app.`
         text: external_exports.string().describe("the message to post to the group")
       }
     },
-    async ({ groupId, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      c.groupMessage(groupId, text5);
-      const e = await err;
-      if (e) return fail(`Couldn't post to the group: ${e.message}`);
+    async ({ groupId, text: text5 }, extra) => withClient(async (c) => {
+      const r = await confirmWrite(
+        c,
+        () => isStateless(c) ? c.groupMessage(groupId, text5, retryKey(extra, ["group_message", groupId, text5])) : c.groupMessage(groupId, text5)
+      );
+      if (r.error) return fail(`Couldn't post to the group: ${r.error}`);
       return ok3(`Posted to the group.`);
     })
   );
@@ -62937,7 +63343,7 @@ Or just upload ${fname} from the agent's page in the web app.`
         fileName: external_exports.string().optional().describe("file name (used with dataUrl, or to name a fileUrl download)")
       }
     },
-    async ({ groupId, path: path3, caption, dataUrl, fileUrl, fileName }) => withClient(async (c) => {
+    async ({ groupId, path: path3, caption, dataUrl, fileUrl, fileName }, extra) => withClient(async (c) => {
       let name, mime, url;
       if (path3) {
         if (!ctx.local) {
@@ -62979,9 +63385,23 @@ Or just upload ${fname} from the agent's page in the web app.`
         return fail("provide a local file `path`, a `dataUrl` + `fileName`, or a public `fileUrl`");
       }
       const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
+      if (rawBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c)) {
+        try {
+          await c.sendFile(
+            { groupId, caption },
+            name,
+            mime,
+            rawBytes,
+            retryKey(extra, ["file", groupId, name, createHash2("sha256").update(rawBytes).digest("hex")])
+          );
+        } catch (e2) {
+          return fail(`Rejected: ${e2?.message ?? e2}`);
+        }
+        return ok3(`Sent \u{1F4CE} ${name} (${MB(rawBytes.length)} MB) to the group.`);
+      }
       if (rawBytes.length > WS_SAFE_FILE_BYTES) {
-        if (rawBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
         try {
           await uploadFileHttp(c, ctx.serverUrl, { groupId }, name, mime, rawBytes, caption);
         } catch (e2) {
@@ -63012,9 +63432,7 @@ Or just upload ${fname} from the agent's page in the web app.`
       if (!other && !groupId) return fail("Give `with` (a username, for a DM) or `groupId` (for a group).");
       const convId = groupId ? groupConversationId(groupId) : dmConversationId(c.identity.username, other);
       const label = groupId ? "this group" : `@${other}`;
-      const p = waitFor(c, "history", (e) => e.conversationId === convId);
-      c.history(convId);
-      const res = await p;
+      const res = await fetchHistory(c, convId);
       const msgs = (res?.messages ?? []).slice(-(limit ?? 20));
       if (!msgs.length) return ok3(`No messages yet in ${label}.`);
       const lines = await Promise.all(msgs.map(async (m) => {
@@ -63045,10 +63463,14 @@ Or just upload ${fname} from the agent's page in the web app.`
       inputSchema: { query: external_exports.string() }
     },
     async ({ query }) => withClient(async (c) => {
-      const res = waitFor(c, "search_results", () => true);
-      c.search(query);
-      const e = await res;
-      const results = e?.results ?? [];
+      let results;
+      if (isStateless(c)) {
+        results = (await c.search(query))?.results ?? [];
+      } else {
+        const res = waitFor(c, "search_results", () => true);
+        c.search(query);
+        results = (await res)?.results ?? [];
+      }
       if (!results.length) return ok3(`No agents matched "${query}".`);
       return ok3(
         results.map((r) => `\u2022 @${r.username} \u2014 ${r.displayName} (${r.status})${r.owner ? ` \xB7 by @${r.owner}` : ""} \xB7 ${r.tags.join(", ")}`).join("\n")
@@ -63064,8 +63486,11 @@ Or just upload ${fname} from the agent's page in the web app.`
         status: external_exports.enum(["online", "away", "busy", "coding", "reviewing", "planning", "offline"])
       }
     },
-    async ({ status }) => withClient(async (c) => {
-      c.presence(status);
+    async ({ status }, extra) => withClient(async (c) => {
+      const declId = isStateless(c) ? retryKey(extra, ["presence", status])?.replace(/^mcp-/, "d-") : void 0;
+      const r = await confirmWrite(c, () => isStateless(c) ? c.presence(status, declId) : c.presence(status));
+      if (r.error) return fail(`Couldn't set status: ${r.error}`);
+      ctx.onPresenceDeclared?.(status);
       return ok3(`Status set to ${status}.`);
     })
   );
@@ -63257,11 +63682,13 @@ function sweepIdleSessions(map3) {
 // src/http.ts
 var HUB = process.env.JEFRI_SERVER ?? "http://localhost:4000";
 var PORT = Number(process.env.MCP_HTTP_PORT ?? 4001);
-var log = (...a) => console.error("[jefrichat-mcp-http]", ...a);
+var STATELESS = process.env.JEFRI_STATELESS === "true";
+var log2 = (...a) => console.error("[jefrichat-mcp-http]", ...a);
 var sessions = /* @__PURE__ */ new Map();
 var HOST_FRESH_MS = Number(process.env.MCP_HOST_FRESH_MS ?? 10 * 60 * 1e3);
 var hubPool = createKeyedPool();
 var SESSION_TTL_MS = Number(process.env.MCP_SESSION_TTL_MS ?? 4 * 60 * 60 * 1e3);
+var STATELESS_POOL_IDLE_MS = Number(process.env.MCP_STATELESS_POOL_IDLE_MS ?? 10 * 60 * 1e3);
 var MAX_SESSIONS = Number(process.env.MCP_MAX_SESSIONS ?? 1500);
 var MAX_SESSIONS_PER_IDENTITY = Number(process.env.MCP_MAX_SESSIONS_PER_IDENTITY ?? 20);
 var INIT_WINDOW_MS = 6e4;
@@ -63292,7 +63719,7 @@ function closeSession(sid, reason) {
     if (detachRef(pooled, sid)) teardownPool(s.poolKey, pooled, "last session gone");
     else if (s.host) announcePoolHosts(s.poolKey, pooled);
   }
-  log(`session ${sid.slice(0, 8)}\u2026 closed (${reason}) (${sessions.size} active)`);
+  log2(`session ${sid.slice(0, 8)}\u2026 closed (${reason}) (${sessions.size} active)`);
 }
 function teardownPool(poolKey, pooled, reason) {
   pooled.closed = true;
@@ -63301,9 +63728,10 @@ function teardownPool(poolKey, pooled, reason) {
     pooled.acp.close();
   } catch {
   }
-  log(`hub connection ${poolKey.slice(0, 8)}\u2026 closed (${reason})`);
+  log2(`hub connection ${poolKey.slice(0, 8)}\u2026 closed (${reason})`);
 }
 function announcePoolHosts(poolKey, pooled) {
+  if (STATELESS) return;
   const joined = aggregateFreshHosts(sessions.values(), poolKey, Date.now(), HOST_FRESH_MS);
   if (joined === pooled.lastHosts) return;
   pooled.lastHosts = joined;
@@ -63318,6 +63746,12 @@ function closePool(poolKey, reason) {
 }
 async function acquirePooledConn(token, poolKey) {
   return hubPool.acquire(poolKey, async () => {
+    if (STATELESS) {
+      const acp2 = new JefriHttpClient({ server: HUB, token });
+      await acp2.whoami();
+      const broughtUp = await statelessPresenceBringUp(acp2);
+      return { acp: acp2, inbox: [], refs: /* @__PURE__ */ new Set(), closed: false, lastSeen: Date.now(), needsBringUp: !broughtUp };
+    }
     const acp = await JefriClient.connect({ server: HUB, token, status: "online" });
     const inbox = [];
     if (acp.identity) attachInbox(acp, inbox, acp.identity.username);
@@ -63339,12 +63773,30 @@ setInterval(() => {
   for (const [sid, s] of sessions) {
     if (now - s.lastActive > SESSION_TTL_MS) closeSession(sid, "idle");
   }
-  const seenPools = /* @__PURE__ */ new Set();
-  for (const s of sessions.values()) {
-    if (seenPools.has(s.poolKey)) continue;
-    seenPools.add(s.poolKey);
-    const pooled = hubPool.get(s.poolKey);
-    if (pooled) announcePoolHosts(s.poolKey, pooled);
+  if (STATELESS) {
+    for (const key of hubPool.keys()) {
+      const pooled = hubPool.get(key);
+      if (!pooled) continue;
+      if (now - (pooled.lastSeen ?? 0) > STATELESS_POOL_IDLE_MS) {
+        hubPool.drop(key);
+        continue;
+      }
+      if (pooled.needsBringUp) {
+        void statelessPresenceBringUp(pooled.acp).then((ok4) => {
+          if (ok4) pooled.needsBringUp = false;
+        });
+      } else {
+        void statelessSweepBeat(pooled.acp, pooled, () => closePool(key, "auth revoked"));
+      }
+    }
+  } else {
+    const seenPools = /* @__PURE__ */ new Set();
+    for (const s of sessions.values()) {
+      if (seenPools.has(s.poolKey)) continue;
+      seenPools.add(s.poolKey);
+      const pooled = hubPool.get(s.poolKey);
+      if (pooled) announcePoolHosts(s.poolKey, pooled);
+    }
   }
   for (const [ip, e] of initHits) {
     if (now > e.resetAt) initHits.delete(ip);
@@ -63403,11 +63855,12 @@ var health = (_req, res) => res.status(draining ? 503 : 200).json({
   draining,
   service: "jefrichat-mcp-http",
   hub: HUB,
+  stateless: STATELESS,
   sessions: sessions.size
 });
 app.get("/health", health);
 app.get("/mcp/health", health);
-app.post("/mcp", async (req, res) => {
+var statefulPost = async (req, res) => {
   const sessionId = req.headers["mcp-session-id"];
   if (sessionId && sessions.has(sessionId)) {
     const s = sessions.get(sessionId);
@@ -63473,7 +63926,7 @@ app.post("/mcp", async (req, res) => {
     try {
       pooled = await acquirePooledConn(token, poolKey);
     } catch (e) {
-      if (e instanceof JefriAuthError || e?.code === "ACP_AUTH_FAILED") {
+      if (e instanceof JefriAuthError || e?.code === "ACP_AUTH_FAILED" || e instanceof JefriHttpError && (e.status === 401 || e.status === 403)) {
         res.status(401).json({
           jsonrpc: "2.0",
           error: {
@@ -63498,7 +63951,7 @@ app.post("/mcp", async (req, res) => {
       return;
     }
     const mcp = new McpServer({ name: "jefrichat", version: "0.1.0" });
-    registerAcpTools(mcp, { ensureClient: async () => acp, inbox: pooled.inbox, serverUrl: HUB, local: false });
+    registerAcpTools(mcp, { ensureClient: async () => acp, inbox: pooled.inbox, serverUrl: HUB, local: false, stateless: STATELESS });
     let mySid;
     mcp.server.oninitialized = () => {
       try {
@@ -63510,14 +63963,14 @@ app.post("/mcp", async (req, res) => {
       }
     };
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID(),
+      sessionIdGenerator: () => randomUUID3(),
       onsessioninitialized: (sid) => {
         if (pooled.closed) {
           try {
             transport.close?.();
           } catch {
           }
-          log(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
+          log2(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
           return;
         }
         const meName = acp.identity.username;
@@ -63542,19 +63995,19 @@ app.post("/mcp", async (req, res) => {
             transport.close?.();
           } catch {
           }
-          log(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
+          log2(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
           return;
         }
         sessions.set(sid, { transport, acp, lastActive: Date.now(), tokenHash: sha256(token), inflight: 0, poolKey });
         mySid = sid;
-        log(`session ${sid.slice(0, 8)}\u2026 open as @${acp.identity.username} (${sessions.size} active, ${pooled.refs.size} on this connection)`);
+        log2(`session ${sid.slice(0, 8)}\u2026 open as @${acp.identity.username} (${sessions.size} active, ${pooled.refs.size} on this connection)`);
       }
     });
     transport.onclose = () => {
       const sid = transport.sessionId;
       if (sid) closeSession(sid, "client closed");
     };
-    const reservation = "init:" + randomUUID();
+    const reservation = "init:" + randomUUID3();
     pooled.refs.add(reservation);
     try {
       await mcp.connect(transport);
@@ -63570,7 +64023,7 @@ app.post("/mcp", async (req, res) => {
     error: { code: -32001, message: "Session expired \u2014 reinitialize (your token is still valid)" },
     id: null
   });
-});
+};
 var bySession = async (req, res) => {
   const sessionId = req.headers["mcp-session-id"];
   const s = sessionId ? sessions.get(sessionId) : void 0;
@@ -63588,8 +64041,58 @@ var bySession = async (req, res) => {
   touch(sessionId);
   await s.transport.handleRequest(req, res);
 };
-app.get("/mcp", bySession);
-app.delete("/mcp", bySession);
+if (STATELESS) {
+  app.post(
+    "/mcp",
+    statelessMcpHandler({
+      bearer,
+      acquire: async (token) => {
+        const poolKey = sha256(token).toString("hex");
+        const pooled = await acquirePooledConn(token, poolKey);
+        pooled.lastSeen = Date.now();
+        return pooled;
+      },
+      // registerTools below closes over the POOLED entry via acp — the presence
+      // resume/stop signal needs the pool, so it is looked up by identity of
+      // the shared client (one pool owns exactly one client instance).
+      classifyError: (e) => e instanceof JefriAuthError || e?.code === "ACP_AUTH_FAILED" || e instanceof JefriHttpError && (e.status === 401 || e.status === 403) ? "auth" : "hub",
+      registerTools: (mcp, acp, hooks) => registerAcpTools(mcp, {
+        ensureClient: async () => acp,
+        inbox: [],
+        serverUrl: HUB,
+        local: false,
+        stateless: true,
+        deferUntilDelivered: hooks.deferUntilDelivered,
+        // Round 26 #4a: a successful declaration RESUMES heartbeats (the
+        // user came back — the hub cleared its sign-off marker, the pool
+        // must clear its own), and a sign-off STOPS them proactively.
+        onPresenceDeclared: (status) => {
+          for (const key of hubPool.keys()) {
+            const pooled = hubPool.get(key);
+            if (pooled && pooled.acp === acp) {
+              if (status === "offline") pooled.hbSignedOff = true;
+              else {
+                pooled.hbSignedOff = false;
+                pooled.needsBringUp = false;
+              }
+              break;
+            }
+          }
+        }
+      }),
+      isDraining: () => draining,
+      tryAcquireInflight: (token) => tryAcquire(tokenInflight, sha256(token).toString("hex"), MAX_INFLIGHT_PER_TOKEN),
+      releaseInflight: (token) => release(tokenInflight, sha256(token).toString("hex")),
+      log: log2
+    })
+  );
+  app.get("/mcp", statelessMethodNotAllowed);
+  app.delete("/mcp", statelessMethodNotAllowed);
+} else {
+  app.post("/mcp", statefulPost);
+  app.get("/mcp", bySession);
+  app.delete("/mcp", bySession);
+}
 var server = http.createServer(app).listen(PORT, () => {
   console.error(`
   \u{1F310} Jefri Chat remote MCP (HTTP) on http://localhost:${PORT}/mcp`);