@staix/agent-hub 0.22.0 → 0.23.0

package/src/hub/operational-settings.ts

@@ -107,10 +107,82 @@ export const RECOVERY_TERMINAL_IDLE_WAIT_SETTING = recoveryNumber({
   min: 30, max: 600, defaultValue: 120, unit: "seconds", inventory: "src/cli/upgrade-runtime.ts:waitForIdle",
 });
 
+const adapterNumber = <const T extends Omit<OperationalNumberSetting, "group" | "store" | "risk" | "applies" | "type">>(def: T) => ({ group: "Start", store: "config", risk: "raises", applies: "next use", type: "integer", ...def }) as const satisfies OperationalNumberSetting;
+export const ACP_TOOL_CEILING_SETTING = adapterNumber({
+  key: "adapter_timing.acp_tool_ceiling_min", path: ["adapter_timing", "acp_tool_ceiling_min"], label: "Next ACP launch: open-tool ceiling (minutes, at least the watchdog)",
+  min: 1, max: 30, defaultValue: 30, unit: "minutes", inventory: "src/adapters/acp.ts:TOOL_CEILING_MS",
+});
+export const ACP_ACTIVITY_BATCH_SETTING = adapterNumber({
+  key: "adapter_timing.acp_activity_batch_ms", path: ["adapter_timing", "acp_activity_batch_ms"], label: "Next ACP launch: activity display batch delay (milliseconds)",
+  min: 10, max: 50, defaultValue: 50, unit: "milliseconds", inventory: "src/adapters/acp.ts:setTimeout",
+});
+export const JCODE_STEER_TIMEOUT_SETTING = adapterNumber({
+  key: "adapter_timing.jcode_steer_timeout_s", path: ["adapter_timing", "jcode_steer_timeout_s"], label: "Next Jcode launch: total native steer deadline (seconds)",
+  min: 5, max: 60, defaultValue: 5, unit: "seconds", inventory: "src/adapters/jcode.ts:STEER_TIMEOUT_MS",
+});
+
+/** #489 H6: relay policy is captured at construction; inference consumers are daemon-start bound. */
+const modelNumber = <const T extends Omit<OperationalNumberSetting, "group" | "store" | "risk" | "type">>(def: T) => ({ group: "Routing", store: "config", risk: "raises", type: "integer", ...def }) as const satisfies OperationalNumberSetting;
+export const MODEL_COOLDOWN_FAILURES_SETTING = modelNumber({
+  key: "model_relay.cooldown_failures", path: ["model_relay", "cooldown_failures"], label: "Model relay: consecutive transport failures before cooldown",
+  min: 1, max: 100, defaultValue: 3, applies: "restart", restartReason: "Model relays and their health state persist until daemon shutdown", unit: "failures", inventory: "src/models/relay.ts:COOLDOWN_FAILURES",
+});
+export const MODEL_COOLDOWN_SETTING = modelNumber({
+  key: "model_relay.cooldown_s", path: ["model_relay", "cooldown_s"], label: "Model relay: initial cooldown and recent-failure window (seconds)",
+  min: 1, max: 300, defaultValue: 30, applies: "restart", restartReason: "Model relays and their health state persist until daemon shutdown", unit: "seconds", inventory: "src/models/relay.ts:COOLDOWN_MS",
+});
+export const MODEL_COOLDOWN_CAP_SETTING = modelNumber({
+  key: "model_relay.cooldown_cap_s", path: ["model_relay", "cooldown_cap_s"], label: "Model relay: maximum cooldown (seconds)",
+  min: 300, max: 3600, defaultValue: 300, applies: "restart", restartReason: "Model relays and their health state persist until daemon shutdown", unit: "seconds", inventory: "src/models/relay.ts:COOLDOWN_CAP_MS",
+});
+export const MODEL_TERMINAL_HISTORY_SETTING = modelNumber({
+  key: "model_relay.terminal_history_limit", path: ["model_relay", "terminal_history_limit"], label: "Model relay: retained completed request records",
+  min: 1, max: 1000, defaultValue: 1000, applies: "restart", restartReason: "Model relays and their health state persist until daemon shutdown", unit: "records", inventory: "src/models/relay.ts:JOURNAL_LIMIT",
+});
+const inferenceRestart = "The inference consumer captures its configuration at daemon startup";
+export const INFERENCE_BACKOFF_SETTING = modelNumber({
+  key: "inference.backoff_min", path: ["inference", "backoff_min"], label: "Inference: cooldown after a failed optional call (minutes)",
+  min: 1, max: 60, defaultValue: 5, applies: "restart", restartReason: inferenceRestart, unit: "minutes", inventory: "src/hub/inference.ts:BACKOFF_MS",
+});
+export const INFERENCE_DIGEST_ITEMS_SETTING = modelNumber({
+  key: "inference.digest_min_items", path: ["inference", "digest_min_items"], label: "Inference: condense status chatter above this item count",
+  min: 1, max: 100_000, defaultValue: 5, applies: "restart", restartReason: inferenceRestart, unit: "items", inventory: "src/hub/inference.ts:digest_min_items",
+});
+export const INFERENCE_DIGEST_CHARS_SETTING = modelNumber({
+  key: "inference.digest_min_chars", path: ["inference", "digest_min_chars"], label: "Inference: condense status chatter above this character count",
+  min: 1, max: 10_000_000, defaultValue: 8000, applies: "restart", restartReason: inferenceRestart, unit: "characters", inventory: "src/hub/inference.ts:digest_min_chars",
+});
+
+/** #489 H7: accepted presentation values are captured once by the next console launch. */
+const consoleNumber = <const T extends Omit<OperationalNumberSetting, "group" | "store" | "risk" | "applies" | "type">>(def: T) => ({ group: "Start", store: "config", risk: "raises", applies: "next use", type: "integer", ...def }) as const satisfies OperationalNumberSetting;
+export const CONSOLE_POLL_SETTING = consoleNumber({
+  key: "console.poll_ms", path: ["console", "poll_ms"], label: "Next console launch: refresh interval (milliseconds)",
+  min: 2000, max: 60_000, defaultValue: 4000, unit: "milliseconds", inventory: "src/cli/console.ts:options.pollMs ?? 4000",
+});
+export const CONSOLE_NOTICE_SETTING = consoleNumber({
+  key: "console.notice_ms", path: ["console", "notice_ms"], label: "Next console launch: notice visibility (milliseconds)",
+  min: 10_000, max: 60_000, defaultValue: 10_000, unit: "milliseconds", inventory: "src/cli/console-state.ts:NOTICE_MS",
+});
+export const CONSOLE_HISTORY_SETTING = consoleNumber({
+  key: "console.history_limit", path: ["console", "history_limit"], label: "Next console launch: retained command history",
+  min: 1, max: 100, defaultValue: 100, unit: "commands", inventory: "src/cli/console-state.ts:[...s.history, input].slice",
+});
+export const CONSOLE_PENDING_STREAM_SETTING = consoleNumber({
+  key: "console.pending_stream_limit", path: ["console", "pending_stream_limit"], label: "Next console launch: buffered offscreen stream events",
+  min: 1, max: 1000, defaultValue: 1000, unit: "events", inventory: "src/cli/console.ts:pendingStream.length > 1000",
+});
+export const CONSOLE_ATTENTION_SETTING = consoleNumber({
+  key: "console.attention_limit", path: ["console", "attention_limit"], label: "Next console launch: retained message attention entries",
+  min: 1, max: 1000, defaultValue: 1000, unit: "messages", inventory: "src/cli/console.ts:[...(state.attentionMessages ?? []), { id: msg.e.env.id, peer: msg.e.env.from, important: msg.e.env.priority === important, since: msg.e.env.ts }].slice",
+});
+
 /** Fixed metadata; never registration from a file, request, adapter or environment variable. */
 export const OPERATIONAL_NUMBERS: readonly OperationalNumberSetting[] = [GROOM_FYI_WINDOW_SETTING, DEMOTE_AT_SETTING, DEMOTION_HALF_LIFE_SETTING, CONTRADICTION_WINDOW_SETTING, RESCREEN_MAX_SETTING, SPLIT_MIN_SETTING, SPLIT_FAILURE_SHARE_SETTING,
   BUS_MAX_ATTEMPTS_SETTING, BUS_DIGEST_MAX_SETTING, BUS_PULL_BUDGET_BYTES_SETTING, BUS_NOTES_KEPT_SETTING, BUS_TERMINAL_HISTORY_LIMIT_SETTING,
-  RECOVERY_RECONNECT_WAIT_SETTING, RECOVERY_UNMANAGED_RECONNECT_WAIT_SETTING, RECOVERY_CONTROL_TIMEOUT_SETTING, RECOVERY_SHUTDOWN_WAIT_SETTING, RECOVERY_TERMINAL_IDLE_WAIT_SETTING];
+  RECOVERY_RECONNECT_WAIT_SETTING, RECOVERY_UNMANAGED_RECONNECT_WAIT_SETTING, RECOVERY_CONTROL_TIMEOUT_SETTING, RECOVERY_SHUTDOWN_WAIT_SETTING, RECOVERY_TERMINAL_IDLE_WAIT_SETTING,
+  ACP_TOOL_CEILING_SETTING, ACP_ACTIVITY_BATCH_SETTING, JCODE_STEER_TIMEOUT_SETTING,
+  MODEL_COOLDOWN_FAILURES_SETTING, MODEL_COOLDOWN_SETTING, MODEL_COOLDOWN_CAP_SETTING, MODEL_TERMINAL_HISTORY_SETTING, INFERENCE_BACKOFF_SETTING, INFERENCE_DIGEST_ITEMS_SETTING, INFERENCE_DIGEST_CHARS_SETTING,
+  CONSOLE_POLL_SETTING, CONSOLE_NOTICE_SETTING, CONSOLE_HISTORY_SETTING, CONSOLE_PENDING_STREAM_SETTING, CONSOLE_ATTENTION_SETTING];
 /** The `tasks` leaves the six #489 H2 readers need; `HubConfig.tasks` has them all. */
 export interface TaskOperationalConfig { tasks: { demote_at?: number; demotion_half_life_h?: number; contradiction_window_days?: number; rescreen_max?: number; split_min_observations?: number; split_max_failure_share?: number } }
 /**
@@ -151,4 +223,33 @@ export const recoveryWaits = (config: () => RecoveryOperationalConfig | undefine
     terminalIdleWaitMs: recoveryMs(RECOVERY_TERMINAL_IDLE_WAIT_SETTING, leaf?.terminal_idle_wait_s),
   };
 };
+export interface AdapterTimingConfig { adapter_timing?: { acp_tool_ceiling_min?: number; acp_activity_batch_ms?: number; jcode_steer_timeout_s?: number } }
+/** The host captures primitive option values for a new adapter; an accepted edit never retimes an existing launch. */
+export const adapterOperationalReaders = (config: () => AdapterTimingConfig) => ({
+  acpToolCeilingMs: () => (config().adapter_timing?.acp_tool_ceiling_min ?? ACP_TOOL_CEILING_SETTING.defaultValue) * 60_000,
+  acpActivityBatchMs: () => config().adapter_timing?.acp_activity_batch_ms ?? ACP_ACTIVITY_BATCH_SETTING.defaultValue,
+  jcodeSteerTimeoutMs: () => (config().adapter_timing?.jcode_steer_timeout_s ?? JCODE_STEER_TIMEOUT_SETTING.defaultValue) * 1000,
+});
 export const operationalNumber = (key: string): OperationalNumberSetting | undefined => OPERATIONAL_NUMBERS.find(def => def.key === key);
+
+export interface ModelOperationalConfig { model_relay?: { cooldown_failures?: number; cooldown_s?: number; cooldown_cap_s?: number; terminal_history_limit?: number } }
+/** The host captures these primitives when it constructs a relay. No current request, cooldown or journal is rewritten by reload. */
+export const modelOperationalReaders = (config: () => ModelOperationalConfig) => ({
+  cooldownFailures: () => config().model_relay?.cooldown_failures ?? MODEL_COOLDOWN_FAILURES_SETTING.defaultValue,
+  cooldownMs: () => (config().model_relay?.cooldown_s ?? MODEL_COOLDOWN_SETTING.defaultValue) * 1000,
+  cooldownCapMs: () => (config().model_relay?.cooldown_cap_s ?? MODEL_COOLDOWN_CAP_SETTING.defaultValue) * 1000,
+  terminalHistoryLimit: () => config().model_relay?.terminal_history_limit ?? MODEL_TERMINAL_HISTORY_SETTING.defaultValue,
+});
+
+export interface ConsoleOperationalConfig { console?: { poll_ms?: number; notice_ms?: number; history_limit?: number; pending_stream_limit?: number; attention_limit?: number } }
+/** Existing authenticated settings_get rows only: pending file values and client-supplied bounds never choose a value. */
+export function consoleOperationalSnapshot(rows: unknown) {
+  const read = (def: OperationalNumberSetting): number => {
+    if (!Array.isArray(rows)) return def.defaultValue;
+    const matches = rows.filter(row => row && typeof row === "object" && !Array.isArray(row) && row.key === def.key);
+    if (matches.length !== 1) return def.defaultValue;
+    const value: unknown = matches[0].value;
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= def.min && value <= def.max ? value : def.defaultValue;
+  };
+  return Object.freeze({ pollMs: read(CONSOLE_POLL_SETTING), noticeMs: read(CONSOLE_NOTICE_SETTING), historyLimit: read(CONSOLE_HISTORY_SETTING), pendingStreamLimit: read(CONSOLE_PENDING_STREAM_SETTING), attentionLimit: read(CONSOLE_ATTENTION_SETTING) });
+}

package/src/hub/peers.ts

@@ -2,6 +2,7 @@ import type { Envelope, EnvelopeOpts, PeerId, PeerState } from "./envelope.ts";
 import type { PermissionMode } from "./permission-mode.ts";
 import type { StartForm } from "../adapters/registry-types.ts";
 import type { DoingKind } from "./peer-doing.ts";
+import type { CapabilityManifest } from "./capabilities.ts";
 
 export interface DeliveryReceipt {
   id: string;
@@ -66,6 +67,8 @@ export interface PeerAdapter {
   readonly statusNotice?: { code: "unidentified-cancellation" | "qwen-detached" | "qwen-stalled"; message: string };
   /** Fixed builtins with session.nativeRevert only. Native conversation effects remain in the adapter. */
   revertTurn?(nativeTurn: string): Promise<void>;
+  /** #445 C1: what this peer's native source lists right now (a probed version only), or an empty manifest. Never throws for an unprobed version; a transport failure rejects. */
+  capabilityManifest?(): Promise<CapabilityManifest>;
   /** Leave the roster without stopping a person's terminal. */
   detachForRoster?(resetMode: PermissionMode): void | Promise<void>;
   /** Return to the roster after detachForRoster. */

package/src/hub/restart.ts

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { join } from "node:path";
 import type { BusSnapshot } from "./bus.ts";
 import type { Envelope, PeerId, PeerState } from "./envelope.ts";
-import { MAX_HOP } from "./envelope.ts";
+import { KINDS, MAX_HOP } from "./envelope.ts";
 import { validateJournalSnapshot } from "./delivery-journal.ts";
 import { atomicPrivateJSON } from "./recovery-store.ts";
 import { RecoveryDeferredHubError, validateDeferredHub } from "./deferred-hub.ts";
@@ -76,7 +76,7 @@ export function readRestartSnapshot(stateDir: string, expected: RestartReadExpec
   const isEnvelope = (value: unknown, seen = false): boolean => {
     if (!value || typeof value !== "object") return false;
     const e = value as Record<string, unknown>;
-    return typeof e.id === "string" && e.id.length > 0 && e.id.length <= 256 && typeof e.trace === "string" && e.trace.length > 0 && e.trace.length <= 256 && peerId(e.from) && typeof e.body === "string" && Number.isSafeInteger(e.hop) && (e.hop as number) >= 0 && (seen || (e.hop as number) <= MAX_HOP) && Number.isFinite(e.ts) && ["chat", "task", "review", "status", "budget", "presence"].includes(e.kind as string) && ["important", "status", "fyi"].includes(e.priority as string) && (e.to === undefined || (Array.isArray(e.to) && e.to.every(peerId)));
+    return typeof e.id === "string" && e.id.length > 0 && e.id.length <= 256 && typeof e.trace === "string" && e.trace.length > 0 && e.trace.length <= 256 && peerId(e.from) && typeof e.body === "string" && Number.isSafeInteger(e.hop) && (e.hop as number) >= 0 && (seen || (e.hop as number) <= MAX_HOP) && Number.isFinite(e.ts) && (KINDS as readonly string[]).includes(e.kind as string) && ["important", "status", "fyi"].includes(e.priority as string) && (e.to === undefined || (Array.isArray(e.to) && e.to.every(peerId)));
   };
   const bus = s.bus as Partial<BusSnapshot>;
   if (bus.schemaVersion !== 1 || !bus.queues || typeof bus.queues !== "object" || !bus.prefaces || typeof bus.prefaces !== "object" || !Array.isArray(bus.seen) || !bus.attempts || typeof bus.attempts !== "object" || !Array.isArray(bus.withdrawn)) return undefined;

package/src/hub/room-invocations.ts

@@ -0,0 +1,145 @@
+/** Host-owned X6 correlation. The room transport never becomes a task/tool authority. */
+import { PreEffectToolRefusal } from "./tool-refusal.ts";
+import { HUB, MAX_HOP, newEnvelope, type Envelope } from "./envelope.ts";
+import type { Bus } from "./bus.ts";
+import { argsDigest, boundedInvocationBody, isOpenOutcome, type InvocationLedger, type InvocationOutcome, type InvocationRow } from "./invocations.ts";
+import { canonical, type ShareConfig } from "./capabilities.ts";
+import { authorizeRoomInvocation, type RoomInvocationAuthorization } from "../rooms/boundary.ts";
+import { decodeRoomInvocationBody, encodeRoomInvocationBody, type RoomReadInvocationRequest } from "../rooms/application.ts";
+import type { RoomInvocationIdentity, RoomInvocationIngress } from "../rooms/service.ts";
+
+export interface RoomInvocationPorts {
+  bus: Bus; ledger: InvocationLedger; shares: () => ShareConfig;
+  identity: (peer: string, sender?: string) => RoomInvocationIdentity | undefined;
+  target: (input: RoomInvocationIngress, request: RoomReadInvocationRequest) => Promise<void>;
+  safeResult: (body: string, current: () => boolean) => Promise<boolean>;
+  quarantine?: (row: InvocationRow) => void;
+  finish: (row: InvocationRow, outcome: InvocationOutcome, input?: { body?: string; reason?: string }) => void;
+}
+export class RoomInvocations {
+  constructor(private readonly p: RoomInvocationPorts) {}
+  localActor(env: Envelope): string | undefined {
+    const local = env.kind === "invocation" ? env.id : env.refs?.invocation;
+    const row = local && this.p.ledger.get(local), route = local && this.p.ledger.relay(local);
+    if (!row || !route) return undefined;
+    try {
+      const identity = this.p.identity(route.remotePeer);
+      return identity && this.authorization(env, identity) ? route.direction === "outbound" ? row.caller : row.target : undefined;
+    } catch { return undefined; }
+  }
+  authorization(env: Envelope, identity: RoomInvocationIdentity): RoomInvocationAuthorization | undefined {
+    const local = env.kind === "invocation" ? env.id : env.refs?.invocation;
+    const row = local && this.p.ledger.get(local), route = local && this.p.ledger.relay(local);
+    if (!row || !route || row.class !== "read" || env.from !== HUB || env.to?.length !== 1 || env.to[0] !== route.remotePeer
+      || route.room !== identity.room || route.member !== identity.member || route.epoch !== identity.epoch || !identity.current()) return undefined;
+    if (env.kind === "invocation" && (route.direction !== "outbound" || !isOpenOutcome(row.outcome) || env.id !== route.request)) return undefined;
+    if (env.kind === "invocation_result" && (route.direction !== "inbound" || env.id !== route.result || route.state !== "result_queued")) return undefined;
+    if (env.kind !== "invocation" && env.kind !== "invocation_result") return undefined;
+    if (env.trace !== row.trace || env.hop !== route.hop + (env.kind === "invocation_result" ? 1 : 0)) return undefined;
+    if (env.kind === "invocation" && roomInvocationHash({ id: env.id, trace: env.trace, hop: env.hop, from: route.caller, to: route.target,
+      kind: env.kind, priority: "status", body: env.body, ts: env.ts }) !== route.hash) return undefined;
+    const payload = decodeRoomInvocationBody(env.kind, env.body);
+    if (payload.invocation !== route.request || payload.capability !== route.capability || payload.digest !== route.digest) return undefined;
+    if (env.kind === "invocation_result" && (payload as import("../rooms/application.ts").RoomReadInvocationResult).outcome !== row.outcome) return undefined;
+    if (env.kind === "invocation" && argsDigest((payload as RoomReadInvocationRequest).args) !== row.argsSha256) return undefined;
+    const current = () => {
+      const live = this.p.ledger.relay(row.id), candidate = this.p.ledger.get(row.id);
+      const pin = this.p.shares()[route.remotePeer]?.[route.capability];
+      return identity.current() && !!candidate && live?.room === identity.room && live.member === identity.member && live.epoch === identity.epoch
+        && (env.kind === "invocation" ? isOpenOutcome(candidate.outcome) && pin?.digest === row.digest && pin.class === "read" : live.state === "result_queued" && live.result === env.id);
+    };
+    return authorizeRoomInvocation(env, route.direction === "outbound" ? row.caller : row.target, payload, current);
+  }
+  /** Called after target execution settles, before the ordinary caller-offline early return. */
+  result(row: InvocationRow, outcome: InvocationOutcome, input: { body?: string; reason?: string }): boolean {
+    const route = this.p.ledger.relay(row.id);
+    if (!route || route.direction !== "inbound") return false;
+    const result = newEnvelope(HUB, "", { to: [route.remotePeer], kind: "invocation_result", priority: "status", refs: { invocation: row.id } });
+    result.trace = row.trace; result.hop = route.hop + 1;
+    result.body = encodeRoomInvocationBody("invocation_result", { invocation: route.request, capability: row.capability, digest: row.digest, class: "read",
+      outcome: outcome as Exclude<InvocationOutcome, "queued" | "delivered">, body: outcome === "withheld" ? "" : boundedInvocationBody(input.body ?? input.reason ?? "no result") });
+    const identity = this.p.identity(route.remotePeer, row.target);
+    if (!identity || identity.room !== route.room || identity.member !== route.member || identity.epoch !== route.epoch || !identity.current()) {
+      this.p.ledger.updateRelay(row.id, "needs_review"); this.p.bus.holdInvocation(row.id, "remote invocation result route changed", row.target); return true;
+    }
+    this.p.ledger.updateRelay(row.id, "result_queued", result.id);
+    try { this.p.bus.publish(result); }
+    catch { this.p.ledger.updateRelay(row.id, "needs_review"); this.p.bus.holdInvocation(row.id, "remote invocation result publication is uncertain", row.target); }
+    return true;
+  }
+  async receive(input: RoomInvocationIngress): Promise<"admitted" | "refused"> {
+    const env = input.envelope;
+    if (env.kind === "invocation") {
+      const request = decodeRoomInvocationBody("invocation", env.body);
+      if (env.hop >= MAX_HOP || !input.current()) return "refused";
+      const prior = this.p.ledger.relayByRemote(input.room, input.member, request.invocation, "inbound");
+      if (prior) {
+        if (prior.hash !== input.hash || prior.epoch !== input.epoch || prior.remotePeer !== input.remotePeer || prior.caller !== env.from || prior.target !== env.to || prior.capability !== request.capability || prior.digest !== request.digest) return "refused";
+        if (!input.claim()) throw new Error("room: invocation claim unavailable");
+        return "admitted";
+      }
+      try { await this.p.target(input, request); return "admitted"; }
+      catch (error) {
+        // Only a proven pre-effect refusal earns a signed NACK; storage/post-claim failures retain uncertainty.
+        if (error instanceof PreEffectToolRefusal) return "refused";
+        throw error;
+      }
+    }
+    if (env.kind !== "invocation_result") return "refused";
+    const result = decodeRoomInvocationBody("invocation_result", env.body), route = this.p.ledger.relay(result.invocation), row = this.p.ledger.get(result.invocation);
+    if (!route || !row || route.direction !== "outbound" || route.room !== input.room || route.member !== input.member || route.epoch !== input.epoch
+      || route.remotePeer !== input.remotePeer || env.from !== route.target || env.to !== route.caller || env.trace !== row.trace || env.hop !== route.hop + 1
+      || result.capability !== row.capability || result.digest !== row.digest || !input.current()) return "refused";
+    if (!isOpenOutcome(row.outcome)) { if (!input.claim()) throw new Error("room: invocation claim unavailable"); return "admitted"; }
+    const pin = this.p.shares()[route.remotePeer]?.[route.capability];
+    const current = () => input.current() && this.p.shares()[route.remotePeer]?.[route.capability]?.digest === row.digest
+      && this.p.shares()[route.remotePeer]?.[route.capability]?.class === "read";
+    let safe = pin?.digest === row.digest && pin.class === "read" && await this.p.safeResult(result.body, current);
+    if (!input.current()) throw new Error("room: invocation trust changed");
+    safe &&= current();
+    if (!input.claim()) throw new Error("room: invocation claim unavailable");
+    const uncertain = result.outcome === "needs_review" || result.outcome === "timeout";
+    if (uncertain) this.p.bus.holdInvocation(row.id, "target hub reports an uncertain invocation", row.target);
+    this.p.ledger.updateRelay(row.id, route.state, env.id);
+    const outcome = uncertain ? "needs_review" : safe ? result.outcome : result.outcome === "refused" ? "refused" : "withheld";
+    const visible = safe ? result.outcome === "completed" ? { body: result.body } : { reason: boundedInvocationBody(result.body) }
+      : uncertain ? { reason: "the target reports an uncertain outcome; remote details were withheld" }
+      : result.outcome === "refused" ? { reason: "the target declined; the reason was withheld" } : {};
+    this.p.finish(row, outcome, visible);
+    this.p.ledger.updateRelay(row.id, uncertain ? "needs_review" : "completed", env.id);
+    return "admitted";
+  }
+  receipt(id: string, state: "completed" | "failed_safe" | "needs_review"): void {
+    const request = this.p.ledger.relay(id), result = this.p.ledger.relayForResult(id);
+    if (request?.direction === "outbound") {
+      if (state === "completed") { this.p.ledger.markDelivered(id); this.p.ledger.updateRelay(id, "admitted"); }
+      else {
+        this.p.ledger.updateRelay(id, state === "failed_safe" ? "completed" : "needs_review"); const row = this.p.ledger.get(id);
+        if (row) this.p.finish(row, state === "failed_safe" ? "refused" : "needs_review", { reason: state === "failed_safe" ? "the target hub refused read admission" : "remote invocation delivery is uncertain; inspect it by hand" });
+      }
+    }
+    if (result) this.p.ledger.updateRelay(result.local, state === "completed" ? "completed" : "needs_review");
+  }
+  /** Startup only: never resend an outcome whose publication a crash could have interrupted. */
+  reconcile(): void {
+    const pending = this.p.bus.queueList(undefined, true);
+    for (const route of this.p.ledger.pendingRelays()) {
+      if (route.state === "needs_review") continue;
+      const row = this.p.ledger.get(route.local);
+      if (!row) continue;
+      const request = pending.find(delivery => delivery.originals.some(env => env.id === row.id));
+      if (isOpenOutcome(row.outcome) && (!request || request.state !== "queued")) {
+        this.p.bus.holdInvocation(row.id, "remote invocation handoff is unconfirmed after restart", row.target);
+        this.p.ledger.updateRelay(row.id, "needs_review");
+        if (this.p.quarantine) this.p.quarantine(row); else this.p.ledger.settle(row.id, "needs_review");
+        continue;
+      }
+      const result = route.result && pending.find(delivery => delivery.originals.some(env => env.id === route.result));
+      if (route.direction === "inbound" && !isOpenOutcome(row.outcome) && (route.state !== "result_queued" || !result || result.state !== "queued")) {
+        this.p.ledger.updateRelay(row.id, "needs_review");
+        if (!route.result) this.p.bus.holdInvocation(row.id, "remote result publication was interrupted", row.target);
+      } else if (route.direction === "outbound" && !isOpenOutcome(row.outcome)) this.p.ledger.updateRelay(row.id, "needs_review");
+    }
+  }
+}
+export const roomInvocationHash = (value: unknown): string => argsDigest(canonical(value));

package/src/hub/settings.ts

@@ -87,7 +87,7 @@ export const SETTINGS: readonly SettingDef[] = [
  * Never editable from settings, whatever the session: these choose what the hub executes or where secrets and task
  * text go. A key equal to an entry, or below it, is refused by name.
  */
-export const NEVER_EDITABLE = ["kimi_cmd", "qwen_cmd", "jcode_cmd", "jcode_home", "jcode_provider_profile", "codex_bin", "pi.cmd", "checks", "mlx", "omniroute", "memory.worker_url", "local.read_allow", "local.bash_network", "local.network_allow", "bench.enabled", "terminal", "schedules", "folder_triggers", "corpus", "rooms", "instances", "adapters", "adapter_modules", "local.doc_read", "local.web_fetch"] as const;
+export const NEVER_EDITABLE = ["invocation", "kimi_cmd", "qwen_cmd", "jcode_cmd", "jcode_home", "jcode_provider_profile", "codex_bin", "pi.cmd", "checks", "mlx", "omniroute", "memory.worker_url", "local.read_allow", "local.bash_network", "local.network_allow", "bench.enabled", "terminal", "schedules", "folder_triggers", "corpus", "rooms", "instances", "adapters", "adapter_modules", "local.doc_read", "local.web_fetch"] as const;
 
 /**
  * The one key `ahub learn accept` writes (#514b): the active profile's review checklist, which replaces as a unit. It is NOT a row of `SETTINGS` and `settingDef` does NOT resolve it, so

package/src/hub/shipped-packs.ts

@@ -1,8 +1,11 @@
 import example from "../../templates/packs/example.pack.json" with { type: "text" };
+import writing from "../../templates/packs/writing-pack.pack.json" with { type: "text" };
+import analysis from "../../templates/packs/analysis.pack.json" with { type: "text" };
+import ops from "../../templates/packs/ops.pack.json" with { type: "text" };
 
 /**
  * The packs the hub ships (#513a), by file name without `.pack.json`. Imported as text so the bundle carries them, as `shipped-roles.ts` carries the role catalog.
- * Only the format example is here: the writing, analysis and ops packs are #513b, which adds a file to `templates/packs/` and a line here.
+ * The format example and the writing, analysis and ops domain packs are advisory data; checks never execute from this registry.
  */
 // TypeScript types a `.json` import as its parsed shape even with `type: "text"`; Bun hands over the file text, which `parsePack` parses and bounds itself.
-export const SHIPPED_PACKS: Readonly<Record<string, string>> = { example: example as unknown as string };
+export const SHIPPED_PACKS: Readonly<Record<string, string>> = { example: example as unknown as string, "writing-pack": writing as unknown as string, analysis: analysis as unknown as string, ops: ops as unknown as string };

package/src/hub/shipped-roles.ts

@@ -10,6 +10,13 @@ import role8 from "../../templates/roles/research/analyst.md" with { type: "text
 import role9 from "../../templates/roles/research/statistician.md" with { type: "text" };
 import role10 from "../../templates/roles/research/fact-checker.md" with { type: "text" };
 
+import role11 from "../../templates/roles/writing/editor.md" with { type: "text" };
+import role12 from "../../templates/roles/writing/translator.md" with { type: "text" };
+import role13 from "../../templates/roles/writing/style-checker.md" with { type: "text" };
+import role14 from "../../templates/roles/writing/terminology-checker.md" with { type: "text" };
+import role15 from "../../templates/roles/ops/project-manager.md" with { type: "text" };
+import role16 from "../../templates/roles/ops/meeting-actions-owner.md" with { type: "text" };
+
 export const SHIPPED_ROLES: Readonly<Record<string, string>> = {
   "software-architect": role0,
   "backend-engineer": role1,
@@ -22,4 +29,10 @@ export const SHIPPED_ROLES: Readonly<Record<string, string>> = {
   "analyst": role8,
   "statistician": role9,
   "fact-checker": role10,
+  "editor": role11,
+  "translator": role12,
+  "style-checker": role13,
+  "terminology-checker": role14,
+  "project-manager": role15,
+  "meeting-actions-owner": role16,
 };

package/src/hub/tasks.ts

@@ -1,3 +1,4 @@
+import type { InvocationRow } from "./invocations.ts";
 import type { ContextAdmission } from "./context-window.ts";
 import { queueBackpressure, queueBackpressurePolicy, type QueueBackpressureCode, type QueueBackpressurePolicy, type QueueBackpressureStatus, type QueuePressure } from "./queue-backpressure.ts";
 import { canonicalMemorySymbolNode, normalizeMemorySymbolInput, MEMORY_SYMBOL_LIMIT, type MemorySymbolNodes } from "./memory-symbols.ts";
@@ -262,6 +263,7 @@ QUIET_EVENTS.add("ready held"); // #655: the hub's note that a ready task waits
 QUIET_EVENTS.add("plan observed"); // Host observation does not move the task or replace completion intent.
 QUIET_EVENTS.add("planner changed"); // Planning authority does not move the execution owner or revoke its handoff.
 QUIET_EVENTS.add("claim verdict"); // #901: a person's bookkeeping on a plan claim moves nothing, so it must not turn a running check into "check finished late".
+QUIET_EVENTS.add("invocation");
 QUIET_EVENTS.add("shell branch bound"); // #880: the hub's host-observed branch binding (#845) is bookkeeping; it neither moves nor settles the task.
 /** The records of the `done (checking)` entry a passed check now completes: what the owner delivered then (#509a). */
 const latestPendingDeliverables = (task: Task): DeliverableRecord[] | undefined => {
@@ -609,6 +611,17 @@ export class Tasks {
     });
   }
 
+  /** Host-only audit: no tool accepts this record and no task state or notification changes. */
+  recordInvocation(id: number, row: InvocationRow): void {
+    const task = this.d.board.get(id);
+    if (!task) throw new Error("invocation audit task is unavailable");
+    if (row.task !== id) throw new Error("invocation audit task mismatch");
+    if (row.outcome === "queued" && (this.isPii(task) || this.d.privateTurn?.(row.caller) || isClosedTaskState(task.state) || task.state === "backlog" || task.owner !== row.caller && task.reviewer !== row.caller)) throw new Error("invocation audit task scope changed");
+    if (task.history.some(entry => entry.invocation?.id === row.id && entry.invocation.outcome === row.outcome)) return;
+    const { id: invocationId, caller, target, capability, digest, class: sideEffect, approval, argsSha256, outcome } = row;
+    this.d.board.update(id, HUB, "invocation", {}, undefined, { invocation: { id: invocationId, caller, target, capability, digest, class: sideEffect, approval, argsSha256, outcome } });
+  }
+
   recordOwnerTurn(peer: PeerId, bindings: readonly { id: number; acceptance: number }[], changed: boolean | undefined, effect: boolean): void {
     requireLocalTaskPeer(peer);
     this.noWriteTurns.retain(this.d.board.list("in_progress").filter(task => ["implement", "bulk_edit"].includes(task.class)).map(task => task.id));
@@ -865,6 +878,7 @@ export class Tasks {
       ...(h.reviewFindings ? { reviewFindings: !h.withheld && this.findingTextAllowed(task, h.reviewFindings.items) ? h.reviewFindings
         : { ...(h.reviewFindings.head ? { head: h.reviewFindings.head } : {}), tally: findingTally(h.reviewFindings.items), withheld: true } } : {}),
       ...(h.supersededBy === undefined ? {} : { supersededBy: screenHistoryText(h.supersededBy, "supersession", h.withheld) }),
+      ...(h.invocation ? { invocation: h.invocation } : {}),
       ...(h.profile === undefined ? {} : { profile: screenHistoryText(h.profile, "profile") }),
       ...(h.owner === undefined ? {} : { owner: h.owner }),
       ...(h.planner === undefined ? {} : { planner: h.planner }),

package/src/memory/capture.ts

@@ -1,6 +1,6 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { defaultCapturePeer } from "../adapters/definitions/native-identity-defaults.ts";
-import { BOUNDED_TASK_TOOLS } from "../hub/hub-tools.ts";
+import { BOUNDED_TASK_TOOLS, CAPABILITY_TOOLS } from "../hub/hub-tools.ts";
 import { MEMORY_READ_TOOLS } from "../hub/read-tools.ts";
 import { isDenied } from "../local/deny.ts";
 import type { MemoryClient } from "./client.ts";
@@ -38,7 +38,7 @@ export class Capture {
   }
 
   observe(call: { tool: string; args: string; output: string; id: string; paths: string[]; sourceId?: string }): void {
-    if (!this.sessionId || ((MEMORY_READ_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || BOUNDED_TASK_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_memory_correct") || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_source_read" || this.opts.skip?.includes(call.tool)) return;
+    if (!this.sessionId || ((MEMORY_READ_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || BOUNDED_TASK_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || CAPABILITY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_memory_correct") || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_source_read" || this.opts.skip?.includes(call.tool)) return;
     // Anything that names a denylisted path is kept out of memory entirely, input and output alike.
     if (call.paths.some((p) => isDenied(p, this.opts.deny) || p.split(/\s+/).some((word) => isDenied(word, this.opts.deny)))) return;
     // ponytail: legacy callers without a host sourceId dedupe native ids within a summary interval; all live LocalPeer calls supply invocation identity. Require that port for other hosts.

package/src/models/relay.ts

@@ -167,6 +167,11 @@ export interface ModelRelayOptions {
   efficientWaitMs?: number;
   /** A backend alias's cooldown starts or ends. */
   onCooldown?: (event: RelayCooldownEvent) => void;
+  /** Host-validated policy captured when this relay is constructed. */
+  cooldownFailures?: number;
+  cooldownMs?: number;
+  cooldownCapMs?: number;
+  terminalHistoryLimit?: number;
   /** Cooldown clock; tests inject one. */
   now?: () => number;
   /** How long a dispatch waits for a busy MLX slot before it gives up and falls back (default 120 s); tests shorten it. */
@@ -207,8 +212,9 @@ export interface ModelRelay {
 
 export interface RelayCooldownEvent { alias: string; event: "start" | "end"; failures: number; ms?: number }
 
-// ponytail: fixed policy, 3 failures and 30 s doubling up to 5 min; routing.toml keys if a backend needs other values.
-const COOLDOWN_FAILURES = 3, COOLDOWN_MS = 30_000, COOLDOWN_CAP_MS = 300_000;
+/** Legacy defaults, independently pinned by the operational-settings tests. */
+export const COOLDOWN_FAILURES = 3, COOLDOWN_MS = 30_000, COOLDOWN_CAP_MS = 300_000;
+export const RELAY_TERMINAL_HISTORY_LIMIT = 1000;
 /** The longest one upstream request may take. */
 const REQUEST_DEADLINE_MS = 180_000;
 // ponytail: a moved attempt (a load move or an enforced pin, both only optimizations) gets 15 s to its response headers
@@ -222,7 +228,12 @@ const MOVE_FIRST_BYTE_MS = 15_000;
  */
 export class BackendCooldowns {
   private readonly entries = new Map<string, { failures: number; until?: number; failedAt?: number; countedAt?: number }>();
-  constructor(private readonly now: () => number = Date.now, private readonly notify: (event: RelayCooldownEvent) => void = () => {}) {}
+  private readonly policy: { failures: number; cooldownMs: number; capMs: number };
+  constructor(
+    private readonly now: () => number = Date.now,
+    private readonly notify: (event: RelayCooldownEvent) => void = () => {},
+    policy: { failures: number; cooldownMs: number; capMs: number } = { failures: COOLDOWN_FAILURES, cooldownMs: COOLDOWN_MS, capMs: COOLDOWN_CAP_MS },
+  ) { this.policy = { ...policy }; }
 
   /** The alias's cooldown while it lasts. Its end is recorded when it is first seen to have passed, or at an answer. */
   cooling(alias: string): { until: number; failures: number } | undefined {
@@ -244,11 +255,11 @@ export class BackendCooldowns {
     const entry = this.entry(alias);
     entry.failedAt = this.now();
     if (cooling || !streak) return;
-    if (entry.countedAt !== undefined && this.now() - entry.countedAt > 2 * COOLDOWN_CAP_MS) entry.failures = 0;
+    if (entry.countedAt !== undefined && this.now() - entry.countedAt > 2 * this.policy.capMs) entry.failures = 0;
     entry.countedAt = this.now();
     entry.failures++;
-    if (entry.failures < COOLDOWN_FAILURES) return;
-    const ms = Math.min(COOLDOWN_CAP_MS, COOLDOWN_MS * 2 ** (entry.failures - COOLDOWN_FAILURES));
+    if (entry.failures < this.policy.failures) return;
+    const ms = Math.min(this.policy.capMs, this.policy.cooldownMs * 2 ** (entry.failures - this.policy.failures));
     entry.until = this.now() + ms;
     this.notify({ alias, event: "start", failures: entry.failures, ms });
   }
@@ -265,7 +276,7 @@ export class BackendCooldowns {
   /** Until when the alias's last dispatch counts as failed for a load move, while it does. */
   failing(alias: string): number | undefined {
     const at = this.entries.get(alias)?.failedAt;
-    return at !== undefined && this.now() < at + COOLDOWN_MS ? at + COOLDOWN_MS : undefined;
+    return at !== undefined && this.now() < at + this.policy.cooldownMs ? at + this.policy.cooldownMs : undefined;
   }
 
   private entry(alias: string) {
@@ -430,7 +441,7 @@ export async function startModelRelay(options: ModelRelayOptions): Promise<Model
   const models = relayModelIds(options);
   const efficientWaitMs = options.efficientWaitMs;
   const moveFirstByteMs = options.moveFirstByteMs ?? MOVE_FIRST_BYTE_MS;
-  const cooldowns = new BackendCooldowns(options.now, (event) => { try { options.onCooldown?.(event); } catch { /* observation cannot fail routing */ } });
+  const cooldowns = new BackendCooldowns(options.now, (event) => { try { options.onCooldown?.(event); } catch { /* observation cannot fail routing */ } }, { failures: options.cooldownFailures ?? COOLDOWN_FAILURES, cooldownMs: options.cooldownMs ?? COOLDOWN_MS, capMs: options.cooldownCapMs ?? COOLDOWN_CAP_MS });
   const autoRoute = options.enableHubAuto ? new AutoRouteSelector({ ...options, dgxMaxInputTokens }, defaultBackend, mlxAlias, estimateInputTokens) : undefined;
   let mlx: MlxHandle | undefined;
   let mlxStarting: Promise<MlxHandle> | undefined;
@@ -438,7 +449,7 @@ export async function startModelRelay(options: ModelRelayOptions): Promise<Model
   const activeRequests = new Set<ActiveRequest>();
   const activeByAlias = new Map<string, number>();
   const journal: RelayRequestRecord[] = [];
-  const JOURNAL_LIMIT = 1000;
+  const JOURNAL_LIMIT = options.terminalHistoryLimit ?? RELAY_TERMINAL_HISTORY_LIMIT;
 
   // The record object is the generation fence: every update goes through this entry's own closure,
   // so interleaved requests for the same alias never write into each other's evidence.

package/src/rooms/application.ts

@@ -6,7 +6,7 @@ import { canonicalBytes, ROOM_WIRE_LIMITS } from "./wire.ts";
 export const ROOM_APPLICATION_MAX_BYTES = ROOM_WIRE_LIMITS.plaintext;
 export interface RoomChatEnvelope {
   id: string; trace: string; hop: number; from: string; to: string;
-  kind: "chat" | "status"; priority: Priority; body: string; ts: number;
+  kind: "chat" | "status" | "invocation" | "invocation_result"; priority: Priority; body: string; ts: number;
 }
 export type RoomReceiptReason = "admitted" | "inbox_admitted" | "inbox_full" | "inbox_oversize" | "inbox_expired" | "inbox_age_unavailable" | "not_exposed" | "boundary_refused" | "invalid_message" | "rate_limited" | "hop" | "person_inbox_unsupported";
 export type RoomMessage =
@@ -64,10 +64,75 @@ function text(value: unknown): string {
   if (encoder.encode(value).length > ROOM_APPLICATION_MAX_BYTES) fail("limit");
   return value;
 }
+export type RoomInvocationKind = "invocation" | "invocation_result";
+export interface RoomReadInvocationRequest {
+  invocation: string; capability: string; digest: string; class: "read"; depth: 1;
+  args: Record<string, string | number | boolean>;
+}
+export interface RoomReadInvocationResult {
+  invocation: string; capability: string; digest: string; class: "read";
+  outcome: "completed" | "refused" | "failed" | "expired" | "timeout" | "needs_review" | "withheld";
+  body: string;
+}
+export type RoomInvocationPayload = RoomReadInvocationRequest | RoomReadInvocationResult;
+/** Wire contract bounds; the target still validates the capability's actual schema. */
+const INVOCATION_ARGS_MAX = 4096, INVOCATION_STRING_MAX = 2000, INVOCATION_RESULT_MAX = 8192;
+const CAPABILITY_ID = /^(command|skill|mcp_tool):[A-Za-z0-9_.:-]{1,64}$/;
+const CAPABILITY_DIGEST = /^sha256:[0-9a-f]{64}$/;
+export function roomInvocationArgs(value: unknown): Record<string, string | number | boolean> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail();
+  const keys = Object.keys(value).sort();
+  if (keys.length > 16) fail("limit");
+  const raw = object(value, keys), args = Object.create(null) as Record<string, string | number | boolean>;
+  for (const key of keys) {
+    if (/^[A-Za-z0-9_.:-]{1,64}$/.exec(key)?.[0] !== key) fail();
+    const arg = raw[key];
+    if (typeof arg === "string") { if (!arg.isWellFormed() || arg.length > INVOCATION_STRING_MAX) fail("limit"); }
+    else if (typeof arg !== "boolean" && (typeof arg !== "number" || !Number.isFinite(arg))) fail();
+    Object.defineProperty(args, key, { value: arg, enumerable: true });
+  }
+  if (JSON.stringify(args).length > INVOCATION_ARGS_MAX) fail("limit");
+  return Object.fromEntries(Object.entries(args));
+}
+function invocationPayload(kind: RoomInvocationKind, value: unknown): RoomInvocationPayload {
+  const row = object(value, kind === "invocation" ? ["invocation", "capability", "digest", "class", "depth", "args"] : ["invocation", "capability", "digest", "class", "outcome", "body"]);
+  if (row.class !== "read" || typeof row.capability !== "string" || CAPABILITY_ID.exec(row.capability)?.[0] !== row.capability
+    || typeof row.digest !== "string" || CAPABILITY_DIGEST.exec(row.digest)?.[0] !== row.digest) fail();
+  const common = { invocation: uuid(row.invocation), capability: row.capability, digest: row.digest, class: "read" as const };
+  if (kind === "invocation") {
+    if (row.depth !== 1) fail();
+    return { ...common, depth: 1, args: roomInvocationArgs(row.args) };
+  }
+  if (typeof row.outcome !== "string" || !["completed", "refused", "failed", "expired", "timeout", "needs_review", "withheld"].includes(row.outcome)) fail();
+  const body = text(row.body);
+  if (encoder.encode(body).length > INVOCATION_RESULT_MAX) fail("limit");
+  if (row.outcome === "withheld" && body !== "") fail();
+  return { ...common, outcome: row.outcome as RoomReadInvocationResult["outcome"], body };
+}
+/** Closed canonical JSON inside the encrypted envelope: no refs, approvals or extra authority fields. */
+export function encodeRoomInvocationBody(kind: RoomInvocationKind, value: RoomInvocationPayload): string {
+  try { return decoder.decode(canonicalBytes(invocationPayload(kind, value))); }
+  catch (error) { return applicationError(error); }
+}
+export function decodeRoomInvocationBody(kind: "invocation", body: string): RoomReadInvocationRequest;
+export function decodeRoomInvocationBody(kind: "invocation_result", body: string): RoomReadInvocationResult;
+export function decodeRoomInvocationBody(kind: RoomInvocationKind, body: string): RoomInvocationPayload;
+export function decodeRoomInvocationBody(kind: RoomInvocationKind, body: string): RoomInvocationPayload {
+  try {
+    const parsed = invocationPayload(kind, JSON.parse(text(body)));
+    if (decoder.decode(canonicalBytes(parsed)) !== body) fail();
+    return parsed;
+  } catch (error) { return applicationError(error); }
+}
+
 function parseEnvelope(value: unknown): RoomChatEnvelope {
   const row = object(value, ["id", "trace", "hop", "from", "to", "kind", "priority", "body", "ts"]);
-  if (row.kind !== "chat" && row.kind !== "status") fail();
+  if (row.kind !== "chat" && row.kind !== "status" && row.kind !== "invocation" && row.kind !== "invocation_result") fail();
   if (row.priority !== "important" && row.priority !== "status" && row.priority !== "fyi") fail();
+  if (row.kind === "invocation" || row.kind === "invocation_result") {
+    const payload = decodeRoomInvocationBody(row.kind, text(row.body));
+    if (row.from === "user" || row.to === "user" || row.priority !== "status" || row.kind === "invocation" && payload.invocation !== row.id) fail();
+  }
   return { id: uuid(row.id), trace: uuid(row.trace), hop: integer(row.hop, 0, MAX_HOP), from: localPeer(row.from), to: localPeer(row.to), kind: row.kind, priority: row.priority, body: text(row.body), ts: integer(row.ts, 0) };
 }
 function frameDigest(value: unknown): string {