@staix/agent-hub 0.32.0 → 0.33.0

package/src/rooms/remote-peer.ts

@@ -3,7 +3,7 @@ import { BasePeer, type DeliveryReceipt } from "../hub/peers.ts";
 import type { Envelope, PeerState } from "../hub/envelope.ts";
 import { encodeRoomMessage, parseRemotePeerId, type RoomChatEnvelope } from "./application.ts";
 import { readRoomOutbound, roomBoundary, type RoomBoundaryContext } from "./boundary.ts";
-import { RoomNotSentError } from "./link.ts";
+import { RoomCodecPendingError, RoomCodecUnsupportedError, RoomNotSentError } from "./link.ts";
 
 export interface RemotePeerPorts {
   member: string;
@@ -32,10 +32,12 @@ export class RemotePeer extends BasePeer {
   private running = false;
   private online = false;
   private blockedNotSent = false;
+  private codecWaiting = false;
   private observed: PeerState = "offline";
   private readonly pending = new Set<string>();
   private readonly waitingForReady = new Set<string>();
   private readonly sending = new Set<string>();
+  private readonly codecRechecks = new Map<string, () => boolean>();
   private readonly deadlines = new Map<string, number>();
   constructor(id: string, readonly remoteRoom: string, readonly remoteQueueTtlMs: number, private readonly ports: RemotePeerPorts) {
     super(id);
@@ -60,6 +62,7 @@ export class RemotePeer extends BasePeer {
     // Active journal rows and their sealed room frames survive a sender restart.
     // Stop only fences in-flight callbacks; it is not evidence of an uncertain send.
     this.pending.clear();
+    this.codecWaiting = false; this.codecRechecks.clear();
     this.waitingForReady.clear();
     this.deadlines.clear(); this.update();
   }
@@ -125,6 +128,7 @@ export class RemotePeer extends BasePeer {
   }
   /** A link becoming ready is an actual wake-up after a typed not-sent refusal. */
   wake(): void { this.blockedNotSent = false; this.update(); }
+  wakeCodec(): void { if (this.codecWaiting) { this.codecWaiting = false; this.wake(); } }
   setRemoteDeadline(envelopeId: string, expiresAt: number): void {
     if (Number.isSafeInteger(expiresAt) && expiresAt > 0 && this.deadlines.size < 200) this.deadlines.set(envelopeId, expiresAt);
   }
@@ -159,7 +163,11 @@ export class RemotePeer extends BasePeer {
     if (this.sending.has(deliveryId)) return;
     this.sending.add(deliveryId);
     try { await this.publishOnce(env, deliveryId, expiresAt, generation, immutable); }
-    finally { this.sending.delete(deliveryId); }
+    finally {
+      this.sending.delete(deliveryId);
+      const changed = this.codecRechecks.get(deliveryId); this.codecRechecks.delete(deliveryId);
+      if (changed?.()) { this.codecWaiting = false; this.wake(); } // Recheck only after this send lane released, closing observation-before-requeue races.
+    }
   }
   private async publishOnce(env: Envelope, deliveryId: string, expiresAt: number, generation: number, immutable?: RoomChatEnvelope): Promise<void> {
     let context: RoomBoundaryContext;
@@ -216,12 +224,19 @@ export class RemotePeer extends BasePeer {
       }
     } catch (error) {
       if (!this.pending.has(deliveryId)) return;
+      if (error instanceof RoomCodecUnsupportedError && !immutable) {
+        let queued: boolean | undefined;
+        try { queued = this.ports.queued?.(deliveryId); } catch { queued = undefined; }
+        if (queued === false) { this.receipt({ id: deliveryId, state: "failed_safe", reason: error.message }); return; }
+      }
+      if (error instanceof RoomCodecPendingError) this.codecWaiting = true;
       if (error instanceof RoomNotSentError) {
         let retained: boolean | undefined;
         try { retained = this.ports.queued?.(deliveryId); } catch { retained = undefined; }
         if (immutable || retained === true) {
-          if (!this.ready()) this.waitForReady(deliveryId);
+          if (!this.ready() || error instanceof RoomCodecPendingError) this.waitForReady(deliveryId);
         } else this.notSent(deliveryId);
+        if (error instanceof RoomCodecPendingError) this.codecRechecks.set(deliveryId, error.changed);
         return;
       }
       if (!trusted()) {

package/src/rooms/service.ts

@@ -11,7 +11,7 @@ import { roomMembers, RoomWireError } from "./wire.ts";
 import { RoomStore, RoomStoreError, RoomApplicationLimitError, type RoomOutgoing } from "./store.ts";
 import { RoomPolicy } from "./policy.ts";
 import { RemotePeer } from "./remote-peer.ts";
-import { parseRemotePeerId, roomReceiptReasonText, type RoomMessage, type RoomReceiptReason, type RoomChatEnvelope } from "./application.ts";
+import { parseRemotePeerId, roomReceiptReasonText, type RoomMessage, type RoomReceiptReason, type RoomChatEnvelope, type RoomCodecFeature } from "./application.ts";
 import { RoomApplicationDeferredError, RoomNotSentError, type RoomLink, type RoomLinkApplication, type RoomLinkContext, type RoomLinkState, type RoomPresencePeer } from "./link.ts";
 import { ROOM_PRESENCE_MISSES, ROOM_REFRESH_MS, roomRefreshPeriod } from "./liveness.ts";
 
@@ -32,7 +32,7 @@ export interface RoomChatOptions {
   roster?: (ids: readonly string[]) => void;
   changed?: () => void;
   limits?: () => LimitsConfig;
-  notice?: (value: { code: "application_capacity"; room: string; count: number } | { code: "sequence_gap"; room: string; sender: string; count: string }) => void;
+  notice?: (value: { code: "application_capacity"; room: string; count: number }) => void;
 }
 export interface RoomMetrics { since: number; outbound: number | null; inbound: number | null; withheld: number | null }
 interface Binding { store: RoomStore; name: string; room: string; link: RoomLink; digest: string; rosterMembers: string; online: boolean; states: Map<string, PeerState>; observedAt: Map<string, number>; observedMembers: Set<string>; tracked?: boolean }
@@ -106,9 +106,9 @@ export class RoomChat {
         const binding = this.bindings.get(context.name); if (binding) this.wakeRemotes(binding);
       },
       capacityChanged: context => { if (context.current()) { const binding = this.bindings.get(context.name); if (binding) this.wakeRemotes(binding); this.capacityChanged(); } },
-      gap: (context, input) => {
-        if (context.current()) this.options.notice?.({ code: "sequence_gap", room: context.store.get(context.name)!.current.room, sender: input.sender, count: input.count });
-      },
+      codecsChanged: (context, input) => { if (context.current()) { const binding = this.bindings.get(context.name); if (binding) { this.wakeRemotes(binding, input.member, true); void this.resumeActive(binding, input.member, input.features); } } },
+      // The signed sequence is room-wide, while chat recipients are selective.
+      // A numeric gap is not evidence of loss and must not become an operator notice.
     };
   }
   private now(): number { return this.options.now?.() ?? Date.now(); }
@@ -149,8 +149,10 @@ export class RoomChat {
     const target = this.targets.get(id);
     return !!target && target.binding.online && this.valid(target.binding);
   }
-  private wakeRemotes(binding: Binding): void {
-    for (const [id, remote] of this.remotes) if (this.targets.get(id)?.binding === binding) remote.wake();
+  private wakeRemotes(binding: Binding, member?: string, codecOnly = false): void {
+    for (const [id, remote] of this.remotes) if (this.targets.get(id)?.binding === binding && (member === undefined || this.targets.get(id)?.member === member)) {
+      if (codecOnly) remote.wakeCodec(); else remote.wake();
+    }
   }
   metrics(name: string, room?: string): RoomMetrics | null {
     const binding = this.bindings.get(name);
@@ -360,7 +362,7 @@ export class RoomChat {
       && this.policy.get(binding.name).includes(peer)
       && roomMembers(state.current).some(member => member.fingerprint === binding.store.identity.public.fingerprint && member.exposedPeers.includes(peer));
   }
-  presence(store: RoomStore, name: string, link: RoomLink, value: { member: string; peers: readonly RoomPresencePeer[]; restored?: true }): void {
+  presence(store: RoomStore, name: string, link: RoomLink, value: { member: string; peers: readonly RoomPresencePeer[]; restored?: true; observedAt?: number | null }): void {
     const binding = this.bindings.get(name), state = store.get(name);
     if (!binding || binding.store !== store || binding.link !== link || !state || !this.valid(binding)) return;
     const member = roomMembers(state.current).find(row => row.fingerprint === value.member);
@@ -371,7 +373,9 @@ export class RoomChat {
     const now = this.presenceNow();
     if (value.restored !== true) {
       binding.observedMembers.add(member.fingerprint);
-      if (now !== undefined) binding.observedAt.set(member.fingerprint, now);
+      const receivedAt = Object.hasOwn(value, "observedAt") ? value.observedAt : now;
+      if (typeof receivedAt === "number" && Number.isSafeInteger(receivedAt) && receivedAt >= 0 && now !== undefined && receivedAt <= now) binding.observedAt.set(member.fingerprint, receivedAt);
+      else binding.observedAt.delete(member.fingerprint);
     }
     this.refreshTargets();
     this.queueChanged();
@@ -686,11 +690,18 @@ export class RoomChat {
     }
     void this.retryPending(); this.queueChanged();
   }
-  private async resumeActive(binding: Binding): Promise<void> {
+  private async resumeActive(binding: Binding, codecMember?: string, changedFeatures?: readonly RoomCodecFeature[]): Promise<void> {
     if (!binding.online || !this.valid(binding)) return;
     try {
-      const active = binding.store.applicationOutbox(binding.name, true).filter(row => (row.state === "dispatching" || row.state === "accepted")
-        && !this.personHeldInvocations.get(binding.name)?.has(row.deliveryId));
+      const active = binding.store.applicationOutbox(binding.name, true).filter(row => {
+        if (row.state !== "dispatching" && row.state !== "accepted" || this.personHeldInvocations.get(binding.name)?.has(row.deliveryId)) return false;
+        if (codecMember === undefined) return true;
+        if (row.recipient !== codecMember) return false;
+        let required: RoomCodecFeature | undefined;
+        if (row.peer === USER) required = "person_inbox_v1";
+        else if (this.options.bus.queueShow(row.deliveryId)?.originals.some(isInvocationKind)) required = "read_invocation_v1";
+        return required !== undefined && (changedFeatures === undefined || changedFeatures.includes(required));
+      });
       for (const row of active) this.remotes.get(row.remotePeer)?.reservePending(row.deliveryId);
       for (const row of active) this.launchResume(binding, row);
     } catch { /* The next authenticated online edge will retry durable rows. */ }
@@ -747,6 +758,10 @@ export class RoomChat {
     const digest = state?.current.digest;
     const proofCurrent = () => this.storeProofCurrent(binding, row, remote, target, digest);
     if (!target || !state || target.binding !== binding || !proofCurrent()) { remote.deferResume(row.deliveryId); return; }
+    let required: RoomCodecFeature | undefined;
+    if (isInvocationKind(original)) required = "read_invocation_v1";
+    else if (row.peer === USER) required = "person_inbox_v1";
+    if (required && !binding.link.codecSupported(row.recipient, required)) { remote.deferResume(row.deliveryId); return; }
     const ready = () => binding.online && this.options.bus.remoteSendAllowed(remote);
     if (!ready()) { remote.waitForReady(row.deliveryId); return; }
     let readinessLost = false;

package/src/rooms/status.ts

@@ -2,6 +2,7 @@ import { types } from "node:util";
 import type { PeerState } from "../hub/envelope.ts";
 import { decodeBase64url, encodeBase64url } from "./crypto.ts";
 import { parseRemotePeerId } from "./application.ts";
+import { ROOM_HEALTH_CAUSES, roomHealthNextStep, type RoomHealthCause } from "./health.ts";
 
 const ROOM_LIMIT = 64;
 const REMOTE_PEER_LIMIT = 4096;
@@ -15,6 +16,13 @@ const EPOCH = /^[1-9][0-9]{0,19}$/;
 const LINK_STATES = new Set(["online", "connecting", "offline", "left"]);
 const PEER_STATES = new Set<PeerState>(["idle", "busy", "paused", "offline"]);
 
+export interface RoomStatusHealth {
+  refused: { invalid_presence: number; wrong_epoch: number; trust_changed: number; stale: number; invalid_frame: number } | null;
+  outboxDepth: number | null;
+  oldestOutboxAgeMs: number | null;
+  lastReceiptAgeMs: number | null;
+}
+
 export interface RoomStatusPeer {
   id: string;
   state: PeerState;
@@ -29,8 +37,15 @@ export interface RoomRelayStats {
   withheld: number | null;
 }
 
+export interface RoomStatusDiagnostics {
+  health?: RoomStatusHealth | null;
+  linkCause?: RoomHealthCause | null;
+  linkNextStep?: string | null;
+}
+export interface RoomStatusUnavailable { code: RoomHealthCause | null; nextStep: string | null }
+
 /** Allowlisted room metadata. Missing member counts and peer lists stay unknown. */
-export interface RoomStatusView {
+export interface RoomStatusView extends RoomStatusDiagnostics {
   name: string;
   room: string;
   owner: string;
@@ -123,6 +138,46 @@ function relayStats(value: unknown): RoomRelayStats | null {
   return { since, outbound, inbound, withheld };
 }
 
+/** Counts and ages remain unknown when an older daemon cannot report them. */
+export function projectRoomHealth(value: unknown): RoomStatusHealth | null {
+  if (!plainRecord(value)) return null;
+  const rawRefused = ownData(value, "refused");
+  let refused: RoomStatusHealth["refused"] = null;
+  if (plainRecord(rawRefused)) {
+    const invalid_presence = relayCount(ownData(rawRefused, "invalid_presence")), wrong_epoch = relayCount(ownData(rawRefused, "wrong_epoch"));
+    const trust_changed = relayCount(ownData(rawRefused, "trust_changed")), stale = relayCount(ownData(rawRefused, "stale")), invalid_frame = relayCount(ownData(rawRefused, "invalid_frame"));
+    if (invalid_presence !== null && wrong_epoch !== null && trust_changed !== null && stale !== null && invalid_frame !== null)
+      refused = { invalid_presence, wrong_epoch, trust_changed, stale, invalid_frame };
+  }
+  return { refused, outboxDepth: relayCount(ownData(value, "outboxDepth")),
+    oldestOutboxAgeMs: relayCount(ownData(value, "oldestOutboxAgeMs")), lastReceiptAgeMs: relayCount(ownData(value, "lastReceiptAgeMs")) };
+}
+
+function healthCause(value: unknown): RoomHealthCause | null {
+  return typeof value === "string" && ROOM_HEALTH_CAUSES.includes(value as RoomHealthCause) ? value as RoomHealthCause : null;
+}
+
+/** Regenerate guidance from closed causes; arbitrary daemon text is never copied. */
+export function projectRoomDiagnostics(value: unknown): RoomStatusDiagnostics {
+  if (!plainRecord(value)) return {};
+  const cause = healthCause(ownData(value, "linkCause"));
+  const result: RoomStatusDiagnostics = {};
+  if (ownField(value, "health").present) result.health = projectRoomHealth(ownData(value, "health"));
+  if (ownField(value, "linkCause").present) {
+    result.linkCause = cause;
+    result.linkNextStep = null;
+    if (cause !== null) result.linkNextStep = roomHealthNextStep(cause);
+  }
+  return result;
+}
+
+/** Absent or malformed availability metadata stays unknown without evaluating getters. */
+export function projectRoomUnavailable(value: unknown): RoomStatusUnavailable | null {
+  if (!plainRecord(value)) return null;
+  const code = healthCause(ownData(value, "code"));
+  return { code, nextStep: code === null ? null : roomHealthNextStep(code) };
+}
+
 /** Project RoomCommands.rows-compatible data to body-free room status metadata. */
 export function projectRoomStatus(value: unknown): RoomStatusView[] {
   try {
@@ -146,6 +201,7 @@ export function projectRoomStatus(value: unknown): RoomStatusView[] {
         memberCount: memberCount(rawMemberCount),
         remotePeers: peers,
         relays: relayStats(ownData(item, "relays")),
+        ...projectRoomDiagnostics(item),
       });
     }
     return views;

package/src/rooms/store.ts

@@ -2,6 +2,7 @@
 import { chmodSync, closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { Database } from "bun:sqlite";
+import type { RoomHealth } from "./health.ts";
 import { realPath } from "../hub/project.ts";
 import { MAX_HOP, USER } from "../hub/envelope.ts";
 import { assertRoomCryptoReady, exportHubIdentityForStorage, generateHubIdentity, importHubIdentity, decodeBase64url, encodeBase64url, sha256, type HubIdentity, type LocalIdentityRecord } from "./crypto.ts";
@@ -1558,9 +1559,27 @@ export class RoomStore {
     });
   }
   refused(name: string): RoomRefusal[] {
-    const state = this.get(name); if (!state) return [];
+    this.now(); named(name); const state = this.rooms.get(name); if (!state) return [];
     return this.db.query<RoomRefusal, [string]>("SELECT digest,reason,at FROM refusals WHERE room=? ORDER BY rowid").all(state.current.room);
   }
+  /** Metadata-only diagnostics. No durable clock write, sealed frame or plaintext read. */
+  health(name: string): RoomHealth {
+    const now = this.now(); named(name); const state = this.rooms.get(name);
+    if (!state) fail("untrusted");
+    const refused: RoomHealth["refused"] = { invalid_presence: 0, wrong_epoch: 0, trust_changed: 0, stale: 0, invalid_frame: 0 };
+    for (const row of this.db.query<{ reason: RoomRefusalReason; count: number }, [string]>("SELECT reason,COUNT(*) AS count FROM refusals WHERE room=? GROUP BY reason").all(state.current.room)) refused[row.reason] = row.count;
+    const pending = this.db.query<{ depth: number; dated: number; oldest: number | null }, [string, number]>(`SELECT COUNT(*) AS depth, COUNT(COALESCE(r.created_at,a.created_at)) AS dated, MIN(COALESCE(r.created_at,a.created_at)) AS oldest
+      FROM outbox o LEFT JOIN application_attempts t ON t.room=o.room AND t.digest=o.digest
+      LEFT JOIN application_outbox a ON a.room=t.room AND a.delivery_id=t.delivery_id
+      LEFT JOIN receipt_outbox r ON r.room=o.room AND r.receipt_digest=o.digest
+      WHERE o.room=? AND (t.digest IS NULL OR a.state IN ('dispatching','accepted'))
+      AND (r.receipt_digest IS NULL OR r.state='dispatching' AND r.expires_at>?)`).get(state.current.room, now)!;
+    const receipt = this.db.query<{ at: number | null }, [string]>(`SELECT MAX(i.received_at) AS at FROM inbox i
+      JOIN application_outbox a ON a.room=i.room AND a.receipt_digest=i.digest WHERE i.room=?`).get(state.current.room)?.at;
+    return { refused, outboxDepth: pending.depth,
+      oldestOutboxAgeMs: pending.depth > 0 && pending.dated === pending.depth && pending.oldest !== null ? now - pending.oldest : null,
+      lastReceiptAgeMs: receipt != null ? now - receipt : null };
+  }
   /** Read-only physical-cap hint for a validated host payload; no body is loaded and no replay/clock row is written. */
   ordinaryInboxAvailable(name: string, bytes: number): boolean {
     this.now(); named(name);

package/src/rooms/wire.ts

@@ -23,7 +23,7 @@ const FP = /^[0-9a-f]{64}$/;
 export interface RoomMember extends PublicHubIdentity { label: string; exposedPeers: string[] }
 export interface FrameWire {
   v: 1; type: "frame"; room: string; epoch: string; sender: string;
-  recipients: string[]; seq: string; ephemeral?: true; nonce: string; ciphertext: string; signature: string;
+  recipients: string[]; seq: string; ephemeral?: true; codecFeatures?: true; nonce: string; ciphertext: string; signature: string;
 }
 export interface RosterWire {
   v: 1; type: "roster"; room: string; epoch: string; owner: string;
@@ -108,9 +108,10 @@ function wrap(x: unknown): WrappedEpochKey {
 }
 function parseFrame(x: unknown): FrameWire {
   const ephemeral = typeof x === "object" && x !== null && Object.hasOwn(x, "ephemeral");
-  const o = object(x, ["v", "type", "room", "epoch", "sender", "recipients", "seq", "nonce", "ciphertext", "signature", ...(ephemeral ? ["ephemeral"] : [])]); base(o, "frame");
-  if (ephemeral && o.ephemeral !== true) fail();
-  return { v: 1, type: "frame", room: b64(o.room, 32), epoch: positiveU64(o.epoch), sender: fingerprint(o.sender), recipients: sorted(array(o.recipients, 64, fingerprint, true), x => x), seq: positiveU64(o.seq), ...(ephemeral ? { ephemeral: true as const } : {}), nonce: b64(o.nonce, 12), ciphertext: ciphertext(o.ciphertext, 65552), signature: b64(o.signature, 64) };
+  const codecFeatures = typeof x === "object" && x !== null && Object.hasOwn(x, "codecFeatures");
+  const o = object(x, ["v", "type", "room", "epoch", "sender", "recipients", "seq", "nonce", "ciphertext", "signature", ...(ephemeral ? ["ephemeral"] : []), ...(codecFeatures ? ["codecFeatures"] : [])]); base(o, "frame");
+  if (ephemeral && o.ephemeral !== true || codecFeatures && (o.codecFeatures !== true || !ephemeral)) fail();
+  return { v: 1, type: "frame", room: b64(o.room, 32), epoch: positiveU64(o.epoch), sender: fingerprint(o.sender), recipients: sorted(array(o.recipients, 64, fingerprint, true), x => x), seq: positiveU64(o.seq), ...(ephemeral ? { ephemeral: true as const } : {}), ...(codecFeatures ? { codecFeatures: true as const } : {}), nonce: b64(o.nonce, 12), ciphertext: ciphertext(o.ciphertext, 65552), signature: b64(o.signature, 64) };
 }
 function parseRoster(x: unknown): RosterWire {
   const o = object(x, ["v", "type", "room", "epoch", "owner", "members", "wraps", "privateNonce", "privateCiphertext", "signature"]); base(o, "roster");
@@ -231,6 +232,7 @@ export interface VerifiedPublicFrame {
   readonly rosterDigest: string;
   readonly recipients: readonly string[];
   readonly ephemeral?: true;
+  readonly codecFeatures?: true;
 }
 interface PublicFrameState { wire: Uint8Array }
 const publicFrames = new WeakMap<VerifiedPublicFrame, PublicFrameState>();
@@ -255,7 +257,7 @@ export async function verifyPublicFrame(input: { wire: Uint8Array; roster: Verif
   await verifyFrameSignature(frame, sender);
   const frameDigest = await digest(canonicalBytes(frame));
   const proof = Object.freeze({ room: frame.room, epoch: frame.epoch, sender: frame.sender, seq: frame.seq,
-    digest: frameDigest, rosterDigest: roster.digest, ...(frame.ephemeral ? { ephemeral: true as const } : {}), recipients: Object.freeze([...frame.recipients]) });
+    digest: frameDigest, rosterDigest: roster.digest, ...(frame.ephemeral ? { ephemeral: true as const } : {}), ...(frame.codecFeatures ? { codecFeatures: true as const } : {}), recipients: Object.freeze([...frame.recipients]) });
   publicFrames.set(proof, { wire });
   return proof;
 }
@@ -333,10 +335,10 @@ function frameAad(frame: Pick<FrameWire, "room" | "epoch" | "sender" | "seq">):
   return enc.encode(`${frame.room}|${frame.epoch}|${frame.sender}|${frame.seq}`);
 }
 export async function sealFrame(input: {
-  epoch: VerifiedEpoch; identity: HubIdentity; recipients: string[]; plaintext: Uint8Array; sequence: SequencePort; ephemeral?: true;
+  epoch: VerifiedEpoch; identity: HubIdentity; recipients: string[]; plaintext: Uint8Array; sequence: SequencePort; ephemeral?: true; codecFeatures?: true;
 }): Promise<Uint8Array> {
   await assertRoomCryptoReady();
-  if (input.ephemeral !== undefined && input.ephemeral !== true) fail();
+  if (input.ephemeral !== undefined && input.ephemeral !== true || input.codecFeatures !== undefined && (input.codecFeatures !== true || input.ephemeral !== true)) fail();
   const epoch = input.epoch, identity = input.identity, sequence = input.sequence;
   const current = state(epoch), sender = identity.public.fingerprint;
   const member = current.roster.members.find(m => m.fingerprint === sender);
@@ -348,7 +350,7 @@ export async function sealFrame(input: {
   if (!sequence || typeof sequence.reserve !== "function" || typeof sequence.isCurrent !== "function") fail("state_unavailable");
   const binding = { room: epoch.room, sender, epoch: epoch.epoch, rosterDigest: epoch.digest };
   const seq = positiveU64(await portCall(() => sequence.reserve({ ...binding })));
-  const header = { v: 1 as const, type: "frame" as const, room: epoch.room, epoch: epoch.epoch, sender, recipients, seq, ...(input.ephemeral ? { ephemeral: true as const } : {}) };
+  const header = { v: 1 as const, type: "frame" as const, room: epoch.room, epoch: epoch.epoch, sender, recipients, seq, ...(input.ephemeral ? { ephemeral: true as const } : {}), ...(input.codecFeatures ? { codecFeatures: true as const } : {}) };
   const nonce = randomBytes(12);
   const encrypted = await encryptEpoch({ key: current.key, purpose: "frame", context: frameContext(epoch, sender), aad: frameAad(header), nonce, plaintext });
   const body = { ...header, nonce: encodeBase64url(nonce), ciphertext: encodeBase64url(encrypted) };

package/src/ui/index.html

@@ -2677,7 +2677,7 @@ function memorySyncLine(sync) {
   const cause = causes.includes(sync.cause) ? sync.cause : 'unknown';
   if (cause === 'declined' && sync.placementActive === false) {
     const declined = Number.isSafeInteger(sync.declinedCount) && sync.declinedCount >= 0 ? String(sync.declinedCount) : 'unknown';
-    return 'machine sync blocked: ' + declined + ' declined rows; per-row placement is not active on this store (agent-mem has no activation command yet, agent-mem#281). Inspect with `ahub memory declined`.';
+    return 'machine sync blocked: ' + declined + ' declined rows; per-row placement is not active on this store. Activation is person-only: preview with `amem migrate --sync-placement --dry-run` and declare every writer via --writer-root. The hub does not yet supply the fresh placementAttestation required for active-placement sync (#1173). Inspect with `ahub memory declined`.';
   }
   const count = Number.isSafeInteger(sync.declinedCount) && sync.declinedCount >= 0 ? ' / ' + sync.declinedCount + ' declined' : '';
   const ids = cause === 'declined' && sync.declinedIdsKnown === false ? ' / declined ID set unknown' : '';