@agfpd/iapeer 0.4.85 → 0.4.87

package/docs/10-messaging.md

@@ -34,7 +34,25 @@ The daemon finds the recipient in the registry and looks at its state:
 
 The key guarantee: `delivered` means the message actually landed in a live session (the daemon waited for confirmation), not that it was just sent into the void. If the session didn't confirm receipt in the allotted time, the daemon treats it as dead and doesn't lie about success.
 
-In every message's envelope travels the sender's nature (`intelligence`) — the recipient knows whether a human, an agent, or a service process is writing to it.
+In every message's envelope travels the sender's nature (`intelligence`) — the recipient knows whether a human, an agent, or a service process is writing to it — and the dispatch instant (`ts`): the moment the router accepted the send. The same instant is returned to the sender as the `ts` field of its `send_to_peer` result, so both sides of a conversation can literally compare timestamps — which is what makes an async desync (a reply addressing an already-outdated state) visible to the recipient instead of silent.
+
+## Envelope: wire form vs agent presentation
+
+The envelope exists in two renderings of the same content:
+
+- **Wire form** — the canonical durable shape: legacy attribute names (`from-personality` / `from-runtime` / `from-intelligence`), `ts` as a full local ISO instant with offset, the body always CDATA-wrapped, `<message>` tag. This is what travels through disk queues, what bridge runtimes (telegram / notifier / voicetalk) receive and parse, and what their pane logs show. It never slims: its bytes cost no tokens, and every deployed parser keeps working unchanged.
+- **Agent presentation** — rendered at the last hop wherever text enters an LLM context (a live delivery to a claude/codex session, a wake boot first-message, an ephemeral-queue drain):
+
+  ```
+  <iap from="boris" runtime="claude" intelligence="artificial" ts="01:23:45">
+  Reply via send_to_peer.
+  <msg>message body…</msg>
+  </iap>
+  ```
+
+  Short attribute names, `ts` compacted to local host time — time-only when the message was sent the same local calendar day it is delivered, date-prefixed (`2026-07-13 01:23:45`) otherwise, so a queue-drained or long-delayed message can never masquerade as fresh. The body is raw (no CDATA) unless it quotes envelope machinery itself — then it keeps the CDATA wrapping (a cosmetic fallback, nothing parses the presentation). The render is fail-open: any problem delivers the wire form as-is rather than risking the message.
+
+So host logs deliberately show two envelope shapes: bridge-bound pane logs carry the wire form, agent-bound pane logs and transcripts carry the compact presentation. The core decoder reads both name sets (and both `<message>`/`<msg>` tags), so any envelope ever emitted on the host — including historic transcripts — still decodes.
 
 ## Message limits
 

package/docs/16-tray.md

@@ -85,7 +85,7 @@ whole dashboard twice.
 | `iapeer tray render [--stream]` | Print the SwiftBar plugin output. `--stream` is the streamable loop the plugin runs; the one-shot form is the poll fallback and the test surface. |
 | `iapeer tray cmd <command> <peer> [runtime]` | POST a fleet command (`wake`/`stop`/`start`/`new`/`refresh`/`interrupt`/`compact`) — the menu's lifecycle actions call this. |
 | `iapeer tray approve <id>` · `iapeer tray deny <id> [reason]` | Resolve a pending human-approval (docs/17) — `POST /fleet/v1/approvals/<id>/(approve\|deny)` over the same unix-first fleet client. The menu's Allow/Deny items call these; the single-queue invariant means the resolution is seen by every channel (CLI, telegram). |
-| `iapeer tray status` | Read-only: is the fleet API up (from `router.json`), is SwiftBar installed and where is its plugin dir, is the plugin file present, **is the tray-host supervisor registered**. Repairs nothing. |
+| `iapeer tray status` | Read-only: is the fleet API up (from `router.json`), is SwiftBar installed and where is its plugin dir, is the plugin file present, **is the tray-host supervisor registered**, and **is the menu-bar icon visible right now** (the persisted `NSStatusItem VisibleCC` state — the ground truth to read first when "the icon is gone" is reported; no screen needed). Repairs nothing. |
 
 ## How it is wired
 

package/docs/ru/16-tray.md

@@ -81,7 +81,7 @@ SwiftBar.app, если его нет.
 | `iapeer tray render [--stream]` | Печатает вывод плагина SwiftBar. `--stream` — streamable-цикл, который крутит плагин; одноразовая форма — поллинг-фолбэк и тест-поверхность. |
 | `iapeer tray cmd <command> <peer> [runtime]` | POST fleet-команды (`wake`/`stop`/`start`/`new`/`refresh`/`interrupt`/`compact`) — lifecycle-пункты меню зовут это. |
 | `iapeer tray approve <id>` · `iapeer tray deny <id> [reason]` | Резолв ожидающего human-approval (docs/17) — `POST /fleet/v1/approvals/<id>/(approve\|deny)` через тот же unix-first fleet-клиент. Пункты Allow/Deny меню зовут это; инвариант единой очереди — резолв виден каждому каналу (CLI, telegram). |
-| `iapeer tray status` | Только чтение: жив ли fleet API (из `router.json`), установлен ли SwiftBar и где его каталог плагинов, на месте ли файл плагина, **зарегистрирован ли супервизор tray-хоста**. Ничего не чинит. |
+| `iapeer tray status` | Только чтение: жив ли fleet API (из `router.json`), установлен ли SwiftBar и где его каталог плагинов, на месте ли файл плагина, **зарегистрирован ли супервизор tray-хоста** и **видима ли иконка в менюбаре прямо сейчас** (персистентное состояние `NSStatusItem VisibleCC` — ground truth, который читают первым при жалобе «иконка пропала»; экран не нужен). Ничего не чинит. |
 
 ## Как устроено
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.85",
+  "version": "0.4.87",
   "description": "Run Claude Code and Codex CLI as local background agents that message each other, wake on demand, and share one memory.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/cli/index.ts

@@ -2607,8 +2607,10 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
                 `  sock: ${s.daemon.sock ?? '—'}\n` +
                 `  tcp:  ${s.daemon.tcp ?? '—'}\n` +
                 `SwiftBar: ${s.swiftbar.installed ? `installed (plugin dir: ${s.swiftbar.pluginDir ?? 'unset'})` : 'not installed'}\n` +
+                // the persisted NSStatusItem visibility — ground truth for "the icon is gone"
+                `menu-bar icon: ${s.swiftbar.iconVisible === undefined ? 'unknown (no persisted state)' : s.swiftbar.iconVisible ? 'visible' : 'HIDDEN (persisted NSStatusItem VisibleCC=0)'}\n` +
                 `plugin: ${s.plugin.installed ? s.plugin.path : 'not installed'}\n` +
-                `login autostart: ${s.autostart.registered ? s.autostart.path : 'not registered'}\n`,
+                `supervisor (autostart): ${s.autostart.registered ? s.autostart.path : 'not registered'}\n`,
             )
             return 0
           }

package/src/codec/index.ts

@@ -1,10 +1,20 @@
-// IAP envelope codec — encoder + decoder, both halves in one module.
+// IAP envelope codec — wire encoder + read-both decoder + agent-facing render.
 //
-// Encoder: inter-agent-protocol/src/lib/preamble.ts buildEnvelope (wins as-is).
-// Decoder: telegram-runtime/src/cli.ts parseIapEnvelope/extractIapEnvelopes,
-//   rewritten CDATA-AWARE (blueprint-v2 codec-fixes) so that an envelope whose
-//   message contains `</iap>`, `</message>`, `]]>` or a literal CR round-trips
-//   by FIELD-semantic equivalence, not byte-equality.
+// Three halves (envelope-compaction F, 0.4.86):
+//   buildEnvelope          → the WIRE form (legacy attr names, always-CDATA, full-ISO ts) —
+//                            what bridges parse and durable stores hold; never slims.
+//   decodeEnvelope         → READ-BOTH (legacy + compact names, <message>/<msg>, ts),
+//                            CDATA-AWARE so a body containing `</iap>`, `</message>`,
+//                            `]]>` or a literal CR round-trips by FIELD-semantic
+//                            equivalence, not byte-equality.
+//   renderEnvelopeForAgent → the compact presentation for LLM-context hops (bottom).
+//
+// Historic origin: encoder from inter-agent-protocol preamble.ts; decoder from
+// telegram-runtime parseIapEnvelope/extractIapEnvelopes. The sibling runtimes run
+// their own copies of the decoder, SYNCED to this canon 14.07.2026 (telegram-runtime
+// 0.26.0, notifier-runtime 0.3.6, voicetalk-runtime 0.1.1 — anchored attrValue, В37/В38,
+// read-both); a decoder-behavior change here should be mirrored there (or flagged to
+// their implementers). The wire form stays compatible with all of them regardless.
 //
 // Deliberately NO CR→LF fold here. The old telegram decoder did
 // `xml.replace(/\r\n?/g, '\n')` to repair tmux paste (which rewrites LF→CR).
@@ -30,11 +40,38 @@ export interface EnvelopeInput {
   fromPersonality: string
   fromRuntime: Runtime
   fromIntelligence: Intelligence
+  /** ISO-8601 LOCAL instant with offset (formatSentAt) — the moment the router
+   *  ACCEPTED the send; the same string is returned to the sender as the `ts`
+   *  field of its send_to_peer result, so recipient-side `ts` and sender-side
+   *  `ts` correspond literally. Rendered as the `ts` open-tag attribute.
+   *  ADDITIVE and optional: every known envelope consumer reads attributes by
+   *  NAME and ignores unknown ones; absent on legacy envelopes. On the WIRE this
+   *  is always the FULL date-time (durable stores — disk queues, pane logs —
+   *  must be unambiguous); the agent-facing render compacts it (see
+   *  renderEnvelopeForAgent). */
+  sentAt?: string
   topic?: string
   attachments?: readonly string[]
   message: string
 }
 
+const pad2 = (n: number): string => String(n).padStart(2, '0')
+
+/** Format a Date as ISO-8601 LOCAL time with numeric offset, second precision:
+ *  `2026-07-14T01:23:45+03:00`. Local (not UTC-Z) on purpose: the fleet's agents
+ *  compare envelope timestamps against their LOCAL statusline clock — a Z-form
+ *  invites silent off-by-offset misreads by an LLM reader. */
+export function formatSentAt(date: Date): string {
+  const offMin = -date.getTimezoneOffset() // minutes EAST of UTC
+  const sign = offMin >= 0 ? '+' : '-'
+  const abs = Math.abs(offMin)
+  return (
+    `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}` +
+    `T${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}` +
+    `${sign}${pad2(Math.floor(abs / 60))}:${pad2(abs % 60)}`
+  )
+}
+
 function escapeAttr(value: string): string {
   return value
     .replace(/&/g, '&amp;')
@@ -49,12 +86,20 @@ function cdata(value: string): string {
   return `<![CDATA[${value.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`
 }
 
+/** WIRE encoder — the canonical durable form (disk queues, bridge deliveries,
+ *  pane logs): legacy attribute names + always-CDATA body, so every deployed
+ *  sibling parser (telegram-/notifier-/voicetalk-runtime) keeps working
+ *  unchanged. `ts` is the only additive attribute (envelope-compaction F).
+ *  Agent-bound deliveries are re-rendered compactly at the LAST hop — see
+ *  renderEnvelopeForAgent; the wire form itself never slims (its bytes cost no
+ *  tokens; only the LLM-context presentation does). */
 export function buildEnvelope(input: EnvelopeInput): string {
   const attrs = [
     `from-personality="${escapeAttr(input.fromPersonality)}"`,
     `from-runtime="${escapeAttr(input.fromRuntime)}"`,
     `from-intelligence="${escapeAttr(input.fromIntelligence)}"`,
   ]
+  if (input.sentAt) attrs.push(`ts="${escapeAttr(input.sentAt)}"`)
   const topic = input.topic?.trim()
   if (topic) {
     attrs.push(`topic="${escapeAttr(topic.slice(0, MAX_TOPIC_LEN))}"`)
@@ -146,13 +191,21 @@ export interface IapEnvelope {
   fromPersonality: string
   fromRuntime: Runtime
   fromIntelligence?: Intelligence
+  /** The sender's dispatch instant (`ts` attribute) — full local ISO on the wire;
+   *  absent on legacy envelopes. */
+  sentAt?: string
   topic?: string
   attachments: string[]
   message: string
 }
 
+/** NAME-ANCHORED attribute lookup. The anchor `(^|\s)` is load-bearing: the old
+ *  unanchored regex made `runtime="` match the TAIL of `from-runtime="…"` (and
+ *  `intelligence="` the tail of `from-intelligence="…"`) — a latent mine that the
+ *  read-both decoder below would have stepped on (the short-name lookup must NOT
+ *  be satisfied by a legacy long-name attribute). */
 function attrValue(attrs: string, name: string): string | undefined {
-  const re = new RegExp(`${name}="([^"]*)"`)
+  const re = new RegExp(`(?:^|\\s)${name}="([^"]*)"`)
   const m = re.exec(attrs)
   return m ? unescapeAttr(m[1]) : undefined
 }
@@ -167,25 +220,34 @@ function unescapeAttr(value: string): string {
     .replace(/&amp;/g, '&')
 }
 
+/** READ-BOTH decoder: accepts the legacy wire names (`from-personality` /
+ *  `from-runtime` / `from-intelligence`, `<message>`) AND the compact
+ *  presentation names (`from` / `runtime` / `intelligence`, `<msg>`) — so any
+ *  envelope form ever emitted on this host (wire, agent-facing render, historic
+ *  transcripts) decodes. Short names win when both are present. */
 export function decodeEnvelope(xml: string): IapEnvelope {
   const open = /^<iap\s+([^>]*)>/.exec(xml.trim())
   if (!open) throw new IapError('invalid IAP envelope: missing <iap ...>')
-  const fromPersonality = attrValue(open[1], 'from-personality')
-  const fromRuntime = attrValue(open[1], 'from-runtime')
+  const fromPersonality = attrValue(open[1], 'from') ?? attrValue(open[1], 'from-personality')
+  const fromRuntime = attrValue(open[1], 'runtime') ?? attrValue(open[1], 'from-runtime')
   if (!fromPersonality || !fromRuntime) {
     throw new IapError('invalid IAP envelope: missing from-personality/from-runtime')
   }
   // READ-COMPAT: a legacy peer (live telegram) may stamp from-intelligence="human";
   // normalize human→natural / scripted→absent, drop a genuinely unknown value.
-  const fromIntelligence = normalizeIntelligenceValue(attrValue(open[1], 'from-intelligence'))
-  const message = readTagContent(xml, 'message')
+  const fromIntelligence = normalizeIntelligenceValue(
+    attrValue(open[1], 'intelligence') ?? attrValue(open[1], 'from-intelligence'),
+  )
+  const message = readTagContent(xml, 'message') ?? readTagContent(xml, 'msg')
   if (message === undefined) throw new IapError('invalid IAP envelope: missing message')
   const attachmentsRaw = readTagContent(xml, 'attachments')
   const topic = attrValue(open[1], 'topic')
+  const sentAt = attrValue(open[1], 'ts')
   return {
     fromPersonality,
     fromRuntime,
     ...(fromIntelligence ? { fromIntelligence } : {}),
+    ...(sentAt ? { sentAt } : {}),
     ...(topic ? { topic } : {}),
     attachments: attachmentsRaw
       ? attachmentsRaw.split('\n').map(item => item.trim()).filter(Boolean)
@@ -209,7 +271,12 @@ function openTagVerdict(candidate: string): 'valid' | 'invalid' | 'incomplete' {
     return unclosed && candidate.length <= MAX_OPEN_TAG_LEN ? 'incomplete' : 'invalid'
   }
   if (m[0].length > MAX_OPEN_TAG_LEN) return 'invalid'
-  return m[1].includes('from-personality="') && m[1].includes('from-runtime="') ? 'valid' : 'invalid'
+  // Read-both (envelope-compaction F): a real open tag carries the required pair
+  // under EITHER naming — legacy wire (from-personality/from-runtime) or compact
+  // presentation (from/runtime, name-anchored so a legacy tail never satisfies it).
+  const hasPersonality = m[1].includes('from-personality="') || /(?:^|\s)from="/.test(m[1])
+  const hasRuntime = m[1].includes('from-runtime="') || /(?:^|\s)runtime="/.test(m[1])
+  return hasPersonality && hasRuntime ? 'valid' : 'invalid'
 }
 
 /**
@@ -257,3 +324,84 @@ export function extractEnvelopes(buffer: string): { envelopes: string[]; rest: s
     rest = rest.slice(envelopeEnd)
   }
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Agent-facing presentation render (envelope-compaction F)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Presentation-hybrid gate: a body that itself contains envelope machinery
+ *  (a quoted envelope, tag markers, CDATA syntax) or a literal CR keeps its
+ *  CDATA wrapping in the presentation too — the cost of the gate firing is
+ *  purely COSMETIC (the agent sees today's CDATA form), whereas rendering such
+ *  a body raw would show the agent a "broken" nested envelope. Plain `<` (code
+ *  snippets etc.) renders raw: nothing parses the presentation. */
+const PRESENTATION_CDATA_MARKERS = [
+  '<iap ',
+  '</iap>',
+  '<message>',
+  '</message>',
+  '<msg>',
+  '</msg>',
+  '<attachments>',
+  '</attachments>',
+  '<![CDATA[',
+  ']]>',
+  '\r',
+] as const
+
+function presentBody(value: string): string {
+  return PRESENTATION_CDATA_MARKERS.some(marker => value.includes(marker)) ? cdata(value) : value
+}
+
+/** Compact the wire `ts` (full local ISO with offset) for the agent's eyes:
+ *  time-only `01:23:45` when the send happened on the SAME local calendar day
+ *  as the render (the normal case), date-prefixed `2026-07-13 01:23:45` when it
+ *  did not (queue drains, long sleeps, midnight crossings) — so a stale message
+ *  can never masquerade as fresh. Renders happen at the LAST delivery hop, so
+ *  "today" is delivery-time local. An unparseable ts passes through verbatim. */
+function renderTsForAgent(sentAt: string, now: Date): string {
+  const d = new Date(sentAt)
+  if (Number.isNaN(d.getTime())) return sentAt
+  const time = `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`
+  const sameLocalDay =
+    d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate()
+  return sameLocalDay ? time : `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${time}`
+}
+
+/**
+ * Render a WIRE envelope into the compact agent-facing presentation:
+ *
+ *   <iap from="boris" runtime="claude" intelligence="artificial" ts="01:23:45">
+ *   Reply via send_to_peer.
+ *   <msg>raw body…</msg>
+ *   </iap>
+ *
+ * Short attribute names, time-only `ts` (cross-day rule above), raw body
+ * (hybrid CDATA when the body quotes envelope machinery). Called ONLY at the
+ * two hops where text enters an LLM context (composeFirstMessage — wake boot +
+ * ephemeral drain; deliverWarm — live paths, gated on agent runtimes); bridge
+ * targets always receive the wire form their parsers expect.
+ *
+ * FAIL-OPEN: any decode/render problem returns the wire text unchanged — a
+ * presentation hiccup must never lose or mangle a delivery.
+ */
+export function renderEnvelopeForAgent(wire: string, now: Date = new Date()): string {
+  try {
+    const env = decodeEnvelope(wire)
+    const attrs = [`from="${escapeAttr(env.fromPersonality)}"`, `runtime="${escapeAttr(env.fromRuntime)}"`]
+    if (env.fromIntelligence) attrs.push(`intelligence="${escapeAttr(env.fromIntelligence)}"`)
+    if (env.sentAt) attrs.push(`ts="${escapeAttr(renderTsForAgent(env.sentAt, now))}"`)
+    if (env.topic) attrs.push(`topic="${escapeAttr(env.topic)}"`)
+    return [
+      `<iap ${attrs.join(' ')}>`,
+      IAP_INSTRUCTION,
+      ...(env.attachments.length
+        ? [`<attachments>${presentBody(env.attachments.join('\n'))}</attachments>`]
+        : []),
+      `<msg>${presentBody(env.message)}</msg>`,
+      '</iap>',
+    ].join('\n')
+  } catch {
+    return wire // fail-open: deliver the wire form rather than risk the message
+  }
+}

package/src/core/constants.ts

@@ -89,11 +89,12 @@ export function isIntelligenceAllowedForRuntime(runtime: string, intelligence: I
 // Infra runtimes are ALWAYS-ON (held live by launchd KeepAlive), as opposed to the
 // warm-on-demand agentic runtimes (claude/codex, woken by the daemon). Liveness is
 // a property of the RUNTIME, not the personality (zone Идентичность). Infra runtimes
-// are routers hosted by the pty supervisor: telegram/voicetalk carry a human channel
-// (inbound messages / voice), notifier receives send_to_peer(timer|watcher, …)
-// registration/live-reload — outbound to each is deliverHosted → the child's stdin.
+// are routers hosted by the pty supervisor: telegram/voicetalk/web carry a human
+// channel (inbound messages / voice / browser console), notifier receives
+// send_to_peer(timer|watcher, …) registration/live-reload — outbound to each is
+// deliverHosted → the child's stdin.
 // This set gates always-on launchd plist generation (src/launch/launchd.ts).
-const INFRA_RUNTIMES = new Set(['notifier', 'telegram', 'voicetalk'])
+const INFRA_RUNTIMES = new Set(['notifier', 'telegram', 'voicetalk', 'web'])
 
 export function isInfraRuntime(runtime: string): boolean {
   return INFRA_RUNTIMES.has(runtime)
@@ -111,6 +112,7 @@ export const INFRA_RUNTIME_BIN_ENV: Readonly<Record<string, string>> = {
   notifier: 'NOTIFIER_RUNTIME_BIN',
   telegram: 'TELEGRAM_RUNTIME_BIN',
   voicetalk: 'VOICETALK_RUNTIME_BIN',
+  web: 'WEB_RUNTIME_BIN',
 }
 
 /** The PATH-resolvable default launcher name per infra runtime (when no abs path
@@ -120,6 +122,7 @@ export const INFRA_RUNTIME_DEFAULT_BIN: Readonly<Record<string, string>> = {
   notifier: 'notifier-runtime',
   telegram: 'telegram-runtime',
   voicetalk: 'voicetalk-runtime',
+  web: 'web-runtime',
 }
 
 // codex MCP token-free import (contract Установка §codex MCP). codex REFUSES to import
@@ -197,8 +200,9 @@ export const PEERS_HOME_DIR = 'peers'
 export const LAUNCHD_LABEL_PREFIX = 'com.iapeer.'
 export const DAEMON_PLIST_LABEL = 'com.agfpd.iapeer'
 
-export const IAP_INSTRUCTION =
-  'IAP message from known peers. Reply via send_to_peer.'
+// Shortened 0.4.86 (envelope-compaction F): the long preamble duplicated doctrine
+// (origin-routing) for live sessions; the reply-routing cue is the load-bearing part.
+export const IAP_INSTRUCTION = 'Reply via send_to_peer.'
 
 export const ALWAYS_LOAD_META = {
   'anthropic/alwaysLoad': true,

package/src/daemon/index.ts

@@ -121,7 +121,7 @@ export function buildSendDescription(): string {
     'Peers can be agents, humans, or services. Runtime is the delivery surface, not the peer type.',
     'Current delivery supports any runtime endpoint that follows the IAP tmux socket convention. Claude/Codex are built-in local runtimes; external runtimes such as telegram can be exposed by runtime-router packages.',
     '',
-    "Use `personality`, not a runtime-prefixed identity. Set `runtime` to target a specific declared runtime for this send. If that runtime is warm-asleep, the daemon wakes it and delivers there; use this to intentionally bring up a second session of the same peer in parallel to the default runtime (for example codex alongside claude). Inbound peer messages arrive as <iap from-personality=\"...\" from-runtime=\"...\" from-intelligence=\"...\"> blocks. The topic attribute is optional.",
+    "Use `personality`, not a runtime-prefixed identity. Set `runtime` to target a specific declared runtime for this send. If that runtime is warm-asleep, the daemon wakes it and delivers there; use this to intentionally bring up a second session of the same peer in parallel to the default runtime (for example codex alongside claude). Inbound peer messages arrive as <iap from=\"...\" runtime=\"...\" intelligence=\"...\" ts=\"...\"> blocks; `ts` is the sender's dispatch time (local host time; date-prefixed when not sent today) — compare it with the current time to spot a stale/desynced message. The topic attribute is optional.",
   ].join('\n')
 }
 

package/src/daemon/main.ts

@@ -181,7 +181,7 @@ export function makeEphemeralRouteDeps(
 ): EphemeralRouteDeps {
   return {
     isEphemeral: cwd => isEphemeralPeer(cwd),
-    deliver: async ({ peer, envelope, topic, runtime }) => {
+    deliver: async ({ peer, envelope, topic, runtime, sentAt }) => {
       const rt = resolveWakeRuntime(runtime, peer)
       if (!rt.ok) return rt
       const identity = buildProcessAddress(rt.value, peer.personality)
@@ -201,7 +201,7 @@ export function makeEphemeralRouteDeps(
         queued: true,
         queuedBy: 'ephemeral',
         queueDepth: depth,
-        ts: new Date().toISOString(),
+        ts: sentAt ?? new Date().toISOString(),
       })
     },
   }

package/src/identity/index.ts

@@ -26,7 +26,7 @@ import {
 // KeepAlive, so creating one installs its always-on plist. Imported from the
 // launchd module directly (not the launch barrel) to keep the dependency surface
 // minimal — launchd.ts pulls only core/*, so identity → launch introduces no cycle.
-import { installAlwaysOnPlist } from '../launch/launchd.ts'
+import { installAlwaysOnPlist, installedPlistRuntime } from '../launch/launchd.ts'
 import { buildProcessAddress } from '../core/socket.ts'
 import { IapError } from '../core/errors.ts'
 import {
@@ -623,13 +623,30 @@ export function ensurePeerProfile(options: EnsurePeerProfileOptions): PeerProfil
   // and leaves no half-updated profile. Idempotent for our own (sentinel) plist.
   let intelligence = existing.intelligence
   if (isInfraRuntime(options.runtime)) {
-    installAlwaysOnPlist({
-      personality: existing.personality,
-      runtime: options.runtime,
-      cwd,
-      runtimeBin: options.runtimeBin,
-      env: options.env,
-    })
+    // MULTI-INFRA BRIDGE: the always-on plist scheme is ONE per personality, so when the
+    // personality's plist is already OCCUPIED by ANOTHER infra runtime (arthur: telegram,
+    // now declaring web), installing here would clobber the live channel — and the
+    // installAlwaysOnPlist collision guard would fail the whole declaration. Instead:
+    // DECLARE the runtime (runtimes += <rt> below — identity `<rt>-<p>` resolves, delivery
+    // to a LIVE hosted session works) but leave the first channel's plist untouched. The
+    // new runtime's session is NOT launchd-owned until per-runtime plists (multi-infra)
+    // land — bring it up manually via `iapeer run-infra <p> <rt>` meanwhile.
+    const occupied = installedPlistRuntime(existing.personality, options.env)
+    if (occupied && occupied !== options.runtime) {
+      options.warn?.(
+        `always-on plist for "${existing.personality}" already holds runtime "${occupied}" — ` +
+          `"${options.runtime}" is DECLARED but gets no launchd plist (one plist per personality); ` +
+          `until per-runtime plists land, bring the session up manually: iapeer run-infra ${existing.personality} ${options.runtime}`,
+      )
+    } else {
+      installAlwaysOnPlist({
+        personality: existing.personality,
+        runtime: options.runtime,
+        cwd,
+        runtimeBin: options.runtimeBin,
+        env: options.env,
+      })
+    }
     // Re-provision honors an EXPLICIT nature (a manifest-declared absent service bot survives
     // update-runtime re-provision), else the runtime default (the legacy vocab-flip this fix
     // preserved). resolvedIntelligence validates the explicit against the runtime's allowed set.

package/src/launch/adapters/web.ts

@@ -0,0 +1,107 @@
+// web RuntimeAdapter — the "HOW to launch / observe ONE web session" half of the
+// launch contract (src/launch/types.ts). Like telegram/voicetalk, web is a
+// long-running ROUTER (`web-runtime run`: the owner's browser fleet-console —
+// local HTTP/WebSocket server the browser client connects to → IAP envelopes to
+// the fleet; <iap>-marked stdin → rendered into the console chat), NOT an LLM TUI.
+// So kind:'router' tells launch.launch to SKIP every TUI phase — no pane boot
+// dialog, no ready-marker, no first-user-turn delivery, no activity-proxy
+// ready-gate, no permission modal, no transcript to resume. The pane predicates
+// below are therefore trivial constants, present only to satisfy the frozen
+// interface.
+//
+// web is a presence-runtime for a HUMAN (the owner's browser console), modelled on
+// telegram/voicetalk per the foundation presence-runtime contract: kind:'router',
+// usesDoctrine:false, allowedIntelligences:['natural','absent'], argv = `<bin> run
+// <extra>`. The server/client mechanics (port, tunnel, auth) live in the
+// @agfpd/web-runtime package, NOT in this adapter and NOT interpreted by the
+// foundation — interfaces.web (if the package declares one) is opaque here.
+//
+// NO sender-guard for web (the voicetalk precedent): telegramSenderGuard is
+// telegram-specific (the bridge picks the SENDING bot from the sender's
+// bot_username); web is a single local owner endpoint — the console renders the
+// sender from the envelope's `from`, so any peer may write to it freely.
+//
+// NO currency on this path: no marketplace check, no plugin install/update — that
+// is install-time (the package self-deploys its runtime.json manifest), not
+// session bring-up.
+
+import type { ControlCommand, ControlPlan, LaunchAdapterConfig, LaunchSpec, RuntimeAdapter } from '../types.ts'
+import { allowedIntelligencesForRuntime } from '../../core/constants.ts'
+
+// ─────────────────────────────────────────────────────────────────────────────
+// webAdapter
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const webAdapter: RuntimeAdapter = {
+  runtime: 'web',
+  kind: 'router',
+  usesDoctrine: false,
+
+  /** No submit surface — a router takes no bracketed-paste-then-Enter turn; delivery
+   *  is deliverHosted → child stdin (<iap> reader), not submitIntoTui. Empty glyphs. */
+  deliveryMarkers: { promptGlyphs: [] },
+
+  /**
+   * web carries a HUMAN (natural) OR a FACELESS SERVICE bot (absent) — never an LLM
+   * agent (artificial), which would route the owner's console channel to an agent/script.
+   * Same nature gate as telegram/voicetalk, sourced from the single Ф0 truth
+   * (allowedIntelligencesForRuntime); enforced by the launch primitive against
+   * LaunchSpec.intelligence. Source → docs/Идентичность.
+   */
+  allowedIntelligences: allowedIntelligencesForRuntime('web'),
+
+  /**
+   * argv = webBin + 'run' + extraArgs.
+   *   - cfg.webBin ?? 'web-runtime'  the launch binary (the always-on plist pins an
+   *     absolute path via WEB_RUNTIME_BIN — launchd-minimal PATH; here we defer to
+   *     cfg.webBin when set, else emit the PATH-resolvable literal for launch.launch
+   *     to resolve).
+   *   - 'run'  the router subcommand: brings up the console server (browser client ↔
+   *     fleet) and pumps IAP envelopes both directions through the session's stdio
+   *     (outbound <iap> stdin → console chat; inbound browser input → fleet via the
+   *     daemon send_to_peer).
+   *   - ...extraArgs  LaunchSpec.extraArgs passthrough.
+   *
+   * NO --system-prompt-file: usesDoctrine:false — a router is not an LLM, no doctrine to
+   * merge. NO --resume: a router has no transcript. NO currency on this path.
+   */
+  buildArgv(spec: LaunchSpec, cfg: LaunchAdapterConfig): string[] {
+    return [cfg.webBin ?? 'web-runtime', 'run', ...(spec.extraArgs ?? [])]
+  },
+
+  /** No startup dialogs — a router has no pane TUI to answer. launch.launch skips the
+   *  boot phase for kind:'router', so this is never consulted; null = "no dialog". */
+  bootDialogKeys(_pane: string): string[] | null {
+    return null
+  },
+
+  /** Always ready: a router has no input surface waiting for a first message — it is
+   *  "up" the instant `web-runtime run` is launched. launch.launch skips the
+   *  ready-gate for kind:'router'; true = "nothing to wait for". */
+  isInputReady(_pane: string): boolean {
+    return true
+  },
+
+  /** No activity proxy: a router writes no transcript/session jsonl to mtime as a
+   *  ready-gate or idle signal. launch.launch skips the activity-proxy gate for a
+   *  router; null per the contract ("null for a router (no proxy)"). */
+  newestActivityMtime(_cwd: string): number | null {
+    return null
+  },
+
+  lastTurnMtime(_cwd: string): number | null {
+    return null // router — no transcript
+  },
+
+  /** Nothing to resume: a router does not replay a transcript, so resume cannot
+   *  fail-loud the way claude/codex do. Always {ok:true}. */
+  resolveResume(_cwd: string): { ok: boolean; ref?: string; reason?: string } {
+    return { ok: true }
+  },
+
+  /** No in-session control: a router has no TUI turn to interrupt/compact. null for
+   *  every command → the daemon/CLI surfaces an explicit "unsupported" refusal. */
+  executeControl(_command: ControlCommand): ControlPlan | null {
+    return null
+  },
+}

package/src/launch/index.ts

@@ -24,6 +24,7 @@ import { codexAdapter } from './adapters/codex.ts'
 import { telegramAdapter } from './adapters/telegram.ts'
 import { notifierAdapter } from './adapters/notifier.ts'
 import { voicetalkAdapter } from './adapters/voicetalk.ts'
+import { webAdapter } from './adapters/web.ts'
 import type {
   LaunchConfig,
   LaunchFn,
@@ -56,6 +57,7 @@ export {
   launchdPlistPath,
   renderLaunchdPlist,
   installAlwaysOnPlist,
+  installedPlistRuntime,
   isFoundationOwnedPlist,
   launchctlBootstrap,
   bootstrapJobCore,
@@ -90,6 +92,7 @@ export function getAdapter(runtime: Runtime): RuntimeAdapter {
   if (runtime === 'telegram') return telegramAdapter
   if (runtime === 'notifier') return notifierAdapter
   if (runtime === 'voicetalk') return voicetalkAdapter
+  if (runtime === 'web') return webAdapter
   throw new Error(`no launch adapter for runtime "${runtime}"`)
 }
 

package/src/launch/launchd.ts

@@ -81,6 +81,20 @@ function readPlistEnvVar(path: string, key: string): string | undefined {
   }
 }
 
+/**
+ * The PEER_RUNTIME baked into the personality's EXISTING foundation-owned always-on
+ * plist, or undefined when there is no plist / it is foreign-owned / it carries no
+ * runtime. The plist scheme is ONE per personality (`com.iapeer.<p>.plist` — the
+ * runtime rides only in ProgramArguments/env), so this is how a caller detects that
+ * the personality's always-on slot is already OCCUPIED by another infra runtime
+ * (e.g. arthur's telegram) before asking for a second one (multi-infra collision).
+ */
+export function installedPlistRuntime(personality: string, env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const path = launchdPlistPath(personality, env)
+  if (!existsSync(path) || !isFoundationOwnedPlist(path)) return undefined
+  return readPlistEnvVar(path, 'PEER_RUNTIME')
+}
+
 /**
  * Resolve an executable to an ABSOLUTE path against `env.PATH` (the RICH
  * provisioning PATH), so the result can be baked into a launchd plist whose own
@@ -614,6 +628,22 @@ export function installAlwaysOnPlist(opts: InstallAlwaysOnPlistOptions): string
         `or other manager owns it; rename the peer to avoid the com.iapeer.<personality> collision`,
     )
   }
+  // MULTI-INFRA COLLISION GUARD (fail-loud, never a silent clobber): the plist scheme
+  // is ONE per personality, so installing a SECOND infra runtime for the same
+  // personality would OVERWRITE the first channel's plist (e.g. web over arthur's
+  // telegram) and kill that channel on the next bootout/reboot. Refuse loudly until
+  // per-runtime plists (multi-infra) land. A deliberate runtime SWITCH is an operator
+  // act: `iapeer stop <p>` + delete the plist, then re-provision.
+  const bakedRuntime = existsSync(path) ? readPlistEnvVar(path, 'PEER_RUNTIME') : undefined
+  if (bakedRuntime && bakedRuntime !== opts.runtime) {
+    throw new IapError(
+      `refusing to overwrite launchd plist ${path}: it already holds the always-on ` +
+        `"${bakedRuntime}" session for "${opts.personality}" (the plist scheme is one per ` +
+        `personality) — installing "${opts.runtime}" here would silently kill that channel. ` +
+        `Multi-infra per personality needs per-runtime plists (not yet supported); for a ` +
+        `deliberate runtime switch: iapeer stop ${opts.personality}, delete the plist, re-provision.`,
+    )
+  }
   // GLOBAL infra logs (Фаза §8): ~/.iapeer/logs/<personality>/, NOT per-peer
   // <cwd>/.iapeer/logs/ — host-service logs live in the global log area.
   const logDir = peerLogsDir(opts.personality, { env })

package/src/launch/launchdRun.ts

@@ -97,6 +97,7 @@ export async function runAlwaysOn(personality: string, runtime: string, cwd: str
     telegramBin: env[INFRA_RUNTIME_BIN_ENV.telegram],
     notifierBin: env[INFRA_RUNTIME_BIN_ENV.notifier],
     voicetalkBin: env[INFRA_RUNTIME_BIN_ENV.voicetalk],
+    webBin: env[INFRA_RUNTIME_BIN_ENV.web],
     sockDir,
     bootDeadlineSecs: 30,
     readyGateSecs: 30,

package/src/launch/types.ts

@@ -141,6 +141,8 @@ export interface LaunchAdapterConfig {
   notifierBin?: string
   /** voicetalk-runtime launch binary (router runtime, infra/always-on — the owner's voice channel). */
   voicetalkBin?: string
+  /** web-runtime launch binary (router runtime, infra/always-on — the owner's browser fleet-console). */
+  webBin?: string
 }
 
 export interface LaunchSpec {

package/src/lifecycle/index.ts

@@ -25,6 +25,7 @@ import {
   type Runtime,
 } from '../core/constants.ts'
 import { buildProcessAddress, buildSocketPath, parseSessionName } from '../core/socket.ts'
+import { renderEnvelopeForAgent } from '../codec/index.ts'
 import { err, ok, type Result } from '../core/errors.ts'
 import { capPaneLogs, paneLogRotateConfig } from '../launch/cmdlog.ts'
 import { resolveGlobalRoot } from '../storage/index.ts'
@@ -917,17 +918,23 @@ function composePeerPrompt(
  * yields no seed and never blocks the wake (the seed is optional).
  */
 export function composeFirstMessage(cwd: string, task: string, fresh: boolean): string {
-  if (!fresh) return task
+  // Envelope-compaction F: the boot first-message enters an LLM context (wake
+  // targets are agent runtimes by construction — launchd-held bridges are never
+  // woken, H4), so the routed WIRE envelope is rendered into the compact
+  // agent-facing presentation here — the boot-side twin of deliverWarm's render.
+  // fail-open inside the renderer (non-envelope/empty task passes through as-is).
+  const presented = task ? renderEnvelopeForAgent(task) : task
+  if (!fresh) return presented
   let seed: string | undefined
   try {
     seed = readPeerProfile(cwd)?.initial_prompt
   } catch {
     /* invalid/absent profile → no seed */
   }
-  if (!seed) return task
+  if (!seed) return presented
   // seed + the routed message (both delivered, seed first). When there is NO incoming
   // message (an eager /new re-launch, C4b — task is empty), the seed is self-sufficient.
-  return task ? `${seed}\n\n${task}` : seed
+  return presented ? `${seed}\n\n${presented}` : seed
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1313,10 +1320,17 @@ interface SuperviseCtx {
  */
 function superviseOnePeer(s: SessionState, ctx: SuperviseCtx): SuperviseOutcome {
   const { cfg, env, nowMs, lastTurnMt, childActivityMt, isAlive, kill, verbose, trace } = ctx
-  // H4 — FIRST, before any reap. A launchd-managed peer is read-only.
+  // H4 — FIRST, before any reap. A launchd-managed peer is read-only: never wake,
+  // never kill, never sweep its PROCESS. Its stale `.session` however is the
+  // DAEMON'S own supervisory record (written back when the peer was daemon-owned),
+  // not the peer's — a peer that moved under launchd would otherwise re-enter this
+  // skip on every tick forever (follow-up 09.06: latent garbage, not a delivery
+  // bug). Drop the record once; if the plist is ever removed again, the next wake
+  // recreates it.
   if (isLaunchdManaged(s.personality, env)) {
-    if (verbose) trace({ identity: s.identity, action: 'skipped-launchd', outcome: 'read-only-h4' })
-    return { identity: s.identity, action: 'skipped-launchd' }
+    removeSessionState(cfg, s.identity)
+    if (verbose) trace({ identity: s.identity, action: 'skipped-launchd', outcome: 'read-only-h4-stale-state-dropped' })
+    return { identity: s.identity, action: 'skipped-launchd', reason: 'launchd-managed; stale daemon .session dropped' }
   }
   const sock = buildSocketPath(s.runtime, s.personality, cfg.sockDir)
   if (!isAlive(sock, s.identity)) {

package/src/runtime/deploy.ts

@@ -33,6 +33,7 @@ export const RUNTIME_PACKAGES: Readonly<Record<string, string>> = {
   telegram: '@agfpd/telegram-runtime',
   notifier: '@agfpd/notifier-runtime',
   voicetalk: '@agfpd/voicetalk-runtime',
+  web: '@agfpd/web-runtime',
 }
 
 /** Resolve the npm package for a runtime: explicit override wins, else the built-in

package/src/transport/index.ts

@@ -32,7 +32,7 @@ import {
   buildSocketPath,
   type ProcessAddress,
 } from '../core/socket.ts'
-import { buildEnvelope } from '../codec/index.ts'
+import { buildEnvelope, formatSentAt, renderEnvelopeForAgent } from '../codec/index.ts'
 import { resolveGlobalRoot } from '../storage/index.ts'
 import { findPeer, readPeersIndex, type PeerRecord } from '../registry/index.ts'
 import type { ResolvedCaller } from '../identity/index.ts'
@@ -238,12 +238,18 @@ export async function deliverWarm(
   seam: WarmDeliverSeam = {},
   env: NodeJS.ProcessEnv = process.env,
 ): Promise<Result<void>> {
+  // Envelope-compaction F: an AGENT target (claude/codex — an LLM reads the text)
+  // receives the compact presentation; a bridge target (telegram/notifier/…)
+  // receives the WIRE form its parser expects. Rendered BEFORE deliverViaHost so
+  // the transcript-confirm matches the text actually delivered. fail-open inside
+  // the renderer: a render problem degrades to the wire form, never to a loss.
+  const payload = isSupportedLocalRuntime(target.runtime) ? renderEnvelopeForAgent(envelope) : envelope
   const address = target.address
   const prev = deliverTails.get(address) ?? Promise.resolve()
   // run AFTER prev settles (success or failure) — a prior delivery's error must not stall the chain
   const run = prev.then(
-    () => deliverViaHost(target, envelope, cwd, seam, env),
-    () => deliverViaHost(target, envelope, cwd, seam, env),
+    () => deliverViaHost(target, payload, cwd, seam, env),
+    () => deliverViaHost(target, payload, cwd, seam, env),
   )
   deliverTails.set(
     address,
@@ -302,11 +308,13 @@ async function deliverViaHost(
   // codex took the socket-ack short-circuit above). A bare transcript/pane-log mtime BUMP is NOT proof
   // the session took THIS message: a receiver in an active turn advances both mtimes with its OWN
   // rendering even when our paste was swallowed at the turn boundary (incident 2026-06-23: ok=true,
-  // message gone). The ONLY proof is a NEW transcript record CARRYING our envelope — for claude, a
-  // queue-operation `content` (busy → enqueued) or the user-turn message (idle), written sub-second so
-  // a short grace covers it. The receiver's own assistant/tool turn never reproduces the
-  // `<iap from-personality=…>` wrapper, so it cannot forge a confirm. No such record within the grace →
-  // false-FAIL (the sender retries) — NOT a false-OK (silent loss the contract forbids).
+  // message gone). The ONLY proof is a NEW transcript record CARRYING the DELIVERED payload (for an
+  // agent target that is the compact `<iap from=…>` presentation — deliverWarm rendered it before this
+  // point, so the needle matches what was actually pasted) — for claude, a queue-operation `content`
+  // (busy → enqueued) or the user-turn message (idle), written sub-second so a short grace covers it.
+  // The receiver's own assistant/tool turn never reproduces the full delivered envelope verbatim, so it
+  // cannot forge a confirm. No such record within the grace → false-FAIL (the sender retries) — NOT a
+  // false-OK (silent loss the contract forbids).
   const confirm = seam.confirmLanded ?? ((payload: string) => transcriptCarriesEnvelope(baseline, payload, { env }))
   const sleep = seam.sleep ?? ((ms: number) => new Promise<void>(r => setTimeout(r, ms)))
   const graceMs = confirmGraceMs()
@@ -884,6 +892,9 @@ export interface EphemeralRouteDeps {
     envelope: string
     topic?: string
     runtime?: string
+    /** Router-acceptance instant (formatSentAt) — the enqueue ACK's `ts` mirrors
+     *  it so sender-side ts ≡ envelope ts holds on the queued path too. */
+    sentAt?: string
   }) => Promise<Result<RouteResult>>
 }
 
@@ -904,6 +915,8 @@ export interface ComposerQueueTryEnqueueArgs {
   target: DeliveryTarget
   envelope: string
   topic?: string
+  /** Router-acceptance instant (formatSentAt) — the queued ACK's `ts` mirrors it. */
+  sentAt?: string
 }
 
 export interface ComposerQueueRouteDeps {
@@ -1192,7 +1205,7 @@ export function createComposerDeliveryQueue(opts: ComposerDeliveryQueueOptions):
         queued: true,
         queuedBy: 'composer',
         queueDepth: q.length,
-        ts: new Date().toISOString(),
+        ts: args.sentAt ?? new Date().toISOString(),
       })
     },
     failAll: async reason => {
@@ -1317,12 +1330,19 @@ export async function routeSend(
   const intendedGuard = telegramSenderGuard(caller, runtime ?? peer.runtime, personality)
   if (!intendedGuard.ok) return intendedGuard
 
+  // Stamped ONCE at router acceptance: the same instant travels as the envelope's
+  // `ts` attribute (recipient side) AND is returned as the result's `ts` (sender
+  // side) — the two correspond literally, which is what makes async-desync
+  // visible (the recipient can tell how old the message it is reading is).
+  const sentAt = formatSentAt(new Date())
   // Built once — it is both the live-delivery payload and, on a miss, the wake
-  // first-message (the woken session receives it as its boot task).
+  // first-message (the woken session receives it as its boot task). This is the
+  // WIRE form; agent-bound hops re-render it compactly at delivery.
   const envelope = buildEnvelope({
     fromPersonality: caller.personality,
     fromRuntime: caller.runtime,
     fromIntelligence: caller.intelligence,
+    sentAt,
     topic,
     attachments: attachmentsResult.value,
     message,
@@ -1336,7 +1356,7 @@ export async function routeSend(
   // would deadlock its own die-after-reply reap on a forever-non-empty queue).
   if (deps.ephemeral?.isEphemeral(peer.cwd)) {
     if (caller.personality === peer.personality) return err('cannot send to self')
-    return deps.ephemeral.deliver({ peer, envelope, topic, runtime })
+    return deps.ephemeral.deliver({ peer, envelope, topic, runtime, sentAt })
   }
 
   const target = resolvePeerDeliveryTarget(personality, runtime, peer, env)
@@ -1346,7 +1366,7 @@ export async function routeSend(
     // land on telegram without an override and without telegram being the default).
     const liveGuard = telegramSenderGuard(caller, target.value.runtime, personality)
     if (!liveGuard.ok) return liveGuard
-    const queued = await deps.composerQueue?.tryEnqueue({ caller, peer, target: target.value, envelope, topic })
+    const queued = await deps.composerQueue?.tryEnqueue({ caller, peer, target: target.value, envelope, topic, sentAt })
     if (queued) return queued
     // peer.cwd enables the Ф-B transcript-mtime liveness probe (busy-session case).
     // deliverWarm is HOST-AWARE (spawn-flip Ф0b-2): a supervisor-hosted target delivers over its
@@ -1359,7 +1379,7 @@ export async function routeSend(
       ok: true,
       delivered_to: { personality: target.value.personality, runtime: target.value.runtime },
       woke: false,
-      ts: new Date().toISOString(),
+      ts: sentAt,
     })
   }
 
@@ -1391,7 +1411,7 @@ export async function routeSend(
           ok: true,
           delivered_to: { personality: revived.value.personality, runtime: revived.value.runtime },
           woke: false,
-          ts: new Date().toISOString(),
+          ts: sentAt,
         })
       }
       // resolved but the deliver didn't land (session still settling) → keep polling
@@ -1427,7 +1447,7 @@ export async function routeSend(
   // a false ok:true — the class the contract forbids. A delivery failure here is
   // surfaced loudly (false-FAIL over false-OK).
   if (woke.taskDelivered === false) {
-    const queued = await deps.composerQueue?.tryEnqueue({ caller, peer, target: live.value, envelope, topic })
+    const queued = await deps.composerQueue?.tryEnqueue({ caller, peer, target: live.value, envelope, topic, sentAt })
     if (queued) return queued
     const delivered = await deliverWarm(live.value, envelope, peer.cwd, {}, env)
     if (!delivered.ok) return delivered
@@ -1436,7 +1456,7 @@ export async function routeSend(
       ok: true,
       delivered_to: { personality: live.value.personality, runtime: live.value.runtime },
       woke: false, // honest: this sender's envelope went the LIVE path, not a boot
-      ts: new Date().toISOString(),
+      ts: sentAt,
     })
   }
   // The envelope was delivered as the boot first-message during wake.
@@ -1444,6 +1464,6 @@ export async function routeSend(
     ok: true,
     delivered_to: { personality: live.value.personality, runtime: live.value.runtime },
     woke: true,
-    ts: new Date().toISOString(),
+    ts: sentAt,
   })
 }

package/src/tray/install.ts

@@ -486,9 +486,18 @@ export function trayAttachTerm(opts: {
 
 export interface TrayStatus {
   daemon: { fleet: boolean; version?: string; sock?: string; tcp?: string }
-  swiftbar: { installed: boolean; pluginDir?: string }
+  swiftbar: {
+    installed: boolean
+    pluginDir?: string
+    /** GROUND TRUTH of the menu-bar icon: AppKit persists NSStatusItem visibility per
+     *  autosaveName in SwiftBar's defaults (`NSStatusItem VisibleCC <plugin>`). false =
+     *  the icon is hidden RIGHT NOW (whatever hid it — a mid-chunk decode nil on an old
+     *  binary, a ⌘-drag removal); undefined = key absent / SwiftBar not installed. The
+     *  first thing to read when "the icon is gone" is reported — no screen needed. */
+    iconVisible?: boolean
+  }
   plugin: { installed: boolean; path?: string }
-  /** Login-autostart LaunchAgent: registered (our plist present) + its path. */
+  /** Tray-host supervisor LaunchAgent: registered (our plist present) + its path. */
   autostart: { registered: boolean; path?: string }
 }
 
@@ -503,9 +512,14 @@ export function trayStatus(opts: { env?: NodeJS.ProcessEnv; run?: Runner; probeA
   const found = searchDirs.map(d => join(d, PLUGIN_BASENAME)).find(f => existsSync(f))
   const autostartPath = swiftBarAutostartPlistPath(env)
   const autostartOurs = existsSync(autostartPath) && isFoundationOwnedPlist(autostartPath)
+  let iconVisible: boolean | undefined
+  if (installed) {
+    const r = run('defaults', ['read', SWIFTBAR_DOMAIN, `NSStatusItem VisibleCC ${PLUGIN_BASENAME}`])
+    if (r.status === 0) iconVisible = r.stdout.trim() === '1'
+  }
   return {
     daemon: { fleet: addr.fleet === 1, version: addr.version, sock: addr.sock, tcp: addr.tcp },
-    swiftbar: { installed, pluginDir: cfgDir },
+    swiftbar: { installed, pluginDir: cfgDir, iconVisible },
     plugin: { installed: Boolean(found), path: found },
     autostart: { registered: autostartOurs, path: autostartOurs ? autostartPath : undefined },
   }