@pcircle/memesh 4.8.2 → 4.8.5

package/docs/platforms/agent-messaging.md

@@ -4,14 +4,41 @@ MeMesh provides two complementary collaboration surfaces on one machine:
 
 - shared durable memory, including the `team` namespace, for knowledge, decisions, and coarse handoffs;
 - the `message` tool for explicit durable messages to one named recipient on the same MeMesh instance.
-
-The messaging path is durable store-and-forward. For an explicitly configured,
-active local Codex CLI session, MeMesh queues a metadata-only native wakeup;
-the session then fetches the durable payload through the scoped `message`
-operation. SQLite remains the audit and recovery authority. `poll`/`watch` are
-compatibility and diagnostic APIs, not the normal delivery loop for that active
-Codex path. A queue admission or `host_accept` is not proof that an agent read
-the payload, acknowledged it, or accepted the work.
+- `message discover` for a bounded, project-scoped view of currently live host registrations.
+
+Use `memesh message discover --project <name> [--limit 1..100]` to read the
+router directory. Results expose `session_id`, `principal_id`, `host_kind`,
+`project`, declared `model` and `work_summary` (`null` when absent), `active`,
+`generation`, and `lease_expires_at_ms`. Discovery performs no send, fetch, ACK, replay, or
+receipt operation; router unavailability is an explicit error, never an empty
+directory.
+
+Briefing follows the same trust boundary. Generic `briefing` and automatic
+SessionStart context have no recipient identity, so they never aggregate or
+announce unread message activity. A caller that already knows its exact
+logical recipient may pass both `project` and `recipient` to `briefing`; the
+result reports only that recipient's unfetched deliveries and tells it to
+`message poll` with the exact scope before fetching each returned
+`message_id`. Fetching remains separate from intake and acknowledgement.
+
+The messaging path keeps durable store-and-forward compatibility. For an
+exact active local Codex or Claude session, MeMesh sends one bounded full
+message through the authenticated native host channel and waits for native
+acceptance; no marker-to-fetch step is required. An oversized full envelope
+returns `native_message_too_large`; other unavailable or rejected exact sessions
+return `recipient_unavailable` while scoped recovery data remains durable.
+Principal targets retain asynchronous store-and-forward semantics.
+The JSON-encoded durable payload is limited to 65,536 UTF-8 bytes (64 KiB).
+Native delivery separately limits the complete envelope, including routing
+metadata and payload, to 16,384 bytes (16 KiB). Fitting the durable limit does
+not guarantee that a native envelope fits; exact-session messages should stay
+comfortably below the native cap.
+The size failure is permanent for that exact envelope and is reported as
+`native_message_too_large`, so callers do not retry it as transient session
+unavailability.
+`poll`/`watch` are compatibility and diagnostic APIs. A queue admission or
+`host_accept` is not proof that an agent read the payload, acknowledged it, or
+accepted the work.
 
 ## One-time owner-private local-host setup
 
@@ -63,6 +90,9 @@ memesh agent setup codex --project my-project --principal codex-reviewer --works
 memesh agent setup claude --project my-project --principal claude-reviewer
 ```
 
+Optional declarations can be persisted with `--model <id>` and
+`--work-summary <text>` (each is capped at 200 characters); no defaults are guessed.
+
 ### Ordinary active Codex CLI session
 
 `codex-session` is the opt-in path for an ordinary local Codex session and
@@ -72,24 +102,35 @@ the setup command from the exact workspace that Codex will use; it stores the
 configured real workspace and stable principal in the owner-private
 `codex-session.json` config. Restart Codex in that workspace after setup.
 
+This guide's supported documented path is ordinary Codex CLI `SessionStart`.
+Codex Desktop or an unattached task is not user-visible native-delivery
+evidence unless that exact live session registers with the router and the
+result is directly verified. This is a scope boundary for evidence, not a
+claim that Codex Desktop is universally unsupported.
+
 On `SessionStart` for `startup` or `resume`, the asynchronous companion checks
 the Codex thread identity, hook session identity, and configured workspace
 realpath before it connects to the router. A missing identity, a different
 workspace, compact lifecycle input, or a failed/disconnected connection does
 not register a host and does not wake anything.
 
-For a registered session, MeMesh invokes `codex queue` with a
-`memesh_message_available` marker containing only the project, recipient,
-target kind, message ID, and delivery ID. The message payload stays in the
-durable MeMesh inbox. Codex must then use the `message` tool to `fetch` that
-same project/recipient/target/message scope. The persisted `host_accept` means
-only that the local Codex queue accepted the marker; it is neither payload
-readback nor an `ack` or workflow disposition.
+For a registered session, MeMesh invokes `codex queue` with one untrusted full
+envelope capped at 16,384 bytes (16 KiB), including routing metadata and payload.
+The separate durable JSON-encoded payload limit is 65,536 bytes (64 KiB). The exact-session sender returns
+`native_delivery.status: "native_accepted"` only after the queue accepts it;
+Codex does not need a second `message fetch` to inspect that native message.
+The persisted `host_accept` is neither agent readback nor an `ack` or workflow
+disposition. Codex exposes message text only through its `--message` process
+argument, so same-user process inspection may observe it while the short-lived
+queue command runs; do not put secrets in native messages.
 
 If the configured Codex session is stopped, missing, disconnected, or no
 longer matches its configured workspace, MeMesh does not start or replace it.
-The durable inbox and its receipt history remain available to scoped fetch,
-cursor recovery, `poll`, or `memesh message watch` for audit and diagnosis.
+An exact-session send reports `recipient_unavailable`; durable scoped recovery
+and receipt history remain available to fetch, cursor recovery, `poll`, or
+`memesh message watch` for audit and diagnosis. Exact-session failures are not
+automatically replayed through the native channel on a later registration; the
+sender must retry deliberately if live delivery is still wanted.
 
 ### Separate: MeMesh-managed Codex app-server runner
 
@@ -105,6 +146,17 @@ process arguments.
 
 ### Claude channel runner
 
+When `memesh doctor` is running from a Claude Code plugin cache, its default
+`Claude Channel registration` row inspects only the user-scoped
+`mcpServers.memesh-channel` entry in Claude's canonical user config and the
+owner-private config file named by its `--config` argument. Missing
+registration is a warning: durable MCP/inbox messaging can still work, while
+live Channel notification remains inactive until the upstream research-preview
+channel is explicitly opted into. A malformed, stale, or insecure target is
+also a warning. `CONFIGURED` means only that the declaration and target are
+coherent; it does not verify development-channel admission or that an agent
+surfaced the notification.
+
 Run the printed `registration_command` once to add `memesh-channel` as a
 user-scoped stdio MCP server. Claude owns that process for the session:
 
@@ -124,7 +176,7 @@ claude --dangerously-load-development-channels server:memesh-channel
 
 Without that flag Claude may initialize the ordinary MCP transport while
 silently dropping channel events; a MeMesh `host_accept` then proves only that
-the notification was written to stdio, not that Claude admitted it. With the
+the bounded message was written to stdio, not that Claude surfaced it. With the
 channel admitted, initialization creates and registers the exact MeMesh
 session automatically; EOF, MCP close, or normal signals unregister it.
 
@@ -145,23 +197,181 @@ for active Codex-session delivery.
 ## What Works Today
 
 - MCP, HTTP, and CLI use the same message lifecycle and SQLite system of record.
-- `send` creates one canonical message, recipient delivery, and payload-free notification event under an idempotency key.
+- `send` creates one canonical message, recipient delivery, and payload-free notification event under an idempotency key. Exact-session success additionally requires native host acceptance; an oversized envelope returns `native_message_too_large`, while other unavailable or rejected sessions return `recipient_unavailable`, with recovery state preserved.
 - `poll` and `memesh message watch` return only events for the exact project and recipient. They are compatibility and diagnostic paths; the opaque cursor can be persisted and reused after a timeout, dropped hint, duplicate delivery, or process restart.
 - `fetch` returns the payload only to the named recipient and matching `target_kind` in the named project. Exact-session messages require `target_kind=session`; polling and fetching do not acknowledge the message.
 - `intake`, `ack`, `disposition`, and `activation` are explicit, separate, idempotent receipt facts. Inbox/MCP ACK is valid without a host-native acceptance; host-native ACK remains bound to its `host_accept`. `receipts` returns one ordered projection and identifies each underlying fact source. For example, `manual_resume_required` does not imply ACK, acceptance, rejection, cancellation, or completion.
 - The transport, rather than model-provided payload data, records sender-host provenance.
 
+## Repeatable owner-run live checks
+
+Everything above is checked by the test suite against stubs and fakes. That
+proves the plumbing and nothing about a live model: a queue admission or a
+`host_accept` is a statement about a frame, not about cognition. Two checks
+close that gap by requiring evidence that could only have come out of a running
+model.
+
+```bash
+TMPDIR=/private/tmp npm run qa:live-journey -- --host codex  --out .qa/codex-report.json
+TMPDIR=/private/tmp npm run qa:live-journey -- --host claude --out .qa/claude-report.json
+```
+
+`.qa/` is where `npm run release:finish` looks for these reports (any ONE
+host's PASS, against the exact commit being released, is enough — see
+`scripts/lib/release-preconditions.mjs`'s `findUsableLiveJourneyReceipt`). The
+directory is gitignored; a report is owner-machine evidence, never shipped.
+
+`TMPDIR` is not decoration on macOS. The router's Unix socket lives beside the
+database inside the temporary directory, and `AF_UNIX` caps a socket path at
+104 bytes; the platform default `os.tmpdir()` spends about half of that before
+the check adds anything. The script measures its own socket path and refuses
+with this hint rather than starting a router that cannot bind.
+
+`scripts/qa/live-journey.mjs` is owner-run and refuses to start when `CI` is
+set, because neither check can run unattended: one needs the owner's Codex
+login, the other needs a person at an interactive Claude session. Its argument
+parsing, its refusals, and every **pure** assertion it makes are unit-tested in
+`tests/qa/live-journey.test.ts`, which does run in CI against recorded
+fixtures; the orchestration around them is exercised only by a live run.
+
+Everything MeMesh writes goes into a fresh `mktemp` MEMESH_DIR that is deleted
+on exit (`--keep` retains it), against this repository's own `dist/`. The check
+refuses to start if that directory would resolve inside `$HOME/.memesh` — the
+comparison is made on **real** paths, before anything is created, so a
+symlinked `TMPDIR` cannot get past it — or if `dist/` has not been built. It
+reads no authentication file. Where that isolation stops is listed under
+limitations below, and the report records whether the working tree was dirty
+and whether `dist/` predates the newest file under `src/`.
+
+Shutdown order is part of the design rather than an afterthought. A connected
+host that sees the router socket disappear starts a **detached** packaged
+router inheriting its own environment — including this check's `MEMESH_DIR` —
+and the router recreates its data directory on start. The check therefore stops
+the companion, waits for live sessions to disconnect, stops the router, and
+only then removes the directory; if a session is still connected when the wait
+expires it keeps the directory rather than racing that spawn. The same sequence
+runs on failures and on `SIGINT`/`SIGTERM`.
+
+**`--host codex`** starts the router, runs `memesh agent setup codex-session`,
+creates one real Codex CLI thread with `codex exec`, registers that thread,
+sends one exact-session message, and then resumes the thread with a fixed
+prompt that names neither the sentinel nor any identifier. The reply must quote
+the envelope's `message_id` and `delivery_id` back, **and** that turn must have
+produced nothing but an answer. Both halves matter: a `read-only` Codex sandbox
+still permits reads, so a turn that ran one command could have taken the
+identifiers off disk instead of out of the envelope. The Codex workspace is a
+separate temporary tree for the same reason — the database and this run's own
+logs are not one `..` away from it. The check then stops the companion and requires the next send to return
+`recipient_unavailable` while `message fetch` still returns the payload.
+
+**`--host claude`** starts the router, runs `memesh agent setup claude`, writes
+a temporary MCP config, and prints the exact interactive launch command — which
+includes `--setting-sources ""` so that no user, project, or local settings
+file is loaded. The operator runs it, confirms with `/mcp` and `/hooks` that
+only the two servers from `--mcp-config` are present, and then types nothing. The check waits for the session to appear
+in `message discover`, sends one exact-session message, and then waits for an
+`intake` receipt on that message whose actor is that session — the model must
+call `intake` itself, which is what makes the proof model-visible rather than
+transport-visible. The operator is then asked to exit the session, and the same
+fail-closed assertion runs.
+
+Print mode (`claude -p`) is **not supported** and is deliberately not
+exercised. A print-mode session does not surface `memesh-channel` notifications
+to the model even when the channel host reports the frame accepted, so it can
+never produce the receipt this check requires.
+
+Each run writes a JSON report: the repository revision, every `message_id` and
+`delivery_id`, the `native_delivery` receipts, the model-visible evidence, and
+a `limitations` list. The exit code is 0 only when every required step passed.
+The limitations these checks always declare:
+
+- The Codex **registration** half is harness-driven: the check drives the
+  shipped `src/host-runtime/codex-session.ts` companion directly with the
+  `SessionStart` payload the packaged plugin hook supplies, because a scripted
+  `codex exec` turn was not observed to register anything on its own. *Why* the
+  plugin hook does not run there is not established — `--ignore-user-config` is
+  documented only as skipping `config.toml`, and on a machine whose
+  `~/.memesh/hosts` has no `codex-session.json` the shipped companion would
+  return early regardless. Dispatch → `codex queue` → model-visible reply is
+  product-path evidence; the registration step is not.
+- The interactive Claude session is **outside** this check's isolation.
+  `--setting-sources ""` is accepted by the CLI (an invalid source name is
+  rejected, an empty list is not), but it is not verified to exclude
+  plugin-provided hooks or MCP servers. A MeMesh plugin hook running in that
+  session inherits no `MEMESH_DIR` and would write the owner's real
+  `~/.memesh`. The operator is told to confirm with `/mcp` and `/hooks` first,
+  and the check cannot observe whether they did.
+- `--host codex` creates one throwaway thread in the owner's Codex rollout
+  store and queues one message into it. That is session state, not
+  configuration; nothing outside the temporary directory is otherwise written.
+- The Claude operator is told to type nothing, but the check cannot observe
+  whether anything was typed. The intake receipt proves the model called
+  `intake` in that session; it does not prove it did so unprompted.
+- The Claude intake receipt is matched on its `actor`, which `intake` sets from
+  the caller's `recipient`. The model must intake under its own session id; an
+  intake recorded against the principal id would not match, and the check would
+  report no model-visible proof.
+- `recipient_unavailable` is a shared failure surface — the same string is
+  returned when the *sender* cannot reach the router. The fail-closed step
+  therefore also records that `message discover` still answered and that
+  `message fetch` still returned the payload. That pairing, not the string, is
+  what attributes the failure to the stopped recipient.
+
+## Scope identifiers
+
+`project` and `recipient` together key one inbox, and `actor` is derived from
+`recipient`, so how those three are spelled is part of the contract rather than
+a formatting detail. Two spellings of one name are two inboxes: the recipient
+that fetches under one never sees what was sent under the other, and a
+`briefing` unread count is computed per spelling.
+
+Every message action canonicalises them to Unicode NFC and trims surrounding
+whitespace, on reads as well as writes, so a decomposed spelling reaches the
+rows a composed one wrote.
+
+A value spelled as an **absolute filesystem path is refused** — a POSIX path
+(`/root`), a Windows drive path (`C:\work`), or a UNC path (`\\host\share`).
+Project identity is derived from the working directory and can never take that
+shape, so such a value is not an identity MeMesh produced; the error names the
+field and a valid value. Callers that previously passed a home directory or a
+checkout path where the agent's or project's NAME belonged must pass the name.
+Nothing else is rewritten: identifiers are compared exactly, case included, and
+an identifier that merely contains a separator (`team/reviewer`) is accepted.
+MeMesh does not treat any prefix as a namespace, so `claude-code:reviewer` and
+`reviewer` are two different recipients.
+
+The same rule covers every surface that reads or writes that key, not only the
+`message` tool: `briefing` counts unfetched deliveries for one exact
+(`project`, `recipient`), and `memesh agent setup --project/--principal` writes
+the identity a host will register under. A path-shaped value is refused there
+too, at the moment the config is written, rather than surfacing later as an
+error about some other agent's send.
+
+`sender` is not covered by any of this. It is provenance rather than routing —
+it keys no inbox, and it keys the send idempotency record — so it is stored
+exactly as given, and the transport-bound provenance remains the field to trust.
+
+Rows written before this rule are repaired once, in place, at the first
+database open after upgrade. Renaming a project across both its entity tags and
+its message scopes is a separate, deliberate, owner-run operation:
+
+```bash
+memesh kg rename-project --from <old> --to <new>          # dry run
+memesh kg rename-project --from <old> --to <new> --apply  # backs up first
+```
+
 ## Identity and lifecycle
 
 A **principal** is the stable logical recipient. A **session** is one live host connection for that principal. A **generation** changes when that session is replaced. An exact-session target never reroutes. A principal target can deliver only to an eligible active session after its activation checkpoint; it does not replay historical inbox contents into a first session.
 
 Persistence, dispatch attempt, host acceptance, intake, acknowledgement,
 workflow disposition, retention, and presence are independent state axes. An
-active configured Codex session receives a host-native metadata marker without
-polling. A stopped, missing, busy beyond its queue limit, disconnected, or
-unsupported session is not awakened, resumed, or replaced; durable state
-remains available for audit and recovery, subject to exact-session and
-activation-checkpoint rules.
+active configured exact session receives a bounded full message without
+polling or an inbox fetch. An oversized full envelope returns
+`native_message_too_large`. A stopped, missing, busy beyond its queue limit,
+disconnected, or unsupported session returns `recipient_unavailable` and is
+not awakened, resumed, or replaced; durable state remains available for audit
+and recovery, subject to exact-session and activation-checkpoint rules.
 
 ## Bounded storage and audit retention
 
@@ -206,9 +416,9 @@ quota or automatic retention policy.
 This guide describes only one local MeMesh instance: its SQLite durable event
 store and same-machine host-native input. Remote and cross-machine transport is
 the responsibility of MeMesh Cloud and requires its own verified relay; Cloud
-state is not evidence that this local host received a marker. A native marker,
-persistence, or fetch does not promise exactly-once cognition, a reply, or a
-stopped-session wake-up.
+state is not evidence that this local host accepted a native message. Native
+acceptance, persistence, or fetch does not promise exactly-once cognition, a
+reply, or a stopped-session wake-up.
 
 ## What This Is Not Yet
 
@@ -223,7 +433,7 @@ stopped-session wake-up.
 
 | Participant | Current path | Status today | Notes |
 |---|---|---|---|
-| Ordinary Codex CLI | `codex-session` owner-private opt-in | metadata-only native wakeup while active | Exact workspace, principal, and SessionStart identity must match; stopped or disconnected sessions are not awakened |
+| Ordinary Codex CLI | `codex-session` owner-private opt-in | bounded full-message native delivery while active | Exact workspace, principal, and SessionStart identity must match; oversized envelopes return `native_message_too_large`, while stopped or disconnected sessions return `recipient_unavailable` |
 | MeMesh-managed Codex app-server | `memesh-host-codex` | separate managed path | It creates its own Codex thread; it does not attach to an ordinary session |
 | Claude channel | `memesh-host-claude` | separate channel path | Requires the documented Channel opt-in; no stopped-session resume |
 | Other local MCP clients | MCP, HTTP, or CLI message operations | durable messaging only | Use `poll`/`watch` and scoped fetch where their own host loop supports it; this guide makes no native-wakeup claim |
@@ -231,19 +441,19 @@ stopped-session wake-up.
 ## Lifecycle
 
 1. A sender calls `message` with `action: "send"`, a stable sender, one recipient, a project, an idempotency key, and a payload.
-2. For an eligible ordinary Codex session, the router queues only a
-   privacy-minimized `memesh_message_available` marker. An explicit
-   `poll`/`watch` client may instead read privacy-minimized events for
-   compatibility or diagnosis.
-3. Codex calls `fetch` with the marker's project, recipient, target kind, and
-   message ID to read the durable payload. The marker and queue admission do
-   not acknowledge the message.
+2. For an eligible exact Codex or Claude session, the router sends one bounded
+   untrusted full envelope and waits for native host acceptance. An explicit
+   `poll`/`watch` client may still read privacy-minimized events for recovery,
+   compatibility, or diagnosis.
+3. Native acceptance returns `native_delivery.status: "native_accepted"`; an
+   absent or rejected exact session returns `recipient_unavailable`. Neither
+   outcome records an agent acknowledgement or workflow disposition.
 4. The receiver records only the facts that actually happened:
    - `intake`: payload fetched or durably ingested;
    - `ack`: explicit recipient acknowledgement;
    - `disposition`: accepted, rejected, completed, cancelled, or deferred;
    - `activation`: woken, manual resume required, unsupported, or failed.
-5. After router or host restart, registration drains only eligible durable deliveries. A manual cursor replay may repeat an event, so application intake still uses its own idempotency key.
+5. After router or host restart, registration drains only eligible durable principal deliveries. Failed exact-session native delivery requires an explicit retry. A manual cursor replay may repeat an event, so application intake still uses its own idempotency key.
 
 `correlation_id` and `reply_to` can connect messages, but they do not change delivery or routing.
 

package/hooks/hooks.json

@@ -55,6 +55,16 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "matcher": "ExitPlanMode|AskUserQuestion",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/hooks/decision-nudge.js",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "Stop": [

package/llms-install.md

@@ -129,14 +129,15 @@ memesh agent setup codex-session --project my-project --principal codex-recipien
 This stores the configured workspace realpath and principal in
 `~/.memesh/hosts/codex-session.json`. On `SessionStart` (`startup` or
 `resume`), an asynchronous companion registers only when its Codex thread ID,
-hook session ID, and workspace realpath match that config. It receives no
-message payload. Instead, an active registered session receives a
-metadata-only `memesh_message_available` queue marker with routing identifiers,
-then uses the scoped `message` `fetch` operation to read the durable payload.
+hook session ID, and workspace realpath match that config. The authenticated
+router sends the active exact session one bounded full message through native
+`codex queue`; no second `message fetch` is required for that live delivery.
 
-`host_accept` records only that the local Codex queue accepted that marker. It
+`host_accept` records only that the local Codex queue accepted that message. It
 does not prove an agent read the payload, acknowledged it, or accepted the
-work. If the session is stopped, missing, disconnected, or in another
+work. Codex exposes message text through its `--message` process argument, so
+same-user process inspection may observe it while the queue command runs; do
+not send secrets through the native path. If the session is stopped, missing, disconnected, or in another
 workspace, MeMesh neither starts nor replaces it; the durable inbox remains
 available to scoped fetch, cursor recovery, `poll`, and `memesh message watch`
 for audit and diagnosis.
@@ -207,6 +208,28 @@ codex mcp list
 
 Expected: `memesh` is listed as enabled.
 
+### Optional: Codex plugin marketplace
+
+Current Codex CLI versions can install the repository's plugin marketplace
+directly. For a fresh install:
+
+```
+codex plugin marketplace add PCIRCLE-AI/memesh
+codex plugin add memesh@pcircle-memesh
+```
+
+If the configured marketplace snapshot is stale, refresh it and reinstall the
+plugin:
+
+```
+codex plugin marketplace upgrade pcircle-memesh
+codex plugin remove memesh
+codex plugin add memesh@pcircle-memesh
+```
+
+These commands are separate from the MCP registration above; keep the MCP
+path when a host needs `memesh-mcp` directly.
+
 | Failure | Remedy |
 |---|---|
 | `command not found: codex` | Codex CLI itself is not installed — out of scope here; install it first, then re-run the add. |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pcircle/memesh",
-  "version": "4.8.2",
-  "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.8.5",
+  "description": "MeMesh — agentic memory for coding agents. Captured from the agent's real work via hooks, recalled when it acts. One SQLite file, zero cloud required.",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -17,13 +17,13 @@
   "files": [
     "dist/",
     "dashboard/dist/",
-    ".mcp.json",
     "hooks/hooks.json",
     "scripts/hooks/",
     "scripts/upgrade-plugin.sh",
     "skills/",
     "docs/platforms/agent-messaging.md",
     ".claude-plugin/",
+    ".codex-plugin/",
     "README.md",
     "LICENSE",
     "llms-install.md",
@@ -41,20 +41,28 @@
     "test:issue-228": "vitest run tests/dashboard/FeedbackWidget.test.tsx --maxWorkers=1",
     "test:issue-229": "vitest run tests/dashboard/OnboardingBanner.test.tsx tests/dashboard-i18n.test.ts --maxWorkers=1",
     "test:issue-230": "vitest run tests/dashboard/OnboardingBanner.test.tsx tests/transports/http.test.ts tests/core/demo.test.ts --maxWorkers=1",
+    "test:issue-241": "vitest run tests/core/lesson-engine.test.ts tests/storage/graph-repairs.test.ts tests/audit/memory-invariants.test.ts --maxWorkers=1",
+    "test:issue-242": "node scripts/run-tests-isolated.mjs tests/core/briefing.test.ts tests/core/work-topology.test.ts tests/hooks/session-start.test.ts --maxWorkers=1",
+    "test:issue-267": "vitest run tests/core/briefing.test.ts tests/core/schema-export.test.ts tests/hooks/session-start.test.ts tests/cli/briefing-recipient.test.ts --maxWorkers=1",
     "test:packaged": "node scripts/smoke-packed-artifact.mjs",
     "test:packaged:upgrade": "node scripts/smoke-packed-upgrade.mjs",
     "test:surface-parity": "vitest run tests/readme-tool-parity.test.ts tests/codemap-parity.test.ts tests/core/schema-export.test.ts && node scripts/check-version-coherence.mjs && node scripts/check-generated-mirror.mjs && npm run test:packaged",
     "check:surface-parity": "node scripts/check-readme-tool-parity.mjs && node scripts/check-codemap-parity.mjs",
     "audit:prod": "node scripts/check-consumer-audit.mjs",
     "audit:memory": "node scripts/audit/memory-invariants.mjs",
-    "verify:release": "npm run lint && npm run typecheck && node scripts/check-version-coherence.mjs && node scripts/check-generated-mirror.mjs && node scripts/check-agent-message-sync.mjs && npm run check:surface-parity && node scripts/check-doc-claims.mjs && node scripts/audit/verification-audit.mjs && npm run audit:prod",
+    "check:entry-points-start": "node scripts/check-entry-points-start.mjs",
+    "verify:release": "npm run lint && npm run typecheck && node scripts/check-version-coherence.mjs && node scripts/check-generated-mirror.mjs && node scripts/check-agent-message-sync.mjs && npm run check:surface-parity && node scripts/check-doc-claims.mjs && node scripts/audit/verification-audit.mjs && npm run audit:prod && npm run check:entry-points-start",
     "release:finish": "node scripts/finish-release.mjs",
-    "prepublishOnly": "npm run build && npm run verify:release && npm run test:isolated && npm run test:packaged && npm run test:packaged:upgrade",
+    "verify:artifact": "npm run verify:release && npm run test:isolated && npm run test:packaged && npm run test:packaged:upgrade",
+    "prepublishOnly": "npm run build && npm run verify:artifact",
     "typecheck": "tsc -p tsconfig.check.json && tsc -p tsconfig.check-dashboard.json",
     "lint": "eslint src/ scripts/ tests/ dashboard/src/ --max-warnings 0",
     "lint:fix": "eslint src/ scripts/ tests/ dashboard/src/ --fix",
     "start": "node dist/mcp/server.js",
     "bench:longmemeval": "node benchmarks/longmemeval/run.mjs --mode A --dataset /tmp/longmemeval_s.json",
+    "qa:live-journey": "node scripts/qa/live-journey.mjs",
+    "qa:pre-release": "node scripts/qa/pre-release.mjs",
+    "qa:post-release": "node scripts/qa/post-release.mjs",
     "test:isolated": "node scripts/run-tests-isolated.mjs",
     "test:coverage": "node scripts/run-tests-isolated.mjs --coverage"
   },

package/scripts/hooks/_generated/agent-message-inbox.js

@@ -6,18 +6,21 @@
 // always-on capture path survives a missing or stale dist/ while staying
 // byte-locked to core — eliminating the hand-mirror drift behind the P0 FTS bug.
 // ============================================================================
-export function unreadDeliveryCount(db, project) {
+export function unreadDeliveryCount(db, project, recipient) {
+    if (!recipient)
+        return 0;
     try {
         const row = db.prepare(`SELECT COUNT(*) AS n
        FROM agent_message_deliveries d
        WHERE d.project = ?
+         AND d.recipient = ?
          AND NOT EXISTS (
            SELECT 1 FROM agent_message_receipts r
            WHERE r.project = d.project
              AND r.recipient = d.recipient
              AND r.message_id = d.message_id
              AND r.receipt_kind = 'intake'
-         )`).get(project);
+         )`).get(project, recipient);
         const n = row?.n;
         return typeof n === 'number' && n > 0 ? n : 0;
     }
@@ -25,9 +28,30 @@ export function unreadDeliveryCount(db, project) {
         return 0;
     }
 }
-export function unreadInboxLines(count, project) {
-    if (count <= 0)
+export function recipientEverSeen(db, project, recipient) {
+    try {
+        const row = db.prepare(`SELECT (
+         EXISTS(SELECT 1 FROM agent_principals WHERE project = ? AND principal_id = ?)
+         OR EXISTS(SELECT 1 FROM agent_message_deliveries WHERE project = ? AND recipient = ?)
+         OR EXISTS(SELECT 1 FROM agent_session_instances WHERE project = ? AND session_instance_id = ?)
+       ) AS seen`).get(project, recipient, project, recipient, project, recipient);
+        return row?.seen === undefined ? undefined : Boolean(row.seen);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function unreadInboxLines(count, project, recipient, everSeen) {
+    if (!recipient)
         return [];
-    const noun = count === 1 ? 'message' : 'messages';
-    return [`${count} ${noun} waiting for "${project}" — fetch them with the message tool; fetching does not acknowledge.`];
+    const displayProject = JSON.stringify(project);
+    const displayRecipient = JSON.stringify(recipient);
+    if (count > 0) {
+        const noun = count === 1 ? 'message' : 'messages';
+        return [`${count} ${noun} waiting for ${displayRecipient} in project ${displayProject} — poll the message tool with project ${displayProject} and recipient ${displayRecipient}, then fetch each message_id; fetching does not acknowledge.`];
+    }
+    if (everSeen === false) {
+        return [`No messages waiting for ${displayRecipient} in project ${displayProject} — and this recipient id has never been seen in this project (check for a typo).`];
+    }
+    return [];
 }

package/scripts/hooks/_generated/citation-rule.js

@@ -25,8 +25,11 @@ memory is recorded as unused: that is how MeMesh learns which memories are
 worth the tokens they cost you.
 `;
 export function citationRuleDir(scope, home, cwd) {
-    const base = scope === 'user' ? home : cwd;
-    return path.join(base, '.claude', 'rules');
+    if (scope === 'project')
+        return path.join(cwd, '.claude', 'rules');
+    const relocated = process.env.CLAUDE_CONFIG_DIR;
+    const configRoot = relocated ? path.resolve(relocated) : path.join(home, '.claude');
+    return path.join(configRoot, 'rules');
 }
 export function citationRulePath(scope, home, cwd) {
     return path.join(citationRuleDir(scope, home, cwd), CITATION_RULE_FILENAME);

package/scripts/hooks/_generated/fts-index.js

@@ -67,6 +67,11 @@ function foldTitleIntoObservations(title, observationsText) {
 }
 export function removeFromFts(db, entityId, name, prevObsText, prevTitle) {
     try {
+        const indexed = db
+            .prepare('SELECT COUNT(*) AS c FROM entities_fts WHERE rowid = ?')
+            .get(entityId);
+        if (!indexed || indexed.c === 0)
+            return;
         db.prepare("INSERT INTO entities_fts (entities_fts, rowid, name, observations) VALUES('delete', ?, ?, ?)").run(entityId, toIndexForm(name), toIndexForm(foldTitleIntoObservations(prevTitle, prevObsText)));
     }
     catch (err) {