agents-city 0.4.0 → 0.5.2

package/plugin/channel/client.js

@@ -13,7 +13,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -45,10 +49,10 @@ var require_constants = __commonJS({
       EMPTY_BUFFER: Buffer.alloc(0),
       GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
       hasBlob,
-      kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
-      kListener: Symbol("kListener"),
-      kStatusCode: Symbol("status-code"),
-      kWebSocket: Symbol("websocket"),
+      kForOnEventAttribute: /* @__PURE__ */ Symbol("kIsForOnEventAttribute"),
+      kListener: /* @__PURE__ */ Symbol("kListener"),
+      kStatusCode: /* @__PURE__ */ Symbol("status-code"),
+      kWebSocket: /* @__PURE__ */ Symbol("websocket"),
       NOOP: () => {
       }
     };
@@ -134,8 +138,8 @@ var require_buffer_util = __commonJS({
 var require_limiter = __commonJS({
   "node_modules/ws/lib/limiter.js"(exports, module) {
     "use strict";
-    var kDone = Symbol("kDone");
-    var kRun = Symbol("kRun");
+    var kDone = /* @__PURE__ */ Symbol("kDone");
+    var kRun = /* @__PURE__ */ Symbol("kRun");
     var Limiter = class {
       /**
        * Creates a new `Limiter`.
@@ -190,11 +194,11 @@ var require_permessage_deflate = __commonJS({
     var { kStatusCode } = require_constants();
     var FastBuffer = Buffer[Symbol.species];
     var TRAILER = Buffer.from([0, 0, 255, 255]);
-    var kPerMessageDeflate = Symbol("permessage-deflate");
-    var kTotalLength = Symbol("total-length");
-    var kCallback = Symbol("callback");
-    var kBuffers = Symbol("buffers");
-    var kError = Symbol("error");
+    var kPerMessageDeflate = /* @__PURE__ */ Symbol("permessage-deflate");
+    var kTotalLength = /* @__PURE__ */ Symbol("total-length");
+    var kCallback = /* @__PURE__ */ Symbol("callback");
+    var kBuffers = /* @__PURE__ */ Symbol("buffers");
+    var kError = /* @__PURE__ */ Symbol("error");
     var zlibLimiter;
     var PerMessageDeflate2 = class {
       /**
@@ -1400,7 +1404,7 @@ var require_sender = __commonJS({
     var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
     var { isBlob, isValidStatusCode } = require_validation();
     var { mask: applyMask, toBuffer } = require_buffer_util();
-    var kByteLength = Symbol("kByteLength");
+    var kByteLength = /* @__PURE__ */ Symbol("kByteLength");
     var maskBuffer = Buffer.alloc(4);
     var RANDOM_POOL_SIZE = 8 * 1024;
     var randomPool;
@@ -1885,14 +1889,14 @@ var require_event_target = __commonJS({
   "node_modules/ws/lib/event-target.js"(exports, module) {
     "use strict";
     var { kForOnEventAttribute, kListener } = require_constants();
-    var kCode = Symbol("kCode");
-    var kData = Symbol("kData");
-    var kError = Symbol("kError");
-    var kMessage = Symbol("kMessage");
-    var kReason = Symbol("kReason");
-    var kTarget = Symbol("kTarget");
-    var kType = Symbol("kType");
-    var kWasClean = Symbol("kWasClean");
+    var kCode = /* @__PURE__ */ Symbol("kCode");
+    var kData = /* @__PURE__ */ Symbol("kData");
+    var kError = /* @__PURE__ */ Symbol("kError");
+    var kMessage = /* @__PURE__ */ Symbol("kMessage");
+    var kReason = /* @__PURE__ */ Symbol("kReason");
+    var kTarget = /* @__PURE__ */ Symbol("kTarget");
+    var kType = /* @__PURE__ */ Symbol("kType");
+    var kWasClean = /* @__PURE__ */ Symbol("kWasClean");
     var Event = class {
       /**
        * Create a new `Event`.
@@ -2294,7 +2298,7 @@ var require_websocket = __commonJS({
     } = require_event_target();
     var { format, parse } = require_extension();
     var { toBuffer } = require_buffer_util();
-    var kAborted = Symbol("kAborted");
+    var kAborted = /* @__PURE__ */ Symbol("kAborted");
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
@@ -3704,7 +3708,7 @@ var require_websocket_server = __commonJS({
 
 // hub-client.ts
 import { spawn } from "child_process";
-import { mkdirSync as mkdirSync2, openSync } from "fs";
+import { mkdirSync as mkdirSync2, openSync as openSync2 } from "fs";
 import { fileURLToPath } from "url";
 
 // node_modules/ws/wrapper.mjs
@@ -3823,17 +3827,50 @@ function escapeRegExp(value) {
 
 // runtime-files.ts
 import { randomBytes } from "crypto";
-import { chmodSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  existsSync as existsSync2,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
 import { dirname, join as join2 } from "path";
 var counter = 0;
 function atomicJson(path, value) {
-  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const directory = dirname(path);
+  mkdirSync(directory, { recursive: true, mode: 448 });
   const tmp = `${path}.tmp-${process.pid}-${counter++}`;
-  writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
-  renameSync(tmp, path);
   try {
+    const fd = openSync(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+    try {
+      writeFileSync(fd, JSON.stringify(value, null, 2) + "\n");
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(tmp, path);
     chmodSync(path, 384);
-  } catch {
+    try {
+      const dirFd = openSync(directory, constants.O_RDONLY);
+      try {
+        fsyncSync(dirFd);
+      } finally {
+        closeSync(dirFd);
+      }
+    } catch {
+    }
+  } catch (error) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
   }
 }
 function actorCredential(context, actor) {
@@ -3879,7 +3916,7 @@ async function ensureHub(context = loadCityContext()) {
   let endpoint = readEndpoint(context);
   if (endpoint && await healthy(endpoint)) return endpoint;
   const hub = fileURLToPath(new URL("./local-hub.js", import.meta.url));
-  const log = openSync(`${context.runtimeDir}/hub.log`, "a", 384);
+  const log = openSync2(`${context.runtimeDir}/hub.log`, "a", 384);
   const child = spawn(process.execPath, [hub, "--data", context.dataDir], {
     detached: true,
     stdio: ["ignore", log, log],
@@ -4155,7 +4192,7 @@ async function roadBusCli(args) {
   if (["help", "-h", "--help"].includes(verb)) {
     return {
       usage: "agents-city bus <roster | inbox | send owner/city text>",
-      note: "Only the seat can cross a road; repo agents are rejected by the bus ACL."
+      note: "Only the seat can cross a road. Inbox returns a bounded batch so a burst never becomes one model turn per message."
     };
   }
   if (verb === "roster") return busCommand("road.roster");

package/plugin/channel/delivery-queue.ts

@@ -1,13 +1,43 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'fs';
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+} from 'fs';
 import { join } from 'path';
 import { atomicJson } from './runtime-files.js';
 import { BusEnvelope, MAX_PENDING, MESSAGE_TTL_MS, safeSegment } from './protocol.js';
 
+export const ROAD_INBOX_BATCH_SIZE = 20;
+const DEFAULT_ROAD_INBOX_LIMIT = 500;
+const MAX_ROAD_INBOX_LIMIT = 10_000;
+const ROAD_INBOX_WAKE_FILE = 'road-inbox-wakeup.json';
+
+export interface RoadInboxStatus {
+  pending: number;
+  oldestAt: string | null;
+  notifiedAt: number;
+}
+
+export interface RoadInboxBatch {
+  messages: BusEnvelope[];
+  remaining: number;
+}
+
+export interface PendingRoadDelivery {
+  envelope: BusEnvelope;
+  queueFile: string;
+}
+
 export function enqueueForActor(runtimeDir: string, envelope: BusEnvelope): void {
   const directory = join(runtimeDir, 'outbox', safeSegment(envelope.to.actor));
   mkdirSync(directory, { recursive: true, mode: 0o700 });
-  trim(directory);
-  atomicJson(join(directory, `${fileKey(envelope.id)}.json`), envelope);
+  const path = join(directory, `${fileKey(envelope.id)}.json`);
+  requireCapacity(directory, path, MAX_PENDING, 'actor_outbox_full');
+  atomicJson(path, envelope);
 }
 
 export function pendingForActor(runtimeDir: string, actor: string): BusEnvelope[] {
@@ -45,18 +75,23 @@ export function acknowledge(runtimeDir: string, actor: string, envelopeId: strin
 export function queueRoad(runtimeDir: string, envelope: BusEnvelope): void {
   const directory = join(runtimeDir, 'road-queue');
   mkdirSync(directory, { recursive: true, mode: 0o700 });
-  trim(directory);
-  atomicJson(join(directory, `${fileKey(envelope.id)}.json`), envelope);
+  const path = join(directory, `${fileKey(envelope.id)}.json`);
+  requireCapacity(directory, path, MAX_PENDING, 'road_queue_full');
+  atomicJson(path, envelope);
 }
 
-export function drainRoadQueue(runtimeDir: string): BusEnvelope[] {
+export function pendingRoadQueue(runtimeDir: string): PendingRoadDelivery[] {
   const directory = join(runtimeDir, 'road-queue');
-  const out: BusEnvelope[] = [];
-  for (const path of jsonFiles(directory)) {
+  const out: PendingRoadDelivery[] = [];
+  for (const path of jsonFilesByAge(directory)) {
     try {
       const envelope = JSON.parse(readFileSync(path, 'utf8')) as BusEnvelope;
-      if (Date.now() - Date.parse(envelope.createdAt) <= MESSAGE_TTL_MS) out.push(envelope);
+      if (Date.now() - Date.parse(envelope.createdAt) <= MESSAGE_TTL_MS) {
+        out.push({ envelope, queueFile: path });
+        continue;
+      }
     } catch {}
+    // Malformed and explicitly expired queue entries are not retryable.
     try {
       unlinkSync(path);
     } catch {}
@@ -64,20 +99,75 @@ export function drainRoadQueue(runtimeDir: string): BusEnvelope[] {
   return out;
 }
 
-export function recordRoadInbox(runtimeDir: string, envelope: BusEnvelope): void {
+export function acknowledgeRoadQueue(queueFile: string): void {
+  try {
+    unlinkSync(queueFile);
+  } catch {}
+}
+
+export function recordRoadInbox(runtimeDir: string, envelope: BusEnvelope): boolean {
   const directory = join(runtimeDir, 'road-inbox');
+  const receipts = join(runtimeDir, 'road-receipts');
   mkdirSync(directory, { recursive: true, mode: 0o700 });
-  trim(directory);
-  atomicJson(join(directory, `${fileKey(envelope.id)}.json`), envelope);
-  appendFileSync(join(runtimeDir, 'road-history.jsonl'), JSON.stringify(envelope) + '\n', {
-    mode: 0o600,
-  });
+  mkdirSync(receipts, { recursive: true, mode: 0o700 });
+  const key = fileKey(envelope.id);
+  const receipt = join(receipts, `${key}.json`);
+  if (existsSync(receipt)) return false;
+  const inbox = join(directory, `${key}.json`);
+  // A crash before markRoadInboxAccepted may replay the relay frame. Preserve
+  // the one inbox record and let the router idempotently recreate its outbox
+  // entry. The remote ACK is sent only after that durable handoff completes.
+  const recovered = existsSync(inbox);
+  if (!recovered) {
+    requireCapacity(directory, inbox, roadInboxLimit(), 'road_inbox_full');
+    atomicJson(inbox, envelope);
+    appendFileSync(join(runtimeDir, 'road-history.jsonl'), JSON.stringify(envelope) + '\n', {
+      mode: 0o600,
+    });
+  }
+  return true;
+}
+
+export function markRoadInboxAccepted(runtimeDir: string, envelopeId: string): void {
+  const receipts = join(runtimeDir, 'road-receipts');
+  mkdirSync(receipts, { recursive: true, mode: 0o700 });
+  const key = fileKey(envelopeId);
+  const receipt = join(receipts, `${key}.json`);
+  if (existsSync(receipt)) return;
+  trimTo(receipts, 1_000);
+  atomicJson(receipt, { id: envelopeId, acceptedAt: new Date().toISOString() });
 }
 
-export function takeRoadInbox(runtimeDir: string): BusEnvelope[] {
+export function roadInboxStatus(runtimeDir: string): RoadInboxStatus {
+  const directory = join(runtimeDir, 'road-inbox');
+  const paths = jsonFilesByAge(directory);
+  let notifiedAt = 0;
+  try {
+    const state = JSON.parse(readFileSync(join(runtimeDir, ROAD_INBOX_WAKE_FILE), 'utf8')) as {
+      notifiedAt?: number;
+    };
+    if (Number.isSafeInteger(state.notifiedAt) && Number(state.notifiedAt) > 0) {
+      notifiedAt = Number(state.notifiedAt);
+    }
+  } catch {}
+  return {
+    pending: paths.length,
+    oldestAt: oldestTimestamp(paths),
+    notifiedAt,
+  };
+}
+
+export function markRoadInboxNotified(runtimeDir: string, notifiedAt = Date.now()): void {
+  atomicJson(join(runtimeDir, ROAD_INBOX_WAKE_FILE), { notifiedAt });
+}
+
+export function takeRoadInbox(runtimeDir: string, limit = ROAD_INBOX_BATCH_SIZE): RoadInboxBatch {
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > ROAD_INBOX_BATCH_SIZE) {
+    throw new Error('invalid_road_inbox_batch_size');
+  }
   const directory = join(runtimeDir, 'road-inbox');
   const out: BusEnvelope[] = [];
-  for (const path of jsonFiles(directory)) {
+  for (const path of jsonFilesByAge(directory).slice(0, limit)) {
     try {
       out.push(JSON.parse(readFileSync(path, 'utf8')) as BusEnvelope);
     } catch {}
@@ -85,7 +175,13 @@ export function takeRoadInbox(runtimeDir: string): BusEnvelope[] {
       unlinkSync(path);
     } catch {}
   }
-  return out;
+  const remaining = jsonFiles(directory).length;
+  if (!remaining) {
+    try {
+      unlinkSync(join(runtimeDir, ROAD_INBOX_WAKE_FILE));
+    } catch {}
+  }
+  return { messages: out, remaining };
 }
 
 function jsonFiles(directory: string): string[] {
@@ -100,6 +196,30 @@ function jsonFiles(directory: string): string[] {
   }
 }
 
+function jsonFilesByAge(directory: string): string[] {
+  return jsonFiles(directory).sort((left, right) => {
+    try {
+      const delta = statSync(left).mtimeMs - statSync(right).mtimeMs;
+      return delta || left.localeCompare(right);
+    } catch {
+      return left.localeCompare(right);
+    }
+  });
+}
+
+function oldestTimestamp(paths: string[]): string | null {
+  for (const path of paths) {
+    try {
+      return new Date(statSync(path).mtimeMs).toISOString();
+    } catch {
+      // A concurrent inbox read may remove the oldest entry between listing
+      // and stat. Continue to the next surviving item instead of failing a
+      // Road delivery that was already durably accepted.
+    }
+  }
+  return null;
+}
+
 function fileKey(value: string): string {
   const out = String(value)
     .replace(/[^a-zA-Z0-9_.-]+/g, '-')
@@ -108,9 +228,28 @@ function fileKey(value: string): string {
   return out;
 }
 
-function trim(directory: string): void {
-  const files = jsonFiles(directory);
-  for (const path of files.slice(0, Math.max(0, files.length - MAX_PENDING + 1))) {
+function roadInboxLimit(): number {
+  const configured = Number(process.env.CITY_ROAD_INBOX_MAX_PENDING);
+  return Number.isSafeInteger(configured) && configured >= ROAD_INBOX_BATCH_SIZE
+    ? Math.min(configured, MAX_ROAD_INBOX_LIMIT)
+    : DEFAULT_ROAD_INBOX_LIMIT;
+}
+
+function requireCapacity(directory: string, target: string, maximum: number, code: string): void {
+  if (existsSync(target)) return;
+  if (jsonFiles(directory).length >= maximum) throw new Error(code);
+}
+
+function trimTo(directory: string, maximum: number): void {
+  const files = jsonFiles(directory).sort((left, right) => {
+    try {
+      const delta = statSync(left).mtimeMs - statSync(right).mtimeMs;
+      return delta || left.localeCompare(right);
+    } catch {
+      return left.localeCompare(right);
+    }
+  });
+  for (const path of files.slice(0, Math.max(0, files.length - maximum + 1))) {
     try {
       unlinkSync(path);
     } catch {}

package/plugin/channel/hub/remote-roads.ts

@@ -1,8 +1,9 @@
 import WebSocket from 'ws';
 import { CityContext } from '../city-config.js';
 import { BUS_PROTOCOL, BusEnvelope, isoNow, randomId } from '../protocol.js';
+import { managedRoadBridge } from '../managed-connect/bridge.js';
 
-export function remoteRoadBridge(context: CityContext, receive: (envelope: BusEnvelope) => void) {
+function legacyRemoteRoadBridge(context: CityContext, receive: (envelope: BusEnvelope) => void) {
   const base = process.env.CITY_BUS_URL || '';
   const token = process.env.CITY_BUS_TOKEN || '';
   const enabled = Boolean(base && token);
@@ -148,6 +149,36 @@ export function remoteRoadBridge(context: CityContext, receive: (envelope: BusEn
   };
 }
 
+export function remoteRoadBridge(
+  context: CityContext,
+  receive: (envelope: BusEnvelope) => void,
+  receiveManaged?: (envelope: BusEnvelope) => { inserted: boolean },
+) {
+  const legacy = legacyRemoteRoadBridge(context, (envelope) => {
+    try {
+      receive(envelope);
+    } catch (error) {
+      console.error(`[city-bus] dropped remote envelope: ${(error as Error).message}`);
+    }
+  });
+  const managed = managedRoadBridge(context, receive, receiveManaged);
+  return {
+    start: () => {
+      legacy.start();
+      managed.start();
+    },
+    close: () => {
+      legacy.close();
+      managed.close();
+    },
+    send: (to: string, envelope: BusEnvelope) =>
+      managed.hasRoad(to) ? managed.send(to, envelope) : legacy.send(to, envelope),
+    enabled: () => legacy.enabled() || managed.enabled(),
+    online: (address: string) => managed.online(address) || legacy.online(address),
+    roads: managed.roads,
+  };
+}
+
 function legacyEnvelope(context: CityContext, from: string, body: string, id: string): BusEnvelope {
   return {
     protocol: BUS_PROTOCOL,

package/plugin/channel/hub/road-controller.ts

@@ -1,15 +1,48 @@
 import { ActorRole, BUS_PROTOCOL, BusEnvelope, isoNow, randomId, text } from '../protocol.js';
 import { CityContext } from '../city-config.js';
-import { recordRoadInbox, takeRoadInbox } from '../delivery-queue.js';
+import {
+  ROAD_INBOX_BATCH_SIZE,
+  markRoadInboxAccepted,
+  markRoadInboxNotified,
+  recordRoadInbox,
+  roadInboxStatus,
+  takeRoadInbox,
+} from '../delivery-queue.js';
 import { requireChair } from '../committee/guards.js';
+import { deliverApprovedReception, recordReceptionMessage } from '../reception.js';
 import { wrapUntrusted } from '../untrusted.js';
 import { EnvelopeRouter } from './envelopes.js';
 import { localRoadOnline, sendLocalRoad } from './local-roads.js';
 import { remoteRoadBridge } from './remote-roads.js';
+import { managedReceptionBridge } from '../managed-connect/reception-bridge.js';
 
 export function roadController(context: CityContext, router: EnvelopeRouter) {
-  const inbound = (envelope: BusEnvelope): void => {
-    const road = context.roads.find((candidate) => candidate.address === envelope.from.city);
+  const wakeIntervalMs = duration(
+    process.env.CITY_ROAD_INBOX_WAKE_INTERVAL_MS,
+    5 * 60_000,
+    30_000,
+    60 * 60_000,
+  );
+  const wakeCheckMs = Math.min(30_000, wakeIntervalMs);
+  const receptionCheckMs = duration(
+    process.env.CITY_RECEPTION_DELIVERY_INTERVAL_MS,
+    1_000,
+    250,
+    30_000,
+  );
+  let wakeTimer: ReturnType<typeof setInterval> | null = null;
+  let receptionTimer: ReturnType<typeof setInterval> | null = null;
+  let remote: ReturnType<typeof remoteRoadBridge>;
+  const reception = managedReceptionBridge(context);
+  const roads = () => {
+    const merged = [...context.roads, ...(remote?.roads() ?? [])];
+    return merged.filter(
+      (road, index) =>
+        merged.findIndex((candidate) => candidate.address === road.address) === index,
+    );
+  };
+  const validateInbound = (envelope: BusEnvelope): void => {
+    const road = roads().find((candidate) => candidate.address === envelope.from.city);
     if (!road) throw new Error(`there is no road from ${envelope.from.city}`);
     if (
       envelope.protocol !== BUS_PROTOCOL ||
@@ -20,6 +53,16 @@ export function roadController(context: CityContext, router: EnvelopeRouter) {
     ) {
       throw new Error('invalid road envelope');
     }
+  };
+  const inbound = (envelope: BusEnvelope): void => {
+    validateInbound(envelope);
+    // Managed traffic crosses a human boundary first. The raw text is durable
+    // in the owner-level local reception, but neither this city nor any model
+    // can read it through road.inbox until the Hall routes it explicitly.
+    if (envelope.payload?.transport === 'managed-e2ee') {
+      recordReceptionMessage(context, envelope);
+      return;
+    }
     // The body is untrusted text from another city: wrap it in an unforgeable
     // boundary and defang chat-template tokens before it can reach the seat's
     // context. Done once, here, so every inbound path (local and remote) and
@@ -37,19 +80,35 @@ export function roadController(context: CityContext, router: EnvelopeRouter) {
             },
           }
         : envelope;
-    recordRoadInbox(context.runtimeDir, guarded);
-    router.roadInbound(guarded);
+    const newlyRecorded = recordRoadInbox(context.runtimeDir, guarded);
+    notifyBacklog();
+    if (!newlyRecorded) return;
+    // The local/self-hosted transport may now return success: the inbox record
+    // and deduplication receipt are durable under one stable envelope id.
+    markRoadInboxAccepted(context.runtimeDir, guarded.id);
   };
-  const remote = remoteRoadBridge(context, (envelope) => {
-    try {
-      inbound(envelope);
-    } catch (error) {
-      console.error(`[city-bus] dropped remote envelope: ${(error as Error).message}`);
+  const inboundManaged = (envelope: BusEnvelope): { inserted: boolean } => {
+    validateInbound(envelope);
+    if (envelope.payload?.transport !== 'managed-e2ee') {
+      throw new Error('managed delivery contains a non-managed envelope');
     }
-  });
+    return recordReceptionMessage(context, envelope);
+  };
+  remote = remoteRoadBridge(context, inbound, inboundManaged);
+
+  const notifyBacklog = (): void => {
+    const status = roadInboxStatus(context.runtimeDir);
+    if (!status.pending || Date.now() - status.notifiedAt < wakeIntervalMs) return;
+    router.internal('road.inbox.ready', 'seat', 'chair', 'seat', null, {
+      pending: status.pending,
+      oldestAt: status.oldestAt,
+      batchSize: ROAD_INBOX_BATCH_SIZE,
+    });
+    markRoadInboxNotified(context.runtimeDir);
+  };
 
   const sendOne = async (to: string, body: string): Promise<string> => {
-    const road = context.roads.find((candidate) => candidate.address === to);
+    const road = roads().find((candidate) => candidate.address === to);
     if (!road) throw new Error(`no road from ${context.city.address} to ${to}`);
     const envelope: BusEnvelope = {
       protocol: BUS_PROTOCOL,
@@ -73,7 +132,7 @@ export function roadController(context: CityContext, router: EnvelopeRouter) {
   ): Promise<unknown> => {
     if (name === 'road.roster') {
       requireChair(actor, role);
-      return context.roads.map((road) => ({
+      return roads().map((road) => ({
         ...road,
         online: road.local ? localRoadOnline(context, road) : remote.online(road.address),
       }));
@@ -87,13 +146,54 @@ export function roadController(context: CityContext, router: EnvelopeRouter) {
     const to = text(payload.to, 'to');
     const body = text(payload.text, 'text');
     if (to !== '*') return { results: [await sendOne(to, body)] };
-    if (!context.roads.length) throw new Error('this city has no roads');
+    const currentRoads = roads();
+    if (!currentRoads.length) throw new Error('this city has no roads');
     const results: string[] = [];
-    for (const road of context.roads) results.push(await sendOne(road.address, body));
+    for (const road of currentRoads) results.push(await sendOne(road.address, body));
     return { results };
   };
 
-  return { command, inbound, start: remote.start, close: remote.close };
+  const start = (): void => {
+    remote.start();
+    reception.start();
+    deliverReception();
+    notifyBacklog();
+    receptionTimer = setInterval(deliverReception, receptionCheckMs);
+    receptionTimer.unref();
+    wakeTimer = setInterval(() => {
+      try {
+        notifyBacklog();
+      } catch (error) {
+        console.error(`[city-bus] Road inbox wake-up failed: ${(error as Error).message}`);
+      }
+    }, wakeCheckMs);
+    wakeTimer.unref();
+  };
+
+  const close = (): void => {
+    if (wakeTimer) clearInterval(wakeTimer);
+    if (receptionTimer) clearInterval(receptionTimer);
+    wakeTimer = null;
+    receptionTimer = null;
+    remote.close();
+    reception.close();
+  };
+
+  return { command, inbound, start, close };
+
+  function deliverReception(): void {
+    try {
+      const result = deliverApprovedReception(context);
+      if (result.delivered) notifyBacklog();
+    } catch (error) {
+      console.error(`[city-bus] Reception delivery failed: ${(error as Error).message}`);
+    }
+  }
 }
 
 export type RoadController = ReturnType<typeof roadController>;
+
+function duration(raw: string | undefined, fallback: number, minimum: number, maximum: number) {
+  const value = Number(raw);
+  return Number.isSafeInteger(value) && value >= minimum && value <= maximum ? value : fallback;
+}

package/plugin/channel/licenses/CONNECT_CLIENT_THIRD_PARTY_NOTICES.md

@@ -0,0 +1,21 @@
+# Third-party cryptography
+
+`@agents-city/connect-client` uses `@kinsh/vodozemac-wasm` 0.4.2 for its
+Olm Double Ratchet implementation. The binding and the underlying
+`matrix-org/vodozemac` library are licensed under Apache License 2.0.
+
+- Binding source: https://github.com/Meneleus/vodozemac-bindings
+- Cryptographic implementation: https://github.com/matrix-org/vodozemac
+- Independent vodozemac audit: https://leastauthority.com/blog/audit-of-vodozemac-library-for-matrix-org/
+- Licence text: `licenses/vodozemac-Apache-2.0.txt`
+
+No `libsignal` source or binary is linked, copied, vendored, or distributed.
+Signal's published protocol documents are used only as a security-properties
+reference. Agents City retains its Apache-2.0 licensing boundary.
+
+Persistent Node clients use `@napi-rs/keyring` 1.3.0 to keep the ratchet-state
+master key in macOS Keychain, Windows Credential Manager, or Linux Secret
+Service. The package is distributed under the MIT License.
+
+- Source: https://github.com/Brooooooklyn/keyring-node
+- Licence text: `licenses/keyring-MIT.txt`

package/plugin/channel/licenses/HYBRID_CRYPTO_THIRD_PARTY_NOTICES.md

@@ -0,0 +1,12 @@
+# Third-party notices
+
+- `libcrux-ml-kem 0.0.10`, Apache-2.0. ML-KEM-768 implementation from Cryspen/libcrux.
+- `aes-gcm 0.10.3`, Apache-2.0 OR MIT. RustCrypto authenticated encryption.
+- `hkdf 0.12.4`, Apache-2.0 OR MIT. RustCrypto HKDF.
+- `sha2 0.10.9`, Apache-2.0 OR MIT. RustCrypto SHA-2.
+- `wasm-bindgen 0.2.104`, Apache-2.0 OR MIT.
+- `zeroize 1.9.0`, Apache-2.0 OR MIT.
+- `serde_json 1.0.151`, Apache-2.0 OR MIT. Test-only NIST vector parser.
+
+Exact resolved transitive versions are pinned by `Cargo.lock`; licence
+validation is a blocking release gate.