patchcord 0.6.41 → 0.6.43

package/bin/patchcord.mjs

@@ -683,6 +683,7 @@ if (cmd === "whoami") {
     codex: "codex", kimi: "kimi", "kimi-code": "kimi",
     opencode: "opencode", agy: "antigravity", antigravity: "antigravity",
     cursor: "cursor", grok: "grok", hermes: "hermes",
+    jcode: "jcode",
   };
   const resolveOpts = {};
   if (toolFlag) {
@@ -907,8 +908,28 @@ if (cmd === "upload") {
     console.error(`file is empty: ${filePath}`);
     process.exit(1);
   }
-  if (stats.size > 25 * 1024 * 1024) {
-    console.error(`file is ${(stats.size / 1024 / 1024).toFixed(1)}MB; max is 25MB for inline upload.`);
+  // THIS IS NOT THE UPLOAD LIMIT AND MUST NOT BE DESCRIBED AS ONE.
+  //
+  // It used to say "max is 25MB", which was wrong in both directions. The
+  // server's limit is PATCHCORD_ATTACHMENT_MAX_BYTES, 10 MiB by default and
+  // raisable on a self-hosted install. So this client refused files a
+  // configured server would have accepted, and accepted files every default
+  // server rejects: a 15 MB file passed here, got base64'd to 20 MB, was
+  // uploaded in full, and came back 413. A guard set above the real limit does
+  // not guard; it only pays the upload first.
+  //
+  // The client must not hold a copy of a number the server owns. What is left
+  // is a memory guard for THIS process: the file, its base64 (4/3 the size),
+  // and the JSON body are all resident at once. The real limit comes back from
+  // the server, in max_bytes, and is printed below.
+  const MEMORY_GUARD_BYTES = 256 * 1024 * 1024;
+  if (stats.size > MEMORY_GUARD_BYTES) {
+    console.error(
+      `file is ${(stats.size / 1024 / 1024).toFixed(1)}MB. This client buffers the ` +
+      `file and its base64 copy in memory and refuses above ` +
+      `${MEMORY_GUARD_BYTES / 1024 / 1024}MB. This is a client memory guard, not ` +
+      `the server's size limit — the server's limit is lower.`
+    );
     process.exit(1);
   }
 
@@ -923,7 +944,18 @@ if (cmd === "upload") {
     "POST", `${baseUrl}/api/agent/attachment/upload`, token, body
   );
   if (status !== "200") {
-    console.error(`✗ HTTP ${status}: ${(json && json.error) || respBody}`);
+    // Print max_bytes/allowed when the server sends them. Without this the user
+    // reads "attachment exceeds maximum size" and is not told the maximum, so
+    // their next move is to guess — or to ask an agent, which will guess.
+    let detail = "";
+    if (json && typeof json.max_bytes === "number") {
+      detail = ` (server limit ${(json.max_bytes / 1024 / 1024).toFixed(1)}MiB` +
+        (typeof json.actual_bytes === "number"
+          ? `, this file ${(json.actual_bytes / 1024 / 1024).toFixed(1)}MiB)` : ")");
+    } else if (json && Array.isArray(json.allowed)) {
+      detail = ` (allowed: ${json.allowed.join(", ")})`;
+    }
+    console.error(`✗ HTTP ${status}: ${(json && json.error) || respBody}${detail}`);
     process.exit(1);
   }
   console.log(json.path);
@@ -1500,6 +1532,48 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
       } catch {}
       return agWritten;
     }
+    if (tool === "jcode") {
+      // jcode is the ONLY harness here that gets a STDIO entry, and the reason
+      // is not preference: jcode has no HTTP transport. Its loader keeps an
+      // entry only when `is_stdio()` holds and drops the rest at load time --
+      // "MCP: Skipping non-stdio server '<name>' (http); HTTP/SSE transports
+      // are not yet supported" (crates/jcode-base/src/mcp/protocol.rs). So the
+      // `type: "http"` entry every other harness receives is READ, RECOGNISED
+      // AND DISCARDED by jcode, with a log line and no error. A bridge process
+      // is the only shape it can run today.
+      //
+      // NAMED patchcord-jcode, NOT patchcord, AND THAT IS LOAD-BEARING.
+      // jcode merges .jcode/mcp.json, then .mcp.json, then .claude/mcp.json,
+      // with later files overriding same-named servers. A guard currently saves
+      // us -- a non-stdio entry never displaces a working stdio one (their
+      // issue #653) -- but that guard holds only while jcode CANNOT run http.
+      // The day it gains that transport, a shared name means .mcp.json wins,
+      // and jcode silently starts authenticating as claude_code's agent: two
+      // harnesses, one credential, no error anywhere. A distinct name cannot
+      // collide in the first place. Codex already does this (patchcord-codex).
+      //
+      // The bridge command mirrors the OpenClaw fallback this file already
+      // prints. NOT VERIFIED END TO END from here: no jcode on this machine,
+      // and proving it needs a live token against the real endpoint.
+      const jdir = join(dir, ".jcode"); mkdirSync(jdir, { recursive: true });
+      return writeJson(join(jdir, "mcp.json"), (o) => {
+        o.mcpServers = o.mcpServers || {};
+        // No `type` key at all. jcode infers stdio from the presence of
+        // `command`, and writing "type": "stdio" is one more string to get
+        // wrong for a default that is already correct.
+        o.mcpServers["patchcord-jcode"] = {
+          command: "npx",
+          args: [
+            "mcp-remote",
+            `${baseUrl}/mcp`,
+            "--header",
+            `Authorization: Bearer ${token}`,
+            "--header",
+            `X-Patchcord-Machine: ${hostname}`,
+          ],
+        };
+      });
+    }
     if (tool === "hermes") {
       // Hermes reads MCP servers ONLY from its GLOBAL ~/.hermes/config.yaml
       // (mcp_servers key) — it ignores a project-local .mcp.json. So unlike the
@@ -1555,7 +1629,7 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
     console.error(`      .mcp.json         → claude_code`);
     console.error(`      .cursor/mcp.json  → cursor`);
     console.error(`  Defaulting would overwrite an agent you did not name, so there is no default.`);
-    console.error(`  One of: claude_code, codex, cursor, kimi, opencode, antigravity, grok, hermes`);
+    console.error(`  One of: claude_code, codex, cursor, kimi, opencode, antigravity, grok, hermes, jcode`);
     console.error(`  ${usage}`);
     process.exit(1);
   };
@@ -3194,7 +3268,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     // falls through to no choice instead of silently configuring a DIFFERENT
     // harness and writing someone's token to the wrong file.
     "vscode": "6", "zed": "7", "opencode": "8", "openclaw": "9", "antigravity": "10",
-    "cline": "11", "kimi": "12", "hermes": "13",
+    "cline": "11", "kimi": "12", "hermes": "13", "jcode": "15",
   };
 
 
@@ -3583,6 +3657,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   const isCline = choice === "11";
   const isKimi = choice === "12";
   const isHermes = choice === "13";
+  const isJcode = choice === "15";
 
   // MoonshotAI ships TWO CLIs that both use the `kimi` command:
   //   • kimi-cli (Python): supports `--mcp-config-file`, config in .kimi/mcp.json
@@ -3657,6 +3732,36 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     } catch (e) {
       console.log(`\n  ${yellow}⚠ Failed to write ${grokPath}: ${e.message}${r}`);
     }
+  } else if (isJcode) {
+    // jcode: project-local .jcode/mcp.json, and a STDIO entry rather than the
+    // http one every other harness gets. jcode has no HTTP transport -- it
+    // recognises `type: "http"` and drops the server at load time with a log
+    // line. See the writeWorkerConfig branch above for why the entry is named
+    // `patchcord-jcode` and not `patchcord`; the short version is that jcode
+    // merges .jcode/mcp.json, .mcp.json and .claude/mcp.json by server NAME,
+    // so a shared name lets claude_code's credential silently become jcode's
+    // the day jcode gains http support.
+    const jcodePath = join(cwd, ".jcode", "mcp.json");
+    try {
+      mkdirSync(dirname(jcodePath), { recursive: true });
+      let jobj = {};
+      try { jobj = JSON.parse(readFileSync(jcodePath, "utf-8")); } catch {}
+      jobj.mcpServers = jobj.mcpServers || {};
+      jobj.mcpServers["patchcord-jcode"] = {
+        command: "npx",
+        args: [
+          "mcp-remote",
+          `${serverUrl}/mcp`,
+          "--header",
+          `Authorization: Bearer ${token}`,
+        ],
+      };
+      writeSecureFile(jcodePath, JSON.stringify(jobj, null, 2) + "\n");
+      console.log(`\n  ${green}✓${r} jcode configured: ${dim}${jcodePath}${r}`);
+      console.log(`  ${dim}Bridged over stdio — jcode does not speak HTTP MCP yet.${r}`);
+    } catch (e) {
+      console.log(`\n  ${yellow}⚠ Failed to write ${jcodePath}: ${e.message}${r}`);
+    }
   } else if (isHermes) {
     // Hermes: global only (~/.hermes/config.yaml, YAML, mcp_servers key)
     const hermesPath = join(HOME, ".hermes", "config.yaml");
@@ -4324,10 +4429,11 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   // Hermes is global config (~/.hermes/config.yaml) — no per-project file to ignore.
   if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isCline && !isHermes) {
     const gitignorePath = join(cwd, ".gitignore");
-    const configFile = isKimiCode ? ".kimi-code/mcp.json" : isKimi ? ".kimi/mcp.json" : isCodex ? ".codex/config.toml" : isCursor ? ".cursor/mcp.json" : isGrok ? ".grok/config.toml" : isVSCode ? ".vscode/mcp.json" : isOpenCode ? "opencode.json" : isAntigravity ? ".agents/mcp_config.json" : ".mcp.json";
+    const configFile = isJcode ? ".jcode/mcp.json" : isKimiCode ? ".kimi-code/mcp.json" : isKimi ? ".kimi/mcp.json" : isCodex ? ".codex/config.toml" : isCursor ? ".cursor/mcp.json" : isGrok ? ".grok/config.toml" : isVSCode ? ".vscode/mcp.json" : isOpenCode ? "opencode.json" : isAntigravity ? ".agents/mcp_config.json" : ".mcp.json";
     // Forms that already cover this config (its file or its dir)
     const patterns = [configFile];
-    if (isKimiCode) patterns.push(".kimi-code/");
+    if (isJcode) patterns.push(".jcode/");
+    else if (isKimiCode) patterns.push(".kimi-code/");
     else if (isKimi) patterns.push(".kimi/");
     else if (isCodex) patterns.push(".codex/");
     else if (isCursor) patterns.push(".cursor/");
@@ -4352,7 +4458,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     }
   }
 
-  const toolName = isHermes ? "Hermes" : isKimiCode ? "Kimi Code" : isKimi ? "Kimi Code" : isAntigravity ? "Antigravity CLI" : isCline ? "Cline" : isOpenClaw ? "OpenClaw" : isOpenCode ? "OpenCode" : isZed ? "Zed" : isVSCode ? "VS Code" : isGemini ? "Gemini CLI" : isWindsurf ? "Windsurf" : isGrok ? "Grok CLI" : isCursor ? "Cursor" : isCodex ? "Codex" : "Claude Code";
+  const toolName = isJcode ? "jcode" : isHermes ? "Hermes" : isKimiCode ? "Kimi Code" : isKimi ? "Kimi Code" : isAntigravity ? "Antigravity CLI" : isCline ? "Cline" : isOpenClaw ? "OpenClaw" : isOpenCode ? "OpenCode" : isZed ? "Zed" : isVSCode ? "VS Code" : isGemini ? "Gemini CLI" : isWindsurf ? "Windsurf" : isGrok ? "Grok CLI" : isCursor ? "Cursor" : isCodex ? "Codex" : "Claude Code";
 
   if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isCline && !isKimi && !isHermes) {
     console.log(`\n  ${dim}To connect a second agent:${r}`);

package/harnesses.json

@@ -0,0 +1,245 @@
+{
+  "$comment": [
+    "Machine-readable harness capability registry. Consumed by mux (lead@mux-v2) to decide",
+    "whether a seat can hold a Patchcord listener and whether two seats may share a host.",
+    "",
+    "TWO SCOPE FIELDS ON PURPOSE. `installer_scope` is where OUR installer writes.",
+    "`harness_scope` is what the HARNESS itself supports. They are not the same question and",
+    "conflating them is what this file exists to prevent: in one thread I answered three",
+    "harness-capability questions with installer behaviour and was wrong all three times.",
+    "hermes is the worked example — our installer writes one global file, and hermes supports",
+    "many isolated profiles. 'Our installer writes X' never implies 'the harness only does X'.",
+    "",
+    "EVIDENCE IS EARNED, NOT TYPED. This file may only ever say \"declared\" or \"absent\".",
+    "\"tested\" is not a legal value here — it lives in tests/test-harness-registry.mjs, in a",
+    "list that names what was observed and by whom. A writer can type a confident guess into",
+    "a data file; a writer cannot type an observation into a test they did not run. If you",
+    "believe a row deserves \"tested\", add it there with the observation, not here.",
+    "",
+    "Any row whose listener.wake is not \"none\" MUST have a real subscribe path on disk, or",
+    "carry blocked_reason saying why not. hermes is why: it HAS a subscribe skill directory",
+    "and, until 0.6.41, could not actually be armed. Directory presence is necessary, never",
+    "sufficient."
+  ],
+  "version": 1,
+  "harnesses": [
+    {
+      "id": "claude_code",
+      "aliases": ["claude"],
+      "cli": "claude",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": ".mcp.json",
+      "harness_scope": "project",
+      "listener": {
+        "wake": "realtime",
+        "mechanism": "subscribe-skill-under-monitor",
+        "self_arm": true,
+        "survives_wake": true,
+        "evidence": "declared"
+      }
+    },
+    {
+      "id": "codex",
+      "aliases": [],
+      "cli": "codex",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": ".codex/config.toml",
+      "harness_scope": "project",
+      "listener": {
+        "wake": "none",
+        "mechanism": "stop-hook-nudge-only",
+        "self_arm": false,
+        "survives_wake": null,
+        "evidence": "declared",
+        "note": "A stop hook fires at the END of a turn. An idle codex seat hears nothing. No subscribe skill exists for codex in this package."
+      }
+    },
+    {
+      "id": "cursor",
+      "aliases": [],
+      "cli": "cursor-agent",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": ".cursor/mcp.json",
+      "harness_scope": "unknown",
+      "listener": {
+        "wake": "realtime",
+        "mechanism": "subscribe-skill-background-shell",
+        "self_arm": true,
+        "survives_wake": null,
+        "evidence": "declared",
+        "note": "The skill claims it wakes the agent. Nobody in this repo has watched it happen."
+      }
+    },
+    {
+      "id": "grok",
+      "aliases": ["grok_cli", "grok_build"],
+      "cli": "grok",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": ".grok/config.toml",
+      "harness_scope": "project",
+      "listener": {
+        "wake": "realtime",
+        "mechanism": "subscribe-skill",
+        "self_arm": true,
+        "survives_wake": null,
+        "evidence": "declared",
+        "note": "Grok resolves configs from cwd up to the git root, so per-seat identity works. Wake is claimed by the skill, not observed."
+      }
+    },
+    {
+      "id": "opencode",
+      "aliases": [],
+      "cli": "opencode",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": "opencode.json",
+      "harness_scope": "unknown",
+      "listener": {
+        "wake": "realtime",
+        "mechanism": "installed-plugin",
+        "self_arm": true,
+        "survives_wake": true,
+        "evidence": "declared",
+        "note": "The installer writes .opencode/plugins/patchcord.js, which spawns `patchcord subscribe` and calls client.session.prompt() on each message. It prompts on the realtime event rather than session.idle deliberately: session.idle re-prompting has a teardown race in headless `opencode run`."
+      }
+    },
+    {
+      "id": "kimi",
+      "aliases": [],
+      "cli": "kimi",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": ".kimi-code/mcp.json",
+      "harness_scope": "unknown",
+      "listener": {
+        "wake": "poll",
+        "mechanism": "poll-script",
+        "self_arm": true,
+        "survives_wake": false,
+        "evidence": "declared",
+        "note": "NOT realtime. patchcord-subscribe.sh polls /api/inbox and EXITS 0 on a pending count; Kimi starts a turn when a background task reaches a terminal state. So the listener dies on every delivery and the agent must re-arm it. Re-arm is the failure point: an agent that skips it is silently deaf from then on."
+      }
+    },
+    {
+      "id": "hermes",
+      "aliases": [],
+      "cli": "hermes",
+      "kind": "terminal",
+      "installer_scope": "global",
+      "installer_config": "~/.hermes/config.yaml",
+      "harness_scope": "per-profile",
+      "installer_defect": "The path is hardcoded to ~/.hermes/config.yaml. The installer never calls `hermes config path` and does not know profiles exist, so installing while a non-default profile is active writes the DEFAULT profile's config — the wrong file, silently. Not fixed as of 0.6.41.",
+      "listener": {
+        "wake": "realtime",
+        "mechanism": "webhook-bridge",
+        "self_arm": false,
+        "survives_wake": true,
+        "evidence": "declared",
+        "note": "`patchcord subscribe --hermes` POSTs to a Hermes gateway webhook per message; the gateway injects a prompt. No re-arm needed. self_arm is false: a human creates the route and starts the bridge once. A deploy that waits N seconds for a SEAT-started listener will fail hermes forever while hermes is fully push-capable.",
+        "blocked_until": "0.6.41",
+        "blocked_reason": "Before 0.6.41 the `patchcord subscribe` wrapper spawned subscribe.mjs with no arguments, so --hermes never reached the child that gates on it. The env var arrived, the flag did not, the flag is the gate. The bridge was unreachable by its own documented command and failed silently. Fixed; not yet observed end to end."
+      }
+    },
+    {
+      "id": "antigravity",
+      "aliases": ["agy"],
+      "cli": "antigravity",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": ".agents/mcp_config.json",
+      "harness_scope": "unknown",
+      "listener": {
+        "wake": "none",
+        "mechanism": null,
+        "self_arm": false,
+        "survives_wake": null,
+        "evidence": "declared",
+        "note": "No subscribe skill of any kind in this package."
+      }
+    },
+    {
+      "id": "openclaw",
+      "aliases": [],
+      "cli": "openclaw",
+      "kind": "terminal",
+      "installer_scope": "unknown",
+      "installer_config": "~/.openclaw/openclaw.json",
+      "harness_scope": "unknown",
+      "listener": {
+        "wake": "none",
+        "mechanism": null,
+        "self_arm": false,
+        "survives_wake": null,
+        "evidence": "absent",
+        "note": "installer_scope is unknown, not global. We PREFER `openclaw mcp set patchcord`, so openclaw decides where the entry lands; the ~/.openclaw path is only our fallback when that CLI is missing. Nobody here has openclaw installed. Do not refuse a second openclaw seat on the strength of this row — refuse on a test or not at all."
+      }
+    },
+    {
+      "id": "windsurf",
+      "aliases": [],
+      "cli": null,
+      "kind": "editor",
+      "installer_scope": "global",
+      "installer_config": "~/.codeium/windsurf/mcp_config.json",
+      "harness_scope": "unknown",
+      "listener": { "wake": "none", "mechanism": null, "self_arm": false, "survives_wake": null, "evidence": "declared" }
+    },
+    {
+      "id": "vscode",
+      "aliases": [],
+      "cli": null,
+      "kind": "editor",
+      "installer_scope": "project",
+      "installer_config": ".vscode/mcp.json",
+      "harness_scope": "unknown",
+      "listener": { "wake": "none", "mechanism": null, "self_arm": false, "survives_wake": null, "evidence": "declared" }
+    },
+    {
+      "id": "zed",
+      "aliases": [],
+      "cli": null,
+      "kind": "editor",
+      "installer_scope": "global",
+      "installer_config": "~/.config/zed/settings.json",
+      "harness_scope": "unknown",
+      "listener": { "wake": "none", "mechanism": null, "self_arm": false, "survives_wake": null, "evidence": "declared" }
+    },
+    {
+      "id": "cline",
+      "aliases": [],
+      "cli": null,
+      "kind": "editor",
+      "installer_scope": "global",
+      "installer_config": "cline_mcp_settings.json (VS Code globalStorage)",
+      "harness_scope": "unknown",
+      "listener": { "wake": "none", "mechanism": null, "self_arm": false, "survives_wake": null, "evidence": "declared" }
+    },
+    {
+      "id": "jcode",
+      "aliases": [],
+      "cli": "jcode",
+      "kind": "terminal",
+      "installer_scope": "project",
+      "installer_config": ".jcode/mcp.json",
+      "harness_scope": "project",
+      "listener": {
+        "wake": "none",
+        "mechanism": null,
+        "self_arm": false,
+        "survives_wake": null,
+        "evidence": "declared",
+        "note": "STDIO ONLY, WHICH IS WHY THIS ROW IS NOT LIKE THE OTHERS. jcode reads .jcode/mcp.json, .mcp.json and .claude/mcp.json, so it ALREADY finds the Claude Code entry we write - and drops it, because jcode supports stdio servers only and skips type http/sse at load time with a log line (crates/jcode-base/src/mcp/protocol.rs, retain on is_stdio). So our installer writes a stdio bridge entry instead of the http entry every other harness gets. Two consequences a reader must not undo: the server is named patchcord-jcode, NOT patchcord, because jcode merges those three files with later ones overriding by NAME - a shared name means the day jcode gains http transport, the .mcp.json entry becomes runnable and silently overrides, and jcode starts authenticating as claude_code's agent. And no wake: no subscribe path exists for jcode in this package."
+      }
+    }
+  ],
+  "retired": [
+    {
+      "id": "gemini",
+      "reason": "Retired as an install target; Antigravity covers Google's agent. CLIENT_TYPE_MAP slot \"5\" is left UNASSIGNED rather than reused, so a stale connect page sending client_type=gemini falls through to no choice instead of silently configuring a different harness and writing someone's token to the wrong file. Do not mirror the gap as a bug and do not fill it."
+    }
+  ]
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "patchcord",
-  "version": "0.6.41",
+  "version": "0.6.43",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "scripts": {
-    "version": "node scripts/sync-plugin-version.mjs && git add .claude-plugin/plugin.json"
+    "version": "node scripts/sync-plugin-version.mjs && git add .claude-plugin/plugin.json agent-plugin/plugin.json"
   },
   "author": "ppravdin",
   "license": "MIT",
@@ -32,6 +32,8 @@
     "per-project-skills/",
     "commands/",
     "README.md",
-    "plugins/"
+    "plugins/",
+    "agent-plugin/",
+    "harnesses.json"
   ]
 }

package/per-project-skills/codex/SKILL.md

@@ -99,7 +99,7 @@ To message a user outside your namespace, use `@username` as the to_agent. Examp
 ```
 patchcord upload /path/to/report.md --mime text/markdown
 ```
-Prints the storage path. Pass it to `send_message`. No curl, no base64 in chat. 25MB cap.
+Prints the storage path. Pass it to `send_message`. No curl, no base64 in chat. The size limit belongs to the server: 10 MiB by default, raisable on a self-hosted server. Too large prints the server's own limit.
 
 **Public URLs → `attachment(relay=true, ...)`:**
 ```

package/per-project-skills/cursor/inbox/SKILL.md

@@ -105,7 +105,7 @@ To message a user outside your namespace, use `@username` as the to_agent. Examp
 ```
 patchcord upload /path/to/report.md --mime text/markdown
 ```
-Prints the storage path. Pass that path to `send_message`. No curl, no base64 in chat, no presigned URLs. 25MB cap.
+Prints the storage path. Pass that path to `send_message`. No curl, no base64 in chat, no presigned URLs. The size limit is the server's, not a number to remember: it is 10 MiB by default and a self-hosted server can raise it. If a file is too large the command prints the server's own limit.
 
 **Public URLs → `attachment(relay=true, ...)`:**
 ```