@pcircle/memesh 4.10.1 → 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.10.1",
+      "version": "4.10.2",
       "author": {
         "name": "PCIRCLE AI"
       },

package/.claude-plugin/plugin.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "PCIRCLE AI"
   },
-  "version": "4.10.1",
+  "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.10.1",
+  "version": "4.10.2",
   "mcpServers": "./.codex-plugin/mcp.json"
 }

package/AGENTS.md

@@ -9,10 +9,32 @@ 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, and — closing the block — a capped index of
-   recent durable memories, one line each with its `[mem:id]` handle
-   (`memesh briefing --index` prints just that). The index is a recent
+   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
@@ -21,8 +43,12 @@ host is recallable from all of them. Not installed yet? Follow
    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 /
@@ -49,10 +75,13 @@ 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
 
@@ -66,7 +95,7 @@ host is recallable from all of them. Not installed yet? Follow
 | `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, closing with a capped index of the project's durable memories; 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 |
@@ -118,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.

package/README.de.md

@@ -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:
 
@@ -146,7 +146,7 @@ Alle Befehle und Tools: [docs/api/API_REFERENCE.md](docs/api/API_REFERENCE.md).
 | `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, abgeschlossen durch einen begrenzten Index der dauerhaften Memories des Projekts; 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

@@ -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:
 
@@ -146,7 +146,7 @@ Full command and tool reference: [docs/api/API_REFERENCE.md](docs/api/API_REFERE
 | `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, closing with a capped index of the project's durable memories; 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

@@ -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 裡使用記憶工具時連終端機都不用開：在對話裡說「記下來」就好；有內容可看之後，開新對話時也會自動先收到摘要。
 
 有了記憶之後，兩件值得知道的事：
 
@@ -148,7 +148,7 @@ memesh serve           # 啟動本機 server 並印出儀表板網址
 | `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 |