klypix-mcp 1.86.3 → 1.88.0

package/README.md

@@ -445,9 +445,16 @@ have to have declared their files for the overlap to be visible at all.
 
 ## Handoffs and messages
 
-`brain_message` leaves one-time coordination notes for other sessions. A supported KLYPIX action
-offers the note in model-visible context; the next independent supported action replays it and
-records an acknowledgement. That acknowledgement proves only that a later action followed the
+`brain_message` leaves one-time coordination notes for other sessions — live, idle, or recently
+closed. Address a session by id: a live session gets the note on its next action; a session
+KLYPIX has identified before that is **not on the lane now** (closed, or quiet) still receives a
+directed note the moment it next acts — a directed note is kept 7 days, and the sender is told it
+is *queued*, not delivered. That is what stops the human from being the courier between two
+agents: the standing rule every host receives is that a message it would otherwise ask the person
+to relay or paste is sent this way instead. Nothing here starts or wakes a session — the note
+waits until a person opens it. A supported
+KLYPIX action offers the note in model-visible context; the next independent supported action
+replays it and records an acknowledgement. That acknowledgement proves only that a later action followed the
 offer — never that a person read it or that an agent acted on it. The note keeps replaying until the
 receiving model calls `brain_message_receipt` with the exact message id and per-recipient offer
 token; only that token-bound action records `consumed`. Pending, offered, and acknowledged notes
@@ -622,7 +629,7 @@ The MCP verbs below are what agents call. These are what **you** call:
 | `brain_lens` | Machine-readable freshness, provenance, activity, timeline, orrery and unresolved views |
 | `brain_garden` | Maintenance pass — proposes first; consolidation cannot apply without an approval code the human generates. The separate `repair:"duplicate-partials"` pass is dry-run first and needs no code (it removes only exact repeats and archives nothing) |
 | `brain_doctor` | Self-diagnosis: version, core/enhanced host adapters, active sessions, tool count, projection drift |
-| `brain_message` | Session-to-session coordination notes with a fixed send-time audience and per-recipient pending / offer / acknowledgement / consumption / failure receipts (24h TTL, never written into the brain) |
+| `brain_message` | Session-to-session coordination notes — to a live session, or queued for one that is not running until it next starts — with a fixed send-time audience and per-recipient pending / offer / acknowledgement / consumption / failure receipts (a directed note is kept 7 days, a broadcast 24h; never written into the brain) |
 | `brain_message_receipt` | Explicitly record model-side consumption using the exact message id and per-recipient offer token; acknowledgement alone never consumes a note |
 | `brain_sync` | Context Gateway: task capsule, active-task peers, exact-file overlap, one-time alerts, timing, and optional result-manifest reconciliation |
 | `brain_connect` | Find and draw related-but-unlinked cards |

package/bin/klypix-install.mjs

@@ -395,7 +395,7 @@ try {
     // canvas-view-app.html is the canvas_view MCP App UI — staged raw (an HTML
     // file must never get a JS-comment banner) beside the flat server, which
     // resolves it via its ./canvas-view-app.html candidate path.
-    for (const f of ['global-brain-hook.mjs', 'capture-gap.mjs', 'brain-semantic.mjs', 'semantic-memory.mjs', 'enrichment.mjs', 'brain-note.mjs', 'brain-evidence.mjs', 'brain-git-hook.mjs', 'git-capture-install.mjs', 'brain-history.mjs', 'brain-graveyard.mjs', 'klypix-format.mjs', 'klypix-core.mjs', 'brain-write-lock.mjs', 'agent-rules.mjs', 'brain-doctor.mjs', 'editor-detect.mjs', 'agent-presence.mjs', 'mcp-presence.mjs', 'repo-state.mjs', 'result-reconcile.mjs', 'finding-routing.mjs', 'presence-relay.mjs', 'mcp-supervisor.mjs', 'mcp-auto-update.mjs', 'runtime-inspector.mjs', 'project-graph.mjs', 'bench.mjs', 'codex-brain-hook.mjs', 'codex-hooks.mjs', 'canvas-view-app.html']) {
+    for (const f of ['global-brain-hook.mjs', 'capture-gap.mjs', 'brain-semantic.mjs', 'semantic-memory.mjs', 'enrichment.mjs', 'provenance.mjs', 'brain-note.mjs', 'brain-evidence.mjs', 'brain-git-hook.mjs', 'git-capture-install.mjs', 'brain-history.mjs', 'brain-graveyard.mjs', 'klypix-format.mjs', 'klypix-core.mjs', 'brain-write-lock.mjs', 'agent-rules.mjs', 'brain-doctor.mjs', 'editor-detect.mjs', 'agent-presence.mjs', 'mcp-presence.mjs', 'repo-state.mjs', 'result-reconcile.mjs', 'finding-routing.mjs', 'presence-relay.mjs', 'mcp-supervisor.mjs', 'mcp-auto-update.mjs', 'runtime-inspector.mjs', 'project-graph.mjs', 'bench.mjs', 'codex-brain-hook.mjs', 'codex-hooks.mjs', 'canvas-view-app.html']) {
         const s = path.join(SRC, f); if (exists(s)) staged.push({ dst: f, content: fs.readFileSync(s, 'utf8') });
     }
     for (const [src, dst] of [

package/bin/klypix-worker.mjs

@@ -621,7 +621,7 @@ server.registerTool('brain_lens', {
 
 server.registerTool('brain_connect', {
   title: 'Connect related-but-unlinked brain cards (densify the graph)',
-  description: 'Repairs orphaned decision/milestone cards first (scope:"orphans", the default) by proposing genuinely related unlinked pairs — semantic similarity at a conservative 0.55 threshold when the on-device model is installed, else shared tags + [[mentions]]. The dry run includes a before→projected orphan receipt; apply:true draws only additive, removable arrows and reports the measured after count. It NEVER archives or rewrites cards. Use scope:"all" for deliberate whole-graph densification. To DISMISS a brain_reconcile false-positive contradiction, pass pairs:[{fromId,toId}] with relationship:"not_contradiction".',
+  description: 'Repairs orphaned decision/milestone cards first (scope:"orphans", the default) by proposing genuinely related unlinked pairs — semantic similarity at a conservative 0.55 threshold when the on-device model is installed, else shared tags + [[mentions]]. The dry run includes a before→projected orphan receipt; apply:true draws only additive, removable arrows and reports the measured after count. It NEVER archives or rewrites cards. Use scope:"all" for deliberate whole-graph densification. To DISMISS a brain_reconcile false-positive contradiction, pass pairs:[{fromId,toId}] with relationship:"not_contradiction". Every applied not_fulfilled / not_contradiction dismissal is also recorded, with its surface and client, to the machine-local provenance sidecar (nothing extra is written into the brain file).',
   inputSchema: {
     canvas: z.string().optional().describe('Canvas filename/path. Defaults to the project brain ("brain").'),
     apply: z.boolean().optional().describe('false (default) = suggest only; true = draw the connections.'),
@@ -631,11 +631,11 @@ server.registerTool('brain_connect', {
     pairs: z.array(z.object({ fromId: z.string(), toId: z.string() })).optional().describe('Explicit card-id pairs to connect (bypasses auto-proposal). Use to dismiss a reconcile false-positive: pass the two card ids with relationship:"not_contradiction".'),
     relationship: z.string().optional().describe('Relationship for explicit `pairs` (e.g. "not_contradiction" to permanently dismiss a contradiction candidate, or "relates_to", "depends_on", "supports").'),
   },
-}, async ({ canvas, apply, max, threshold, scope, pairs, relationship }) => toContent(await opBrainConnect({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), apply, max, threshold, scope, pairs, relationship, log })));
+}, async ({ canvas, apply, max, threshold, scope, pairs, relationship }, extra) => toContent(await opBrainConnect({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), apply, max, threshold, scope, pairs, relationship, via: extra.klypixClientName, log })));
 
 server.registerTool('brain_reconcile', {
   title: 'Reconcile the brain — contradictions, unrecorded migrations, and what a release already closed',
-  description: 'Truth maintenance. (1) CONTRADICTIONS: finds same-subject live card pairs where one carries an explicit correction cue (uppercase "CORRECTION", "was WRONG", "OBSOLETE" — that side is the presumed truth, UNLESS the cue predates its counterpart: then the pair is marked "presumed superseded" and the newer card is presumed current — verify before retiring) or the two use opposite polarity words (deferred↔wired, broken↔fixed, dead↔live), i.e. stale facts whose correction never got linked — candidates only, YOU confirm each: retire the stale card via brain_note ✓. Dismiss a FALSE positive (either kind) by connecting the two ids with brain_connect pairs + relationship:"not_contradiction" — persisted, so it never resurfaces (and its cue stops overlaying recall/ask for that pair). (2) MIGRATIONS: lists committed migration files (Supabase / Rails / Prisma / Knex / generic) that NO brain card references, so an applied-but-unnarrated rollout can be recorded. (3) LEGACY: pre-v1.15 raw-bash ship cards to tidy. (4) RELEASE: which open cards look fulfilled by the commits a release ref already carries (subject+body coverage, the card\'s own #commit- receipt, or a hint edge whose milestone is in the ref). READ-ONLY by default and on every other mode. THE ONE EXCEPTION: on mode "claims" and mode "release" you may pass confirm/dismiss to actually close what you verified — confirm names exact card ids, so nothing is matched by prose; covering only part of a multi-item clause writes "✔ partial" and KEEPS the card open unless you pass whole:true; a call whose every entry is refused leaves the brain byte-identical. Never reads the database or the network. Run it periodically, when recall surfaces something you believe is stale, or right before cutting a release.',
+  description: 'Truth maintenance. (1) CONTRADICTIONS: finds same-subject live card pairs where one carries an explicit correction cue (uppercase "CORRECTION", "was WRONG", "OBSOLETE" — that side is the presumed truth, UNLESS the cue predates its counterpart: then the pair is marked "presumed superseded" and the newer card is presumed current — verify before retiring) or the two use opposite polarity words (deferred↔wired, broken↔fixed, dead↔live), i.e. stale facts whose correction never got linked — candidates only, YOU confirm each: retire the stale card via brain_note ✓. Dismiss a FALSE positive (either kind) by connecting the two ids with brain_connect pairs + relationship:"not_contradiction" — persisted, so it never resurfaces (and its cue stops overlaying recall/ask for that pair). (2) MIGRATIONS: lists committed migration files (Supabase / Rails / Prisma / Knex / generic) that NO brain card references, so an applied-but-unnarrated rollout can be recorded. (3) LEGACY: pre-v1.15 raw-bash ship cards to tidy. (4) RELEASE: which open cards look fulfilled by the commits a release ref already carries (subject+body coverage, the card\'s own #commit- receipt, or a hint edge whose milestone is in the ref). READ-ONLY by default and on every other mode. THE ONE EXCEPTION: on mode "claims" and mode "release" you may pass confirm/dismiss to actually close what you verified — confirm names exact card ids, so nothing is matched by prose; covering only part of a multi-item clause writes "✔ partial" and KEEPS the card open unless you pass whole:true; a call whose every entry is refused leaves the brain byte-identical. Never reads the database or the network. Every applied confirm/dismiss is also recorded to the machine-local provenance sidecar (actor, surface, exact card ids — nothing extra is written into the brain file), and a claims confirm settles the pair\'s dashed "likely closed by" hint into a solid confirmed edge. Run it periodically, when recall surfaces something you believe is stale, or right before cutting a release.',
   inputSchema: {
     canvas: z.string().optional().describe('Brain canvas filename/path. Defaults to the project brain ("brain").'),
     root: z.string().optional().describe("Project root holding the migrations dir / git repo (default: the brain file's folder)."),
@@ -746,11 +746,11 @@ server.registerTool('brain_note', {
 });
 
 server.registerTool('brain_message', {
-  title: 'Message the other live agent sessions on this project (one-time note, not a brain card)',
-  description: 'Leave a DELIBERATE, targeted note for the OTHER active agent sessions working on this project right now ("merged the hook refactor — rebase before you commit", "don\'t touch canvasStore, mid-refactor"). Any MCP client can send and receive through the shared machine-local presence lane. A supported lifecycle event or KLYPIX tool result offers the note into model-visible context; a later independent supported action acknowledges that offer. Pending/offered notes replay after reconnect, while expiry or capacity loss leaves a failed per-recipient receipt instead of silently disappearing. Acknowledged means a later action followed the offer — it is NOT proof a human read it. A note then retires either by an explicit brain_message_receipt ("acted on it") or by AUTO-CONSUMPTION on a further independent action, with no receipt; your receipt line names which, and auto-consumption evidences activity, not uptake. Delivery remains OS-user-local, machine-local, bounded by a 24h TTL, and unavailable to a peer that never takes a supported action. Ephemeral and NOT persisted to the brain — for a durable decision use brain_note instead.',
+  title: 'Message another agent session on this project — live, idle, or recently closed (one-time note, not a brain card)',
+  description: 'Leave a DELIBERATE, targeted note for another agent session working on this project ("merged the hook refactor — rebase before you commit", "don\'t touch canvasStore, mid-refactor"). Address it to a session id from the brain_sync peer list or brain_doctor. A LIVE session gets it on its next lifecycle event or KLYPIX tool call, even if it is idle right now. A session KLYPIX has identified before that is NOT on the lane now (closed, or quiet) still receives a directed note the moment it next acts — the note is kept for up to 7 days — so if you would otherwise ask the human to relay or paste something to another agent session, send it here instead and tell them it was sent or queued. Broadcasts ("all") reach only sessions live right now. Any MCP client can send and receive through the shared machine-local presence lane. Delivery contract: a supported action offers the note into model-visible context, a later independent action acknowledges it, and it retires either by an explicit brain_message_receipt ("acted on it") or by auto-consumption on a further independent action; your receipt line names which, and neither is proof a human read it. Expiry or capacity loss leaves a failed per-recipient receipt instead of silently disappearing. OS-user-local and machine-local. Ephemeral and NOT persisted to the brain — for a durable decision use brain_note instead.',
   inputSchema: {
     text: z.string().describe('The note to deliver (kept to 400 chars).'),
-    to: z.string().optional().describe('Target hint — a peer session id-prefix or branch name; omit or "all" for every live session.'),
+    to: z.string().optional().describe('Target — a session id (or unique prefix of at least 8 characters) from the peer list, or an exact unique branch; omit or "all" for every session live right now. A directed id may name a session that is not running: the note then waits and is delivered when that session next starts.'),
     canvas: z.string().optional().describe('Brain canvas filename/path. Defaults to the project brain ("brain").'),
   },
 }, async ({ text, to, canvas }, extra) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klypix-mcp",
-  "version": "1.86.3",
+  "version": "1.88.0",
   "mcpName": "io.github.dahshanlabs/klypix-mcp",
   "description": "Active state management for multi-agent coding: a shared, versioned project brain over MCP.",
   "type": "module",
@@ -84,7 +84,7 @@
     "bench": "node bin/klypix-mcp.mjs bench",
     "test:bench": "node test/bench.mjs",
     "pretest": "node test/publish-workflow.mjs",
-    "test": "node test/publish-verdict.mjs && node test/npx-owned-names.mjs && node test/project-graph.mjs &&node test/project-map-cli.mjs && node test/mcp-auto-update.mjs && node test/mcp-supervisor.mjs && node test/runtime-inspector.mjs && node test/codex-hooks.mjs && node test/request-identity.mjs && node test/session-identity-core.mjs && node test/agent-presence.mjs && node test/message-delivery-v3.mjs && node test/claude-message-delivery-v3.mjs && node test/result-reconcile.mjs && node test/evidence-publication-gate.mjs && node test/release-evidence-cli.mjs && node test/intent-guard.mjs && node test/git-capture-install.mjs && node test/brain-history.mjs && node test/brain-graveyard.mjs && node test/archived-visibility.mjs && node test/finding-routing.mjs && node test/finding-routing-hook.mjs && node test/presence-relay.mjs && node test/install-version.mjs && node test/install-rename-backoff.mjs && node test/project-binding-rebind.mjs && node test/context-gateway.mjs && node test/repo-state.mjs && node test/released-tag-guard.mjs && node test/conformance.mjs && node test/brain-doctor.mjs && node test/version-currency.mjs && node test/ship-capture.mjs && node test/capture-gap.mjs && node test/lane-message.mjs && node test/brain-quality.mjs && node test/brain-connect-orphans.mjs && node test/orphan-gardener.mjs && node test/brief-and-recall.mjs && node test/guard-cards.mjs && node test/layout-cluster.mjs && node test/brain-ask.mjs && node test/retrieval-fusion.mjs && node test/eval-retrieval.mjs && node test/field-report-2026-07-04.mjs && node test/autoprop.mjs && node test/overlay-recency-2026-07-12.mjs && node test/brain-challenge.mjs && node test/brain-lens.mjs && node test/brain-kind.mjs && node test/rule-drafts.mjs && node test/claim-engine.mjs && node test/partial-notes.mjs && node test/lifecycle-prefix.mjs && node test/close-link-safety.mjs && node test/resolve-ledger.mjs && node test/plan-fulfillment.mjs && node test/skill-staleness.mjs && node test/canvas-view.mjs && node test/status-completeness.mjs && node test/semantic-security.mjs && node test/semantic-gate.mjs && node test/memory-runtime.mjs && node test/semantic-cache.mjs && node test/semantic-hash-parity.mjs && node test/enrichment.mjs && node test/hook-fallback.mjs && node test/eval-hook-lane.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/marker-suffix-grammar.mjs && node test/evidence-anchors.mjs && node test/brain-evidence.mjs && node test/presence-visibility.mjs && node test/undeclared-active.mjs && node test/presence-liveness.mjs && node test/observed-scope.mjs && node test/release-lease.mjs && node test/release-reconcile.mjs && node test/release-ancestry.mjs && node test/release-claim-join.mjs && node test/release-claims.mjs && node test/release-handshake.mjs && node test/completion-guard.mjs && node test/merge-brains.mjs && node test/concurrent-writes.mjs && node test/lock-interop.mjs && node test/capture-write-failure.mjs && node test/a2a-smoke.mjs && node test/one-command-setup.mjs && node test/cli-args.mjs && node test/format-guard.mjs && node test/canvas-groups.mjs && node test/git-tools.mjs && node test/uninstall.mjs && node test/current-guidance.mjs && node test/status-shape.mjs && node test/status-hook.mjs",
+    "test": "node test/publish-verdict.mjs && node test/npx-owned-names.mjs && node test/project-graph.mjs &&node test/project-map-cli.mjs && node test/mcp-auto-update.mjs && node test/mcp-supervisor.mjs && node test/runtime-inspector.mjs && node test/codex-hooks.mjs && node test/request-identity.mjs && node test/session-identity-core.mjs && node test/agent-presence.mjs && node test/message-delivery-v3.mjs && node test/claude-message-delivery-v3.mjs && node test/session-mailbox.mjs && node test/result-reconcile.mjs && node test/evidence-publication-gate.mjs && node test/release-evidence-cli.mjs && node test/intent-guard.mjs && node test/git-capture-install.mjs && node test/brain-history.mjs && node test/brain-graveyard.mjs && node test/archived-visibility.mjs && node test/finding-routing.mjs && node test/finding-routing-hook.mjs && node test/presence-relay.mjs && node test/install-version.mjs && node test/install-rename-backoff.mjs && node test/project-binding-rebind.mjs && node test/context-gateway.mjs && node test/repo-state.mjs && node test/released-tag-guard.mjs && node test/conformance.mjs && node test/brain-doctor.mjs && node test/version-currency.mjs && node test/ship-capture.mjs && node test/capture-gap.mjs && node test/lane-message.mjs && node test/brain-quality.mjs && node test/brain-connect-orphans.mjs && node test/orphan-gardener.mjs && node test/brief-and-recall.mjs && node test/guard-cards.mjs && node test/layout-cluster.mjs && node test/brain-ask.mjs && node test/retrieval-fusion.mjs && node test/eval-retrieval.mjs && node test/field-report-2026-07-04.mjs && node test/autoprop.mjs && node test/overlay-recency-2026-07-12.mjs && node test/brain-challenge.mjs && node test/brain-lens.mjs && node test/brain-kind.mjs && node test/rule-drafts.mjs && node test/claim-engine.mjs && node test/partial-notes.mjs && node test/lifecycle-prefix.mjs && node test/close-link-safety.mjs && node test/resolve-ledger.mjs && node test/plan-fulfillment.mjs && node test/skill-staleness.mjs && node test/canvas-view.mjs && node test/status-completeness.mjs && node test/semantic-security.mjs && node test/semantic-gate.mjs && node test/memory-runtime.mjs && node test/semantic-cache.mjs && node test/semantic-hash-parity.mjs && node test/enrichment.mjs && node test/provenance.mjs && node test/confirm-trail.mjs && node test/hook-fallback.mjs && node test/eval-hook-lane.mjs && node test/hook-unified-lane.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/marker-suffix-grammar.mjs && node test/evidence-anchors.mjs && node test/brain-evidence.mjs && node test/presence-visibility.mjs && node test/undeclared-active.mjs && node test/presence-liveness.mjs && node test/observed-scope.mjs && node test/release-lease.mjs && node test/release-reconcile.mjs && node test/release-ancestry.mjs && node test/release-claim-join.mjs && node test/release-claims.mjs && node test/release-handshake.mjs && node test/completion-guard.mjs && node test/merge-brains.mjs && node test/concurrent-writes.mjs && node test/lock-interop.mjs && node test/capture-write-failure.mjs && node test/a2a-smoke.mjs && node test/one-command-setup.mjs && node test/cli-args.mjs && node test/format-guard.mjs && node test/canvas-groups.mjs && node test/git-tools.mjs && node test/uninstall.mjs && node test/current-guidance.mjs && node test/status-shape.mjs && node test/status-hook.mjs",
     "test:memory": "node test/memory-runtime.mjs",
     "test:memory:soak": "node --expose-gc test/memory-soak.mjs",
     "runtime": "node bin/klypix-runtime.mjs",

package/src/agent-presence.mjs

@@ -19,6 +19,30 @@ export const MESSAGE_RECEIPT_CAP = 100;
 export const SESSION_ALIAS_CAP = 8;
 export const ENDED_SESSION_CAP = 80;
 export const ENDED_SESSION_FRESH_MS = 24 * 60 * 60 * 1000;
+// ── Session directory (mailbox, 1.88.0) ──────────────────────────────────────
+// The lane forgets a session ten minutes after its last heartbeat and keeps
+// only a 24h tombstone for the (Codex-only) SessionEnd path, so a note to a
+// session that had closed was refused as "target-not-unique" and the human
+// became the courier between two agents (2026-09-30 field case). The
+// directory is an ADDITIVE lane key remembering every exactly-identified
+// session the lane has seen — its resume id, client, last intent, last scope,
+// when it was last live — for two weeks. It is what lets a directed note be
+// QUEUED for a session that is not running (delivered the moment that id
+// comes back) and what a doctor/CLI/app can list as "recent sessions, not
+// running". Provisional MCP connection ids are never remembered: they cannot
+// be resumed and do not name a conversation.
+export const DIRECTORY_FRESH_MS = 14 * 24 * 60 * 60 * 1000;
+export const DIRECTORY_CAP = 200;
+// A DIRECTED note waits a week, not a day: the promise is "a session that has
+// closed still receives it when it next starts", and that must hold whether
+// the session was already gone at send time or closed an hour later. Stored
+// per message (expiresAt); broadcasts keep the 24h rule.
+export const MESSAGE_DIRECTED_FRESH_MS = 7 * 24 * 60 * 60 * 1000;
+export const MESSAGE_OFFLINE_FRESH_MS = MESSAGE_DIRECTED_FRESH_MS;
+// "working" is believed only while the host keeps stamping it: an MCP-only
+// host never stamps idle (no Stop event), so a busy stamp older than this
+// renders as idle-for-N-minutes instead of "working" all afternoon.
+export const HOST_STATUS_BUSY_FRESH_MS = 10 * 60 * 1000;
 // Marker shared by the pure relay seam. A message carrying this prefix was
 // received from another computer, rather than authored on this local lane.
 // Revoking cross-computer presence must remove these notes as well as cloud
@@ -435,6 +459,128 @@ const endedMatches = (row, id) => {
   return key && (recipientKey(row?.id) === key || normalizeAliases(row?.aliases).includes(key));
 };
 
+// ── Session directory upkeep (mailbox) ───────────────────────────────────────
+// PARITY: global-brain-hook.mjs keeps a verbatim twin (dirPrune/dirRemember)
+// because that hook stays free of sibling imports — change both.
+const pruneDirectory = (rows, now) => (Array.isArray(rows) ? rows : [])
+  .filter((row) => row && recipientKey(row.id) && now - Number(row.lastSeen || 0) < DIRECTORY_FRESH_MS)
+  .map((row) => ({
+    id: recipientKey(row.id),
+    client: String(row.client || 'unknown').slice(0, 40),
+    surface: row.surface ? String(row.surface).slice(0, 40) : null,
+    branch: row.branch ? String(row.branch).slice(0, 120) : null,
+    intent: String(row.intent || '').replace(/\s+/g, ' ').trim().slice(0, 120),
+    files: normalizeFiles(row.files).slice(-8),
+    cwd: row.cwd ? String(row.cwd).slice(0, 400) : null,
+    aliases: normalizeAliases(row.aliases, row.id),
+    firstSeen: Number(row.firstSeen) || Number(row.lastSeen) || now,
+    lastSeen: Number(row.lastSeen) || now,
+    endedAt: Number(row.endedAt) || null,
+    hostStatus: row.hostStatus ? String(row.hostStatus).slice(0, 16) : null,
+  }))
+  .sort((left, right) => Number(left.lastSeen) - Number(right.lastSeen))
+  .slice(-DIRECTORY_CAP);
+
+// Remember (or refresh) the directory entry for one lane row. Only rows with an
+// EXACT logical identity are remembered — that id is the one a human can
+// resume and a note can wait for. `ended` stamps endedAt (SessionEnd); any
+// live touch clears it, because a revived session is running again.
+function rememberSession(directory, row, now, { ended = false } = {}) {
+  const rows = pruneDirectory(directory, now);
+  const id = recipientKey(row?.logicalSessionId || '');
+  if (!id || row?.via === 'cloud') return rows;
+  const index = rows.findIndex((entry) => entry.id === id);
+  const prev = index >= 0 ? rows[index] : null;
+  const scope = [...new Set([...normalizeFiles(row.files), ...normalizeFiles(row.observedFiles)])].slice(-8);
+  const intent = String(row.intent || '').replace(/\s+/g, ' ').trim().slice(0, 120);
+  const entry = {
+    id,
+    client: String(row.client || prev?.client || 'unknown').slice(0, 40),
+    surface: row.surface ?? prev?.surface ?? null,
+    branch: row.branch ?? prev?.branch ?? null,
+    intent: intent || prev?.intent || '',
+    files: scope.length ? scope : (prev?.files || []),
+    cwd: row.cwd ? String(row.cwd).slice(0, 400) : (prev?.cwd || null),
+    aliases: normalizeAliases([...(prev?.aliases || []), ...normalizeAliases(row.aliases), recipientKey(row.id)], id),
+    firstSeen: Number(prev?.firstSeen) || now,
+    lastSeen: now,
+    endedAt: ended ? now : null,
+    hostStatus: row.hostStatus ? String(row.hostStatus).slice(0, 16) : (prev?.hostStatus || null),
+  };
+  if (index >= 0) rows[index] = entry; else rows.push(entry);
+  return rows
+    .sort((left, right) => Number(left.lastSeen) - Number(right.lastSeen))
+    .slice(-DIRECTORY_CAP);
+}
+
+// Directed-target resolution over the directory: exact id/alias, else a unique
+// >=8-character prefix. Branch names are deliberately NOT accepted here — over
+// two weeks of history a branch names many conversations. Returns the single
+// entry, or ambiguous=true when several match (fail closed).
+function resolveDirectoryTarget(target, directory) {
+  const wanted = String(target || '').trim().toLowerCase();
+  const rows = Array.isArray(directory) ? directory : [];
+  if (!wanted) return { entry: null, ambiguous: false };
+  const keysOf = (entry) => [entry.id, ...(entry.aliases || [])].map((value) => String(value).toLowerCase());
+  const exact = rows.filter((entry) => keysOf(entry).includes(wanted));
+  if (exact.length === 1) return { entry: exact[0], ambiguous: false };
+  if (exact.length > 1) return { entry: null, ambiguous: true };
+  if (wanted.length >= 8) {
+    const prefixed = rows.filter((entry) => keysOf(entry).some((key) => key.startsWith(wanted)));
+    if (prefixed.length === 1) return { entry: prefixed[0], ambiguous: false };
+    if (prefixed.length > 1) return { entry: null, ambiguous: true };
+  }
+  return { entry: null, ambiguous: false };
+}
+
+// Host activity status from the event that touched the row. A prompt or tool
+// call means the model is working; a Stop/complete means it is waiting for the
+// human. Heartbeats carry no status and keep the previous one. This is the
+// difference between "inactive" (which the founder read as "closed") and
+// "idle for 14 minutes — it will read your note the next time it is prompted".
+const hostStatusFromEvent = (event) => {
+  const name = String(event || '');
+  if (/^(?:UserPromptSubmit|PreToolUse|PostToolUse|McpToolUse|McpTaskStart|McpTaskCheckpoint)$/i.test(name)) return 'busy';
+  if (/^(?:Stop|McpTaskComplete|SessionStart)$/i.test(name)) return 'idle';
+  return null;
+};
+
+// "working" | "idle" | "idle 14m" | "" (unknown). Shared by every renderer so
+// the peer footer, brain_sync, doctor and the send receipt agree on one word.
+export function sessionStatusLabel(session, now = Date.now()) {
+  const status = String(session?.hostStatus || '');
+  if (!status) return '';
+  const at = Number(session?.hostStatusAt || session?.lastSeen || now);
+  if (status === 'busy' && now - at < HOST_STATUS_BUSY_FRESH_MS) return 'working';
+  const min = Math.max(0, Math.round((now - at) / 60_000));
+  return min <= 0 ? 'idle' : `idle ${min}m`;
+}
+
+// "2h ago" for receipts and labels — one helper so every surface agrees.
+export function agoLabel(ms) {
+  const m = Math.max(0, Math.round(Number(ms || 0) / 60_000));
+  if (m < 1) return 'just now';
+  if (m < 60) return `${m}m ago`;
+  const h = Math.round(m / 60);
+  return h < 48 ? `${h}h ago` : `${Math.round(h / 24)}d ago`;
+}
+
+// The command a human can paste to bring a closed session back, when the host
+// has one. Only the two hosts whose resume-by-id was verified (2026-09-30):
+// Claude Code `claude --resume <id>` and Codex `codex resume <id>`; both
+// accept the exact id the lane stores. Anything else returns ''.
+export function resumeCommandFor(client, id) {
+  const key = String(client || '').toLowerCase();
+  const sid = recipientKey(id);
+  // The command is shown to a model and may be pasted by a human: only an id
+  // made of identifier characters may ever appear in it (the lane is
+  // same-user-writable, so the id is not trusted as shell-safe by origin).
+  if (!sid || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(sid)) return '';
+  if (key === 'claude-code' || key === 'claude') return `claude --resume ${sid}`;
+  if (key === 'codex') return `codex resume ${sid}`;
+  return '';
+}
+
 export function sessionDeliveryReachability(session) {
   const channels = new Set(Array.isArray(session?.channels) ? session.channels.map(String) : []);
   const transport = session?.transport && typeof session.transport === 'object' ? session.transport : {};
@@ -663,7 +809,13 @@ function pruneMessages(messages, now) {
     if (!message) continue;
     const terminalAt = Number(message.deadLetter?.at || message.retiredAt || 0);
     if (terminalAt && now - terminalAt >= MESSAGE_RECEIPT_FRESH_MS) continue;
-    if (!terminalAt && now - Number(message.ts || 0) >= MESSAGE_FRESH_MS) {
+    // A note queued for a session that was not running carries its own
+    // deadline (MESSAGE_OFFLINE_FRESH_MS from send); every other note keeps
+    // the 24h rule. PARITY: global-brain-hook.mjs maintainMsgs.
+    const deadline = Number(message.expiresAt) > 0
+      ? Number(message.expiresAt)
+      : Number(message.ts || 0) + MESSAGE_FRESH_MS;
+    if (!terminalAt && now >= deadline) {
       message = terminalizeMessage(message, now, 'expired-before-consumption');
     }
     out.push(message);
@@ -771,6 +923,9 @@ export function upsertSession({
   // pointer instead of the same ~5k chars. ADDITIVE — written only when a
   // writer passes it; kept verbatim by every other touch (…previous spread).
   statusDigestHash,
+  // Host activity status (mailbox, 1.88.0): 'busy' | 'idle'. Derived from
+  // `event` when a writer does not pass it; heartbeats keep the previous value.
+  hostStatus = null,
   now = Date.now(),
 }) {
   if (!brainPath || !id) return withWriteVerdict([], false, 'no-brain-or-id');
@@ -869,6 +1024,7 @@ export function upsertSession({
     const activityEvent = /^(?:McpToolUse|McpTaskStart|McpTaskCheckpoint|UserPromptSubmit|PreToolUse|PostToolUse)$/i.test(String(event || ''))
       ? String(event)
       : null;
+    const nextHostStatus = hostStatus ? String(hostStatus).slice(0, 16) : hostStatusFromEvent(event);
     const next = {
       ...previous,
       id: String(id),
@@ -932,6 +1088,11 @@ export function upsertSession({
           ...(taskCompleted ? { completedAt: now } : (previous.completedAt ? { completedAt: previous.completedAt } : {})),
         }),
       ...(statusDigestHash !== undefined ? { statusDigestHash: String(statusDigestHash || '').slice(0, 16) } : {}),
+      // ADDITIVE host status: stamped only when this touch carries one, kept
+      // verbatim otherwise, so a heartbeat never turns "working" into unknown.
+      ...(nextHostStatus
+        ? { hostStatus: nextHostStatus, hostStatusAt: now }
+        : (previous.hostStatus ? { hostStatus: previous.hostStatus, hostStatusAt: previous.hostStatusAt || null } : {})),
       lastSeen: now,
     };
     const kept = sessions.filter((session) => session.id !== id);
@@ -942,6 +1103,7 @@ export function upsertSession({
       sessions: kept.slice(-40),
       messages: maintainMessages(data.messages, now),
       endedSessions,
+      directory: rememberSession(data.directory, next, now),
     }));
     return withWriteVerdict(kept.sort((a, b) => Number(b.lastSeen || 0) - Number(a.lastSeen || 0)), true);
   } finally {
@@ -1200,12 +1362,18 @@ export function endSession({ brainPath, id, home, now = Date.now(), expectedPid
     const kept = sessions.filter((session) => !identities.includes(recipientKey(session.id))
       && !normalizeAliases(session.aliases).some((alias) => identities.includes(alias))
       && !(session.logicalSessionId && identities.includes(recipientKey(session.logicalSessionId))));
+    // The directory keeps the closed conversation as a door a note can wait at
+    // ("closed 2h ago"), stamped ended so readers never call it merely idle.
+    const directory = row
+      ? rememberSession(data.directory, { ...row, logicalSessionId: row.logicalSessionId || row.id, hostStatus: 'idle' }, now, { ended: true })
+      : pruneDirectory(data.directory, now);
     fs.mkdirSync(path.dirname(laneFile), { recursive: true });
     writeLaneFileAtomic(laneFile, JSON.stringify({
       ...data,
       sessions: kept,
       messages: maintainMessages(data.messages, now),
       endedSessions,
+      directory,
     }));
     return { ok: true, changed: kept.length !== sessions.length, reason: null, sessions: kept };
   } finally {
@@ -2077,29 +2245,39 @@ export function shortestUniqueSessionPrefix(sessions, sessionId, minLength = 8)
   return canonical;
 }
 
-export function resolveMessageTargetIds(message, sessions) {
+// Live-target resolution with its verdict: `ids` is the resolved audience and
+// `ambiguous` says whether an empty result means "nobody matched" or "several
+// matched" — the mailbox needs the difference, because only a target that
+// matched NO live row may fall through to the directory. PARITY:
+// global-brain-hook.mjs resolveMsgTarget.
+export function resolveMessageTarget(message, sessions) {
   const rows = Array.isArray(sessions) ? sessions : [];
   const target = String(message?.to || '').trim().toLowerCase();
-  if (!target || target === 'all' || target === '*') return rows.map((row) => String(row.id));
+  if (!target || target === 'all' || target === '*') return { ids: rows.map((row) => String(row.id)), ambiguous: false };
 
   // Full canonical ids and aliases are accepted only when they resolve to one
   // row. This also makes a retained provisional id useful after atomic rekey.
   const exactIdentity = rows.filter((row) => sessionIdentityKeys(row).includes(target));
-  if (exactIdentity.length === 1) return [String(exactIdentity[0].id)];
-  if (exactIdentity.length > 1) return [];
+  if (exactIdentity.length === 1) return { ids: [String(exactIdentity[0].id)], ambiguous: false };
+  if (exactIdentity.length > 1) return { ids: [], ambiguous: true };
 
   // Prefixes are intentionally fail-closed and require >=8 characters.
   if (target.length >= 8) {
     const prefixMatches = rows.filter((row) => sessionIdentityKeys(row)
       .some((key) => key.startsWith(target)));
-    if (prefixMatches.length === 1) return [String(prefixMatches[0].id)];
-    if (prefixMatches.length > 1) return [];
+    if (prefixMatches.length === 1) return { ids: [String(prefixMatches[0].id)], ambiguous: false };
+    if (prefixMatches.length > 1) return { ids: [], ambiguous: true };
   }
 
   // Human-friendly branch targeting remains, but only exact and unique. Intent,
   // client and surface substring matching are deliberately forbidden.
   const branchMatches = rows.filter((row) => String(row?.branch || '').trim().toLowerCase() === target);
-  return branchMatches.length === 1 ? [String(branchMatches[0].id)] : [];
+  if (branchMatches.length === 1) return { ids: [String(branchMatches[0].id)], ambiguous: false };
+  return { ids: [], ambiguous: branchMatches.length > 1 };
+}
+
+export function resolveMessageTargetIds(message, sessions) {
+  return resolveMessageTarget(message, sessions).ids;
 }
 
 function messageTargetsSession(message, session, sessionId, sessions = []) {
@@ -2421,6 +2599,12 @@ export function postPresenceMessage({
   // hand-typed targets: the exactly-one-live-row refusal below is what keeps an
   // ambiguous prefix from queuing a note nobody will ever receive.
   allowOfflineTarget = false,
+  // Mailbox (1.88.0): a hand-typed target that matches NO live row may still
+  // name exactly one session the directory remembers (closed, or gone from the
+  // lane). The note is then QUEUED for that id — delivered the moment the
+  // session is back — instead of refused. Ambiguity still fails closed, and a
+  // target nobody remembers is 'target-unknown', never a silent queue.
+  allowKnownOfflineTarget = false,
 }) {
   const body = neutralizeMarkers(String(text || '').replace(/\s+/g, ' ').trim().slice(0, 400));
   if (!brainPath || !from || !body) return { posted: false, message: null, reason: 'invalid-message' };
@@ -2440,15 +2624,19 @@ export function postPresenceMessage({
       if (existing) return { posted: false, message: existing, reason: 'duplicate' };
     }
     const senderId = String(from).slice(0, 160);
-    const target = String(to || 'all').replace(/\s+/g, ' ').trim().slice(0, 160) || 'all';
+    // The broadcast verdict is decided on the same folded value the resolver
+    // uses ("ALL" is a broadcast everywhere, including the hook twin), and the
+    // stored `to` is the canonical 'all' so every later reader agrees.
+    const rawTarget = String(to || 'all').replace(/\s+/g, ' ').trim().slice(0, 160) || 'all';
+    const broadcast = /^(?:all|\*)$/i.test(rawTarget);
+    const target = broadcast ? 'all' : rawTarget;
     // Receipt truth must survive peers ending before the sender checks doctor.
     // Snapshot only recipient session ids (already lane metadata) at SEND time;
     // old messages without this additive field retain reconstruction fallback.
-    const resolvedTargets = resolveMessageTargetIds({ to: target }, sessions);
-    const candidateIds = resolvedTargets
+    const resolution = resolveMessageTarget({ to: target }, sessions);
+    const candidateIds = resolution.ids
       .filter((id) => id && id !== senderId)
       .map((id) => String(id).slice(0, 160));
-    const broadcast = target === 'all' || target === '*';
     // A broadcast with no OTHER live recipient is not a successful handoff.
     // Refuse before constructing/persisting a message so no zero-audience row
     // can later be mistaken for queued or delivered work.
@@ -2457,13 +2645,37 @@ export function postPresenceMessage({
     }
     // A targeted hint that does not resolve to exactly one OTHER live row is
     // unsafe: it may be an ambiguous UUID prefix or duplicated branch. Refuse
-    // instead of queuing a note whose visible `to` never had a recipient.
+    // instead of queuing a note whose visible `to` never had a recipient —
+    // unless the target matched NOBODY live and is (a) an exact id a machine
+    // caller vouched for, or (b) one session the directory remembers.
+    let offline = null;
     if (!broadcast && candidateIds.length !== 1) {
-      if (!(allowOfflineTarget && candidateIds.length === 0)) {
+      const selfOnly = resolution.ids.length > 0 && resolution.ids.every((id) => id === senderId);
+      const nobodyLive = candidateIds.length === 0 && !resolution.ambiguous && !selfOnly;
+      if (nobodyLive && allowKnownOfflineTarget) {
+        const known = resolveDirectoryTarget(target, pruneDirectory(data.directory, now));
+        if (known.ambiguous) return { posted: false, message: null, reason: 'target-not-unique' };
+        if (!known.entry) return { posted: false, message: null, reason: 'target-unknown' };
+        if (known.entry.id === senderId) return { posted: false, message: null, reason: 'target-not-unique' };
+        candidateIds.push(known.entry.id);
+        offline = {
+          queuedAt: now,
+          target: {
+            id: known.entry.id,
+            client: known.entry.client,
+            intent: known.entry.intent,
+            lastSeen: known.entry.lastSeen,
+            endedAt: known.entry.endedAt || null,
+          },
+        };
+      } else if (allowOfflineTarget && candidateIds.length === 0) {
+        // Offline machine-known recipient: address the exact id we were handed
+        // (1.87 semantics kept verbatim — a logical id split across two live
+        // rows still resolves through candidateIds, so it is not refused).
+        candidateIds.push(String(target).slice(0, 160));
+      } else {
         return { posted: false, message: null, reason: 'target-not-unique' };
       }
-      // Offline machine-known recipient: address the exact id we were handed.
-      candidateIds.push(String(target).slice(0, 160));
     }
     const message = {
       id: sha16(`${from}|${to}|${body}|${now}|${crypto.randomBytes(4).toString('hex')}`),
@@ -2476,6 +2688,10 @@ export function postPresenceMessage({
       deliveries: candidateIds.map((recipientId) => ({ recipientId, state: 'pending', attempts: 0 })),
       candidateIds,
       ...(key ? { dedupeKey: key } : {}),
+      // Every directed note keeps for a week (see MESSAGE_DIRECTED_FRESH_MS);
+      // `offline` additionally records that the target was away at send time.
+      ...(broadcast ? {} : { expiresAt: now + MESSAGE_DIRECTED_FRESH_MS }),
+      ...(offline ? { offline } : {}),
     };
     messages.push(message);
     fs.mkdirSync(path.dirname(laneFile), { recursive: true });
@@ -2484,12 +2700,82 @@ export function postPresenceMessage({
       sessions,
       messages: capMessages(messages, MESSAGE_LANE_CAP, now),
     }));
-    return { posted: true, message, reason: null };
+    // Who will actually see this, and in what state — the sender's reply to the
+    // human is built from this, so it must say "idle 14m" or "not running",
+    // never just "queued".
+    const recipients = candidateIds.map((id) => {
+      const row = sessions.find((session) => String(session.id) === id);
+      if (row) {
+        return {
+          id,
+          live: true,
+          client: row.client || 'unknown',
+          intent: String(row.intent || '').slice(0, 120),
+          branch: row.branch || null,
+          deliveryReachability: row.deliveryReachability || sessionDeliveryReachability(row),
+          hostStatus: row.hostStatus || null,
+          statusLabel: sessionStatusLabel(row, now),
+          lastSeen: Number(row.lastSeen || 0) || null,
+          endedAt: null,
+          resumeCommand: '',
+        };
+      }
+      const known = offline?.target?.id === id ? offline.target : null;
+      // "not seen for 2h" — honest about what the lane knows: ten minutes of
+      // silence means closed OR idle with no KLYPIX heartbeat; only a
+      // SessionEnd (Codex) proves "closed". Either way the note is delivered
+      // the moment that session next acts.
+      return {
+        id,
+        live: false,
+        client: known?.client || 'unknown',
+        intent: known?.intent || '',
+        branch: null,
+        deliveryReachability: 'not-running',
+        hostStatus: null,
+        statusLabel: known?.endedAt ? 'closed' : (known?.lastSeen ? `not seen for ${agoLabel(now - known.lastSeen).replace(/ ago$/, '')}` : 'not running'),
+        lastSeen: known?.lastSeen || null,
+        endedAt: known?.endedAt || null,
+        resumeCommand: resumeCommandFor(known?.client, id),
+      };
+    });
+    return { posted: true, message, reason: null, queuedOffline: Boolean(offline), recipients };
   } finally {
     releaseLock(lockFile);
   }
 }
 
+// Every session the directory remembers (two weeks), joined with the live lane:
+// `live` says whether a row is heartbeating now, `status` is the shared word
+// ("working", "idle 14m", "closed", "not running"), and `waitingNotes` counts
+// notes queued for that id that nobody has offered yet. Read-only; this is the
+// data behind "recent sessions" in doctor, a CLI verb, or an app switchboard.
+export function listKnownSessions({ brainPath, home, now = Date.now() } = {}) {
+  if (!brainPath) return [];
+  const lane = readLane(laneFileFor(brainPath, home));
+  const live = pruneSessions(lane.sessions, now);
+  const messages = (Array.isArray(lane.messages) ? lane.messages : [])
+    .map((message) => normalizeMessageDelivery(message, now))
+    .filter((message) => message && !isTerminalMessage(message));
+  return pruneDirectory(lane.directory, now).map((entry) => {
+    const wanted = entry.id.toLowerCase();
+    const row = live.find((session) => sessionIdentityKeys(session).includes(wanted)) || null;
+    const waitingNotes = messages.filter((message) => Array.isArray(message.candidateIds)
+      && message.candidateIds.map(recipientKey).includes(entry.id)
+      && messageDeliveryState(message, entry.id) === 'pending').length;
+    return {
+      ...entry,
+      live: Boolean(row),
+      status: row ? (sessionStatusLabel(row, now) || 'live')
+        : (entry.endedAt ? 'closed' : `not seen for ${agoLabel(now - entry.lastSeen).replace(/ ago$/, '')}`),
+      lastSeen: row ? Number(row.lastSeen || entry.lastSeen) : entry.lastSeen,
+      deliveryReachability: row ? (row.deliveryReachability || sessionDeliveryReachability(row)) : 'not-running',
+      waitingNotes,
+      resumeCommand: row ? '' : resumeCommandFor(entry.client, entry.id),
+    };
+  }).sort((left, right) => Number(right.lastSeen) - Number(left.lastSeen));
+}
+
 const clientLabel = (session) => {
   const client = String(session?.client || '').toLowerCase();
   if (!client) return 'Claude Code';
@@ -2610,8 +2896,14 @@ export function formatPresenceMessage(sessions, selfId, { includeSolo = false, n
     // 100-minute-old task line can never read as "what they're doing right now".
     const intentAgeMin = group.intentAt ? Math.max(0, Math.round((now - Number(group.intentAt)) / 60_000)) : null;
     const intentAge = intentAgeMin !== null && intentAgeMin - ageMin > 3 ? ` (intent set ${intentAgeMin}m ago)` : '';
+    // Host status rides the row that carries it (a lifecycle row knows Stop /
+    // prompt; an MCP-only row may not) — take the freshest stamped one.
+    const statusRow = group.rows
+      .filter((row) => row.hostStatus)
+      .sort((a, b) => Number(b.hostStatusAt || b.lastSeen || 0) - Number(a.hostStatusAt || a.lastSeen || 0))[0] || null;
     const details = [
       clientLabel(session),
+      statusRow ? sessionStatusLabel(statusRow, now) : null,
       group.rows.length > 1 ? `${group.rows.length} connections` : null,
       group.branch ? `branch ${group.branch}` : null,
       group.intent ? `"${String(group.intent).slice(0, 90)}"${intentAge}` : null,
@@ -2693,7 +2985,10 @@ export function formatReceivedMessages(messages, now = Date.now(), decay = {}, s
     const senderLabel = senders.length <= 3 ? senders.join(', ') : `${senders.slice(0, 3).join(', ')} +${senders.length - 3}`;
     const oldestTs = Math.min(...group.map(item => Number(item?.ts) || now));
     const ageMin = Math.max(0, Math.round((now - oldestTs) / 60_000));
-    lines.push(`- from ${senderLabel} (${ageMin}m ago): ${neutralizeMarkers(String(message.text || '').replace(/\s+/g, ' ').trim().slice(0, 400))}`);
+    // A note that waited for this session while it was not running says so:
+    // the reader should treat it as the sender's state THEN, not a live ping.
+    const waited = group.some((item) => item?.offline) ? ', left while this session was not running' : '';
+    lines.push(`- from ${senderLabel} (${ageMin}m ago${waited}): ${neutralizeMarkers(String(message.text || '').replace(/\s+/g, ' ').trim().slice(0, 400))}`);
     const receipts = group.map((item) => messageDeliveryReceipt(item, sessionId)).filter(Boolean);
     if (receipts.length) {
       lines.push(`  Receipt(s): ${receipts.map((receipt) => `${receipt.messageId}:${receipt.offerToken}`).join(', ')}. After incorporating ${receipts.length === 1 ? 'it' : 'them'}, call brain_message_receipt with each exact message_id and offer_token — that is the ONLY way the sender learns you acted on ${receipts.length === 1 ? 'it' : 'them'}. If you skip it, your next independent action auto-consumes ${receipts.length === 1 ? 'this note' : 'these notes'} and the sender is told only that ${receipts.length === 1 ? 'it was' : 'they were'} auto-consumed.`);