@pcircle/memesh 4.9.4 → 4.10.2

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
       "name": "memesh",
       "source": "./",
       "description": "MeMesh \u2014 agentic memory for coding agents. Captured from the agent's real work via hooks, recalled when it acts. One SQLite file, zero cloud required.",
-      "version": "4.9.4",
+      "version": "4.10.2",
       "author": {
         "name": "PCIRCLE AI"
       },

package/.claude-plugin/plugin.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "PCIRCLE AI"
   },
-  "version": "4.9.4",
+  "version": "4.10.2",
   "mcpServers": "./.claude-plugin/mcp.json",
   "homepage": "https://github.com/PCIRCLE-AI/memesh",
   "repository": "https://github.com/PCIRCLE-AI/memesh",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memesh",
   "description": "MeMesh — agentic memory for coding agents.",
-  "version": "4.9.4",
+  "version": "4.10.2",
   "mcpServers": "./.codex-plugin/mcp.json"
 }

package/AGENTS.md

@@ -9,12 +9,46 @@ host is recallable from all of them. Not installed yet? Follow
 
 1. **Session start — load, don't re-explore.** Call the `briefing` tool once
    (CLI: `memesh briefing`). It returns the assembled work topology for the
-   current project: goal / next / blocked / done, decisions, lessons,
-   knowledge, recent activity. Read that instead of re-reading the repo to
-   reconstruct context.
+   current project: decisions, lessons, knowledge and recent activity are
+   always included; the stated goal / next / blocked / done and the capped
+   durable-memory index (`memesh briefing --index` prints just that, one
+   line each with its `[mem:id]` handle) are added at `standard` (the
+   default) and up. How much is assembled depends on the `briefing` setting
+   — `minimal` (this project only: decisions, lessons, knowledge, recent
+   activity, with the repository state in front whenever anything else is
+   injected — nothing else), `standard` (+ the task state
+   when fresh, + the durable-memory index — **default**), `full` (+ global
+   memory + other projects' recent activity, the pre-#360 memory-block
+   behaviour — except when the task state itself is stale or of unknown
+   age, where the one-line replacement below applies at `full` too) — set
+   with `memesh config set briefing <level>`. The SessionStart hook
+   additionally appends a work-package notice at `full` (see below); that
+   notice is a host-agent instruction, not memory, and this tool never
+   includes it, at any level. A
+   goal/next/blocked/done stated more than 72 hours ago, or whose timestamp
+   is missing/unreadable/implausibly future-dated, is not injected as
+   current at any level — only one line saying so and how to see it
+   (`memesh task`). Only `minimal` can be fully silent: when the project has
+   no ranked memories, no stale-state flag and no unread message (a fresh
+   task state may exist — `minimal` does not show it — and there is no
+   index to fall back to), nothing is injected at all, the repository state
+   included — no empty framing; `standard`/`full` still show the index's
+   own "no durable memories yet" line even then, because that line is
+   itself informative. The index is a recent
+   window, not everything: it holds at most 40 lines / 3072 bytes, memories
+   untouched for 180 days collapse into a single count line with no
+   `[mem:id]`, and whatever else is cut past those caps becomes an
+   `N more — memesh recall --tag "project:…"` line, also with no
+   `[mem:id]`. Treat the index as "recent, capped" — when it says there is
+   more, call `recall` rather than assuming the index already covers it.
+   Read the index instead of re-reading the repo to reconstruct context.
 2. **When the user states a goal, a next step, or a blocker — record it.**
-   Call the `task_state` tool (CLI: `memesh task --goal "…" --next "…"`). It
-   is injected at the start of the next session and acted on as fact.
+   Call the `task_state` tool (CLI: `memesh task --goal "…" --next "…"`).
+   Fresh state is injected at the start of the next session at
+   `standard`/`full` (the default and above) and acted on as fact;
+   `minimal` never shows a fresh state, but a stale or unknown-age one
+   still gets a one-line flag at every level — `memesh task` always shows
+   the complete stored state.
    - An empty string **clears** a field: pass `blocked: ""` (CLI:
      `memesh task --blocked ""`) once a blocker is resolved.
    - **Record only what the user actually said.** Never infer goal / next /
@@ -41,33 +75,49 @@ host is recallable from all of them. Not installed yet? Follow
    declarations remain unknown. Then send a `message`. The host's own push tool (Claude
    Code's `SendMessage`, a Codex queue) delivers a wakeup; it is not the
    record, and it cannot reach an agent on a different host or one that is
-   not running. Generic `briefing` and SessionStart context has no recipient
-   identity and stays quiet. Check an inbox with the exact `project` and
-   `recipient`; poll first, then fetch each returned `message_id`. Fetching
-   does not acknowledge.
+   not running. Generic `briefing` has no recipient identity and stays quiet;
+   so do the SessionStart and prompt hooks, unless the session declared who it
+   is by starting with `MEMESH_RECIPIENT=<id>`, in which case they say how many
+   messages wait for that recipient and in which project. Check an inbox with
+   the exact `project` and `recipient`; poll first, then fetch each returned
+   `message_id`, then record `intake` for it: fetching alone does not
+   acknowledge and does not end the reminder.
 
 ## All 12 MCP tools
 
 | Tool | Purpose |
 |---|---|
 | `work_package` | Prepare one bounded untrusted digest (calendar-selected) or transcript package from the newest Claude Code session under the client's single matching MCP workspace root; submit one strictly validated result for pending human review or defer without durable change. Submission retains bounded redacted source turns for comparison; agents cannot apply or reject, and hashes identify freshness and workspace scope rather than authentication. |
-| `remember` | Store knowledge as an entity with observations, tags, and relations |
+| `remember` | Store knowledge as an entity with observations, tags, and relations; or pass only `note` (free text) and the title, observations and name are derived; `replace: true` rewrites a named memory, keeping the old version as history |
 | `recall` | Search stored knowledge (words are OR-ed, ranked by relevance); empty query lists recent |
 | `forget` | Archive an entity (soft-delete), or remove one observation via the `observation` parameter |
 | `export` | Export memories as portable JSON for sharing or backup |
 | `import` | Import a JSON export; `merge_strategy` (required): skip / append / overwrite |
 | `learn` | Record a structured lesson: error, root cause, fix, prevention |
 | `task_state` | Read or update where the work stands: goal / next / blocked / done |
-| `briefing` | The assembled work topology; exact `project` + `recipient` can surface only that recipient's unfetched deliveries |
+| `briefing` | The assembled work topology, closing, by default, with a capped index of the project's durable memories (the `briefing` setting — `minimal` / `standard` / `full` — controls how much is assembled); exact `project` + `recipient` can surface only that recipient's unfetched deliveries |
 | `user_patterns` | Analyze work schedule, tool preferences, and focus areas from memory |
 | `improvement` | Propose an evidence-linked product improvement or read its status; only a human may accept/reject it |
 | `message` | Discover live agents, then exchange exact-recipient untrusted messages: durable JSON payload max 64 KiB; complete native envelope max 16 KiB with distinct `native_message_too_large` and `recipient_unavailable` errors; delivery reads/acceptance never imply ACK or disposition |
 
 ## Memory hygiene
 
+- **The cheapest write is `remember({ note: "…" })`.** First line → title,
+  each following paragraph → one observation, name derived from the text
+  (the same text twice is one memory). Optional `type` (default `note`),
+  `tags`, `name`. The response echoes the derived shape under `derived`.
 - **Reuse a stable `name` to append.** Calling `remember` with an existing
   name appends observations and dedupes tags. A fresh name for every update
   creates duplicates that recall must wade through.
+- **Correct a memory in one call**: `remember` it again with its `name` and
+  `replace: true`. `type` is not needed — the memory keeps the one it has.
+  Pass a `type` only to reclassify: one that differs from what is stored
+  rewrites it. (`type` is still required on a call with no `note` that is
+  not a `replace`, and on a `replace` whose `name` does not exist yet.) Observations are rewritten (tags too
+  when you pass them, the title when you pass `title` or `note`); what was
+  there moves to `metadata.replaced_history` with the time it was replaced,
+  so the wrong line stops showing up in recall but is not lost (recall shows
+  only `replaced_history_count`; `export` has the versions).
 - **Replacing a decision**: `remember` the new one with a relation of type
   `supersedes` pointing at the old — the old entity is archived (recoverable),
   not left active to contradict the new one.
@@ -97,8 +147,10 @@ host is recallable from all of them. Not installed yet? Follow
 
 Under Claude Code with the MeMesh plugin, hooks capture automatically:
 
-- **SessionStart** injects the work topology (the same block `briefing`
-  returns) at the top of the session.
+- **SessionStart** injects the work topology (the same memory block
+  `briefing` returns, plus a work-package notice at `full` that `briefing`
+  never includes) at the top of the session, whenever the configured level
+  has something to show; an empty project at `minimal` injects nothing.
 - **PreToolUse (Edit|Write)** surfaces memories related to the file being
   edited.
 - **PostToolUse (Bash)** records git commits with diff stats.
@@ -106,6 +158,16 @@ Under Claude Code with the MeMesh plugin, hooks capture automatically:
   decision just made — once per tool per session. It only reminds; unlike
   the hooks above, it writes nothing to the graph itself.
 - **Stop** captures bounded session evidence, including observed error/fix signals.
+  It also ingests the project's Claude Code memory directory
+  (`~/.claude/projects/<slug>/memory/*.md` — one memory per file with
+  `name`/`description`/`metadata.type` frontmatter, tagged `source:note-file`;
+  a file that disappears is tagged `source:note-file:missing`, never deleted),
+  and when the turn since the last Stop approved a plan, answered a question,
+  committed, or turned a test red then green — with no `remember`/`learn` call
+  and no note-file change — it shows one line suggesting a `remember`. Both
+  the session capture and the note-directory ingestion are writes, so both
+  stop when auto-capture is off (`memesh config set autoCapture false`, or
+  `MEMESH_AUTO_CAPTURE=false`); the reminder line still runs either way.
 - **PreCompact** saves important knowledge before history is compressed.
 - **UserPromptSubmit** detects "remember this" intent in the prompt.
 - **PreToolUse (Bash)** fires accepted lesson-guards: a fenced warning

package/README.de.md

@@ -43,7 +43,7 @@ MeMesh merkt sich das für ihn. Claude-Code-Hooks erfassen und laden den laufend
 - **Erfassen, Erinnern, Hinweise und Schutz im richtigen Moment.** MeMesh liefert **9 Hook-Befehle** über seine Claude-Code- und Codex-Integrationen: Acht Claude-Code-Hooks laufen beim Sitzungsstart, vor Dateiänderungen, nach `git commit`, nach einem freigegebenen Plan oder einer beantworteten Frage, wenn Claude aufhört, vor dem Kürzen des Kontexts, bei „remember this“ (in 5 Sprachen, Deutsch nicht darunter) und vor einem riskanten Befehl, der eine bestätigte Lektion wiederholen würde. Die Plan-/Frage- und „remember this“-Hooks erinnern den Agenten nur an `remember`; der neunte Befehl verarbeitet sowohl Codex SessionStart als auch SessionEnd und registriert beziehungsweise beendet eine geeignete gewöhnliche Codex-CLI-Sitzung kontrolliert.
 - **Ein Gedächtnis für alle Tools.** Was du heute in Claude Code speicherst, steht morgen auch Codex oder Cursor zur Verfügung.
 - **Agenten können sich Nachrichten hinterlassen.** Der dauerhafte lokale Posteingang übersteht Neustarts; unter macOS oder Linux kann auch eine exakt adressierte, aktive gewöhnliche Codex-CLI-Sitzung mit MeMesh-Plugin die begrenzte Nachricht über ihre native Queue erhalten.
-- **Ein Dashboard** zum Stöbern: 5 Tabs, 11 Sprachen, unter `http://localhost:3737/dashboard`.
+- **Ein Dashboard** zum Stöbern: 4 Tabs, 11 Sprachen, unter `http://localhost:3737/dashboard`.
 
 ---
 
@@ -119,11 +119,11 @@ memesh remember "Login verwendet OAuth 2.0 mit PKCE"
 memesh recall "Login"
 # -> findet die PKCE-Entscheidung
 
-memesh briefing        # was der Agent über dieses Projekt weiß und wo du aufgehört hast
+memesh briefing        # was der Agent über dieses Projekt weiß
 memesh serve           # startet den lokalen Server und gibt die Dashboard-URL aus
 ```
 
-Lass `memesh serve` laufen und öffne die ausgegebene URL. Für die Memory-Tools brauchst du in Claude Code nicht einmal das Terminal: Sag im Chat „remember this“, und das Briefing kommt bei jedem Sitzungsstart von selbst.
+Lass `memesh serve` laufen und öffne die ausgegebene URL. Für die Memory-Tools brauchst du in Claude Code nicht einmal das Terminal: Sag im Chat „remember this“, und sobald es etwas zu zeigen gibt, kommt das Briefing beim Sitzungsstart von selbst.
 
 Zwei Dinge, die du kennen solltest, sobald Erinnerungen da sind:
 
@@ -139,14 +139,14 @@ Alle Befehle und Tools: [docs/api/API_REFERENCE.md](docs/api/API_REFERENCE.md).
 | Tool | Was es tut |
 |------|-------------|
 | `work_package` | Einen begrenzten, nicht vertrauenswürdigen Kalender-Digest oder ein Claude-Code-Transkript-Paket unter einem passenden MCP-Workspace-Root vorbereiten; genau ein striktes Ergebnis zur menschlichen Prüfung einreichen oder ohne dauerhafte Änderung zurückstellen. Die Transkript-Einreichung bewahrt begrenzte redigierte Quellzüge auf; Dateipfad, verborgenes Denken, Provider-, Embedding- oder Vektordaten werden nicht offengelegt. |
-| `remember` | Wissen mit Beobachtungen, Relationen und Tags speichern |
+| `remember` | Wissen mit Beobachtungen, Relationen und Tags speichern — oder Freitext als `note` übergeben, woraus Titel, Beobachtungen und Name abgeleitet werden; `replace` korrigiert eine Erinnerung an Ort und Stelle |
 | `recall` | Lokale FTS5-Suche mit Multi-Faktor-Bewertung (Relevanz, Aktualität, Häufigkeit, Konfidenz, Abruf-Auswirkung) |
 | `forget` | Soft-Archivierung (löscht nie) oder entfernt spezifische Beobachtungen |
 | `export` | Memories als JSON sichern, migrieren oder zwischen kompatiblen Agenten übertragen |
 | `import` | Memories mit Merge-Strategien importieren (Skip / Overwrite / Append) |
 | `learn` | Strukturierte Lektionen aus Fehlern erfassen (Fehler, Grundursache, Behebung, Prävention) |
 | `task_state` | Arbeitsstand lesen oder festhalten — Ziel, nächster Schritt, Blocker, gerade Erledigtes |
-| `briefing` | Die Arbeitstopologie für jeden MCP-Client; allgemeiner Kontext bleibt still, während exakte Angaben für `project` + `recipient` nur dessen noch nicht abgerufene Zustellungen anzeigen |
+| `briefing` | Die Arbeitstopologie für jeden MCP-Client wird standardmäßig mit einem begrenzten Index der dauerhaften Memories des Projekts abgeschlossen; wie viel Inhalt zusammengestellt wird, steuert die Einstellung `briefing` (`minimal` / `standard` / `full`); allgemeiner Kontext bleibt still, während exakte Angaben für `project` + `recipient` nur dessen noch nicht abgerufene Zustellungen anzeigen |
 | `user_patterns` | Arbeitsmuster analysieren — Zeitplan, Tools, Stärken, Lernbereiche |
 | `improvement` | Evidenzverknüpfte Produktverbesserung zur menschlichen Prüfung vorschlagen oder ihren Status lesen; Agenten können sie nicht selbst annehmen oder ablehnen |
 | `message` | Aktive Agenten finden und nicht vertrauenswürdige Nachrichten mit exaktem Empfänger austauschen. Dauerhafter JSON-Payload: max. 64 KiB; vollständiger nativer Envelope: max. 16 KiB mit getrennten Fehlern `native_message_too_large` und `recipient_unavailable`. Native Annahme, Discovery, Poll und Fetch bedeuten weder Bestätigung noch Workflow-Status |

package/README.md

@@ -43,7 +43,7 @@ MeMesh remembers for it. Claude Code hooks capture and restore routine context;
 - **Capture, recall, reminders, and safeguards at the right time.** MeMesh ships **9 hooks** (nine hook commands) across its Claude Code and Codex integrations: eight Claude Code hooks run at session start, before file edits, after `git commit`, after a plan is approved or a question answered, when Claude stops, before context compaction, when you say "remember this" (5 languages), and before a risky command that repeats an accepted lesson. The plan/question and "remember this" hooks only remind the agent to call `remember`; the ninth command handles both Codex SessionStart and SessionEnd to register and retire an eligible ordinary Codex CLI session.
 - **One memory for all your tools.** A decision stored from Claude Code is available to Codex or Cursor the next day.
 - **Agents can leave each other messages.** A durable inbox survives restarts; on macOS or Linux, an ordinary Codex CLI thread with the MeMesh plugin can keep a bounded post-turn native queue window and consume the accepted message when that same thread resumes.
-- **A dashboard** to browse it all: 5 tabs, 11 languages, at `http://localhost:3737/dashboard`.
+- **A dashboard** to browse it all: 4 tabs, 11 languages, at `http://localhost:3737/dashboard`.
 
 ---
 
@@ -119,11 +119,11 @@ memesh remember "Login uses OAuth 2.0 with PKCE"
 memesh recall "login"
 # -> finds the PKCE decision
 
-memesh briefing        # what the agent knows about this project, where you left off
+memesh briefing        # what the agent knows about this project
 memesh serve           # starts the local server and prints the dashboard URL
 ```
 
-Keep `memesh serve` running and open the printed URL. In Claude Code you do not even need the terminal for memory tools: say "remember this" in chat, and the briefing arrives on its own at every session start.
+Keep `memesh serve` running and open the printed URL. In Claude Code you do not even need the terminal for memory tools: say "remember this" in chat, and once there is something to show, the briefing arrives on its own at session start.
 
 Two things worth knowing once you have memories:
 
@@ -139,14 +139,14 @@ Full command and tool reference: [docs/api/API_REFERENCE.md](docs/api/API_REFERE
 | Tool | What it does |
 |------|-------------|
 | `work_package` | Prepare one bounded untrusted calendar digest or Claude Code transcript package under one matching MCP workspace root; submit one strict result for pending human review, or defer without durable change. Transcript submission retains bounded redacted source turns; no file path, hidden reasoning, provider, embedding, or vector data is exposed. |
-| `remember` | Store knowledge with observations, relations, and tags |
+| `remember` | Store knowledge as observations, relations and tags — or pass free text as `note` and the title, observations and name are derived; `replace` corrects a memory in place |
 | `recall` | Local FTS5 search with multi-factor scoring (relevance, recency, frequency, confidence, recall impact) |
 | `forget` | Soft-archive (never deletes) or remove specific observations |
 | `export` | Back up, migrate, or move memories as JSON between compatible agents |
 | `import` | Import memories with merge strategies (skip / overwrite / append) |
 | `learn` | Record structured lessons from mistakes (error, root cause, fix, prevention) |
 | `task_state` | Read or record where the work stands — goal, next step, blocker, what was just finished |
-| `briefing` | The assembled work topology for any MCP client; generic context stays quiet, while exact `project` + `recipient` can surface only that recipient's unfetched deliveries |
+| `briefing` | The assembled work topology for any MCP client, closing, by default, with a capped index of the project's durable memories (the `briefing` setting — `minimal` / `standard` / `full` — controls how much is assembled); generic context stays quiet, while exact `project` + `recipient` can surface only that recipient's unfetched deliveries |
 | `user_patterns` | Analyze your work patterns — schedule, tools, strengths, learning areas |
 | `improvement` | Stage an evidence-linked product improvement for human review, or read its status; agents cannot accept or reject it |
 | `message` | Discover live agents, then exchange exact-recipient untrusted messages. Durable JSON payload max: 64 KiB; complete native envelope max: 16 KiB with distinct `native_message_too_large` and `recipient_unavailable` failures. Native acceptance, discovery, poll, and fetch never imply acknowledgement or disposition |

package/README.zh-TW.md

@@ -45,7 +45,7 @@ MeMesh 幫它記住。Claude Code hooks 會記錄並還原日常工作脈絡；
 - **在適當時機記錄、提醒與防護。** MeMesh 的 Claude Code 與 Codex 整合共提供 **9 個 hook command**：其中 8 個 Claude Code hook 分別在開新對話、改檔案前、`git commit` 後、計畫核准或你回答問題後、Claude 停下來時、對話被壓縮前、你說「記下來」時（聽得懂 5 種語言），以及執行可能重犯已接受教訓的危險指令前運作。計畫/問題與「記下來」hook 只會提醒 agent 呼叫 `remember`；第 9 個 command 同時處理 Codex SessionStart 與 SessionEnd，註冊並退場符合資格的一般 Codex CLI session。
 - **所有工具共用一份記憶。** 今天在 Claude Code 存的決定，明天 Codex 或 Cursor 也用得到。
 - **agent 之間可以留言。** 本機的耐久收件匣可跨重啟保存；在 macOS 或 Linux 上，確切且活動中的一般 Codex CLI session 裝有 MeMesh plugin 時，也能透過原生 queue 收到有界訊息。
-- **有儀表板** 可以瀏覽全部內容：5 個分頁、11 種語言，在 `http://localhost:3737/dashboard`。
+- **有儀表板** 可以瀏覽全部內容：4 個分頁、11 種語言，在 `http://localhost:3737/dashboard`。
 
 ---
 
@@ -121,11 +121,11 @@ memesh remember "登入功能用 OAuth 2.0 加 PKCE"
 memesh recall "登入"
 # -> 找到那筆 PKCE 的決定
 
-memesh briefing        # agent 對這個專案知道多少、上次做到哪
+memesh briefing        # agent 對這個專案知道多少
 memesh serve           # 啟動本機 server 並印出儀表板網址
 ```
 
-讓 `memesh serve` 保持執行，再開啟它印出的網址。在 Claude Code 裡使用記憶工具時連終端機都不用開：在對話裡說「記下來」就好，每次開新對話也會自動先收到摘要。
+讓 `memesh serve` 保持執行，再開啟它印出的網址。在 Claude Code 裡使用記憶工具時連終端機都不用開：在對話裡說「記下來」就好；有內容可看之後，開新對話時也會自動先收到摘要。
 
 有了記憶之後，兩件值得知道的事：
 
@@ -141,14 +141,14 @@ memesh serve           # 啟動本機 server 並印出儀表板網址
 | 工具 | 做什麼 |
 |------|--------|
 | `work_package` | 準備一份有界限且不受信任的日曆摘要，或從唯一符合的 MCP workspace root 準備 Claude Code transcript 套件；提交一份嚴格結果等待人工審核，或延後而不產生耐久變更。Transcript 提交會保留有界且已遮蔽的來源輪次；不會暴露檔案路徑、隱藏推理、provider、embedding 或 vector 資料。 |
-| `remember` | 用觀察、關係和標籤儲存知識 |
+| `remember` | 用觀察、關係和標籤儲存知識；也可以只給一段自由文字（`note`），標題、觀察和名稱會自動推導出來；`replace` 則是直接改掉既有的那一筆 |
 | `recall` | 本機 FTS5 搜尋，包含多因素評分（相關性、近期性、頻率、信心、回憶影響） |
 | `forget` | 軟歸檔（永不刪除）或移除特定觀察 |
 | `export` | 以 JSON 備份、搬遷記憶，或在相容代理之間轉移 |
 | `import` | 匯入記憶，包含合併策略（跳過 / 覆寫 / 追加） |
 | `learn` | 記錄來自錯誤的結構化教訓（錯誤、根本原因、修復、預防） |
 | `task_state` | 讀取或記下工作進度——目標、下一步、卡住的地方、剛完成的事 |
-| `briefing` | 提供給任何 MCP client 的工作拓撲；一般情境不顯示未讀訊息，確切的 `project` + `recipient` 才會顯示該收件者尚未擷取的訊息 |
+| `briefing` | 提供給任何 MCP client 的工作拓撲，預設情況下最後會附上這個專案長期記憶的索引（有數量上限）——實際組裝多少內容由 `briefing` 設定（`minimal` / `standard` / `full`）決定；一般情境不顯示未讀訊息，確切的 `project` + `recipient` 才會顯示該收件者尚未擷取的訊息 |
 | `user_patterns` | 分析你的工作模式——時間表、工具、優勢、學習領域 |
 | `improvement` | 將有證據來源的產品改善送交人類審核，或讀取其狀態；agent 不能自行接受或拒絕 |
 | `message` | 先找出活動 agent，再交換確切收件者的不受信任訊息。Durable JSON payload 上限 64 KiB；完整 native envelope 上限 16 KiB，並區分 `native_message_too_large` 與 `recipient_unavailable`。原生接受、探索、輪詢與擷取都不代表 ACK 或 workflow disposition |