machine-bridge-mcp 2.0.0 → 3.0.0-beta.102

package/src/worker/pending-call-contract.ts

@@ -1,26 +1,63 @@
+import type { AuthorityRevocation } from "../shared/authority-revocation.mjs";
+import type { DaemonChannel } from "./daemon-channel.ts";
+
+export type PendingCallOutcome =
+  | { ok: true; value: unknown }
+  | { ok: false; error: Error };
+
+export type PendingCallSettlement = {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+};
+
+export class PendingCallRegistrationError extends Error {
+  readonly code: "conflict" | "limit_exceeded";
+  readonly retryable: boolean;
+  constructor(code: "conflict" | "limit_exceeded", message: string, retryable = false) {
+    super(message);
+    this.name = "PendingCallRegistrationError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+}
+
 export interface PendingCallRecord {
   id: string;
-  socket?: WebSocket;
+  socket?: DaemonChannel;
   daemonInstanceId?: string;
   reconnectTimeout?: ReturnType<typeof setTimeout>;
+  reconnectDeadlineAt?: number;
+  onReconnectTimeout?: (record: PendingCallRecord) => Error;
   clientRequestKey?: string;
+  owner_kind?: "account";
+  owner_account_id?: string;
+  owner_account_version?: number;
+  owner_client_id?: string;
+  owner_family_id?: string;
   tool: string;
+  recovery?: Record<string, unknown>;
   startedAt: number;
-  timeout: ReturnType<typeof setTimeout>;
-  resolve: (value: unknown) => void;
-  reject: (error: Error) => void;
+  timeout?: ReturnType<typeof setTimeout>;
+  deadlineAt: number;
+  remainingTimeoutMs: number;
+  onTimeout: (record: PendingCallRecord) => Error;
+  redeliverAfterProvenMissing?: (record: PendingCallRecord, channel: DaemonChannel) => boolean;
+  settlement: PendingCallSettlement;
   signal?: AbortSignal;
   abortHandler?: () => void;
 }
 
 export interface RegisterPendingCall {
   id: string;
-  socket: WebSocket;
+  socket: DaemonChannel;
   daemonInstanceId?: string;
   clientRequestKey?: string;
+  authority?: AuthorityRevocation;
   tool: string;
+  recovery?: Record<string, unknown>;
   timeoutMs: number;
   onTimeout: (record: PendingCallRecord) => Error;
+  redeliverAfterProvenMissing?: (record: PendingCallRecord, channel: DaemonChannel) => boolean;
   signal?: AbortSignal;
   onAbort?: (record: PendingCallRecord) => Error;
 }

package/src/worker/pending-call-deadlines.ts

@@ -0,0 +1,75 @@
+import type { PendingCallRecord } from "./pending-call-contract.ts";
+
+type TimerHandle = ReturnType<typeof setTimeout>;
+export type PendingCallDeadlineOptions = {
+  now?: () => number;
+  scheduler?: {
+    setTimeout: (callback: () => void, delay: number) => TimerHandle;
+    clearTimeout: (handle: TimerHandle) => void;
+  };
+};
+
+export class PendingCallDeadlines {
+  private readonly clock: () => number;
+  private readonly scheduler: Required<PendingCallDeadlineOptions>["scheduler"];
+
+  constructor(options: PendingCallDeadlineOptions = {}) {
+    this.clock = options.now ?? (() => performance.now());
+    this.scheduler = options.scheduler ?? { setTimeout, clearTimeout };
+  }
+
+  now(): number {
+    return this.clock();
+  }
+
+  nextDelayMs(record: PendingCallRecord): number {
+    const deadline = record.socket ? record.deadlineAt : record.reconnectDeadlineAt;
+    return Number.isFinite(deadline) ? Math.max(0, Number(deadline) - this.clock()) : Number.POSITIVE_INFINITY;
+  }
+
+  isDue(record: PendingCallRecord, now = this.clock()): boolean {
+    const deadline = record.socket ? record.deadlineAt : record.reconnectDeadlineAt;
+    return Number.isFinite(deadline) && Number(deadline) <= now;
+  }
+
+  armOperation(record: PendingCallRecord, delayMs: number, expire: (id: string) => void): void {
+    if (record.timeout) this.scheduler.clearTimeout(record.timeout);
+    const delay = boundedPendingDelayMs(delayMs);
+    record.remainingTimeoutMs = delay;
+    record.deadlineAt = this.clock() + delay;
+    record.timeout = this.scheduler.setTimeout(() => expire(record.id), delay);
+  }
+
+  pauseOperation(record: PendingCallRecord): void {
+    record.remainingTimeoutMs = Math.max(1, Math.ceil(record.deadlineAt - this.clock()));
+    if (record.timeout) this.scheduler.clearTimeout(record.timeout);
+    record.timeout = undefined;
+  }
+
+  armReconnect(record: PendingCallRecord, delayMs: number, expire: (id: string) => void): void {
+    if (record.reconnectTimeout) this.scheduler.clearTimeout(record.reconnectTimeout);
+    const delay = boundedPendingDelayMs(delayMs);
+    record.reconnectDeadlineAt = this.clock() + delay;
+    record.reconnectTimeout = this.scheduler.setTimeout(() => expire(record.id), delay);
+  }
+
+  clearReconnect(record: PendingCallRecord): void {
+    if (record.reconnectTimeout) this.scheduler.clearTimeout(record.reconnectTimeout);
+    record.reconnectTimeout = undefined;
+    record.reconnectDeadlineAt = undefined;
+  }
+
+  clear(record: PendingCallRecord): void {
+    if (record.timeout) this.scheduler.clearTimeout(record.timeout);
+    if (record.reconnectTimeout) this.scheduler.clearTimeout(record.reconnectTimeout);
+    record.reconnectDeadlineAt = undefined;
+  }
+}
+
+export function boundedPendingDelayMs(value: unknown, maximum = 2_147_483_647): number {
+  if (!Number.isSafeInteger(maximum) || maximum < 1) throw new TypeError("pending-call delay maximum must be a positive safe integer");
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    throw new RangeError(`pending-call delay must be an integer from 1 to ${maximum}`);
+  }
+  return value;
+}

package/src/worker/pending-calls.ts

@@ -1,173 +1,179 @@
-import type { PendingCallRecord, RegisterPendingCall } from "./pending-call-contract.ts";
-
-export class PendingCallRegistrationError extends Error {
-  readonly code: "conflict" | "limit_exceeded";
-  readonly retryable: boolean;
-
-  constructor(code: "conflict" | "limit_exceeded", message: string, retryable = false) {
-    super(message);
-    this.name = "PendingCallRegistrationError";
-    this.code = code;
-    this.retryable = retryable;
-  }
-}
-
+import { toolCallAdmission, toolCallCapacityConfig, type ToolCallCapacityConfig } from "../shared/tool-call-capacity.mjs";
+import relayContract from "../shared/relay-contract.json" with { type: "json" };
+import { PendingCallRegistrationError, type PendingCallOutcome, type PendingCallRecord, type PendingCallSettlement, type RegisterPendingCall } from "./pending-call-contract.ts";
+import { boundedPendingDelayMs, PendingCallDeadlines, type PendingCallDeadlineOptions } from "./pending-call-deadlines.ts";
+import { pendingRegistrySnapshot } from "./pending-call-capacity.ts";
+import { recordMatchesAuthorityRevocation, type AuthorityRevocation } from "../shared/authority-revocation.mjs";
+import type { DaemonChannel } from "./daemon-channel.ts";
+type PendingCallRegistryOptions = PendingCallDeadlineOptions & {
+  reservedCapacity?: number;
+  reservedTools?: Iterable<string>;
+};
 export class PendingCallRegistry {
-  private readonly maximum: number;
+  private readonly capacity: ToolCallCapacityConfig;
   private readonly byId = new Map<string, PendingCallRecord>();
   private readonly byRequestKey = new Map<string, string>();
-
-  constructor(maximum: number) {
-    this.maximum = maximum;
+  private readonly deadlines: PendingCallDeadlines;
+  constructor(maximum: number, options: PendingCallRegistryOptions = {}) {
+    this.capacity = toolCallCapacityConfig(maximum, options.reservedCapacity, options.reservedTools);
+    this.deadlines = new PendingCallDeadlines(options);
   }
-
-  get size(): number {
-    return this.byId.size;
+  get size(): number { return this.byId.size; } hasRequestKey(requestKey?: string): boolean { return Boolean(requestKey && this.byRequestKey.has(requestKey)); }
+  resultOwnership(id: string, socket: DaemonChannel): "owned" | "missing" | "stale" {
+    const record = this.byId.get(id); return !record ? "missing" : record.socket === socket ? "owned" : "stale";
   }
-
-  hasRequestKey(requestKey?: string): boolean {
-    return Boolean(requestKey && this.byRequestKey.has(requestKey));
+  nextDeadlineDelayMs(): number { return Math.min(Number.POSITIVE_INFINITY, ...[...this.byId.values()].map((record) => this.deadlines.nextDelayMs(record))); }
+  async expireDue(now = this.deadlines.now()): Promise<number> {
+    const due = [...this.byId.values()].filter((record) => this.deadlines.isDue(record, now));
+    let expired = 0;
+    for (const record of due) expired += Number(await this.expireRecord(record));
+    return expired;
   }
 
   register(input: RegisterPendingCall): Promise<unknown> {
-    if (this.byId.size >= this.maximum) throw new PendingCallRegistrationError("limit_exceeded", "too many concurrent daemon tool calls", true);
-    if (this.byId.has(input.id)) throw new PendingCallRegistrationError("conflict", "duplicate internal daemon call id");
-    if (input.clientRequestKey && this.byRequestKey.has(input.clientRequestKey)) {
-      throw new PendingCallRegistrationError("conflict", "duplicate in-flight JSON-RPC request id within this MCP session");
-    }
-    const startedAt = performance.now();
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        const record = this.take(input.id);
-        if (!record) return;
-        let error: unknown;
-        try { error = input.onTimeout(record); }
-        catch { error = new Error("pending daemon call timed out"); }
-        reject(error instanceof Error ? error : new Error("pending daemon call timed out"));
-      }, input.timeoutMs);
-      const abortHandler = () => {
-        const record = this.take(input.id);
-        if (!record) return;
-        let error: unknown;
-        try { error = input.onAbort?.(record); }
-        catch { error = new Error("pending daemon call was cancelled"); }
-        reject(error instanceof Error ? error : new Error("pending daemon call was cancelled"));
-      };
-      const record: PendingCallRecord = {
-        id: input.id,
-        socket: input.socket,
-        daemonInstanceId: input.daemonInstanceId,
-        clientRequestKey: input.clientRequestKey,
-        tool: String(input.tool || "unknown"),
-        startedAt,
-        timeout,
-        resolve,
-        reject,
-        signal: input.signal,
-        abortHandler: input.signal ? abortHandler : undefined,
-      };
-      this.byId.set(input.id, record);
-      if (input.clientRequestKey) this.byRequestKey.set(input.clientRequestKey, input.id);
-      if (input.signal?.aborted) abortHandler();
-      else input.signal?.addEventListener("abort", abortHandler, { once: true });
-    });
+    this.assertCanRegister(input);
+    let resolveResult!: (value: unknown) => void;
+    let rejectResult!: (error: Error) => void;
+    const result = new Promise<unknown>((resolve, reject) => { resolveResult = resolve; rejectResult = reject; });
+    this.add(input, { resolve: resolveResult, reject: rejectResult });
+    return result;
   }
-
-  resolve(id: string, socket: WebSocket, value: unknown): boolean {
-    const record = this.byId.get(id);
-    if (!record || record.socket !== socket) return false;
-    this.take(id)?.resolve(value);
-    return true;
+  resolve(id: string, socket: DaemonChannel, value: unknown): Promise<boolean> {
+    const record = this.byId.get(id); return !record || record.socket !== socket ? Promise.resolve(false) : this.finish(id, { ok: true, value });
+  }
+  reject(id: string, error: Error, socket?: DaemonChannel): Promise<boolean> {
+    const record = this.byId.get(id); return !record || (socket && record.socket !== socket) ? Promise.resolve(false) : this.finish(id, { ok: false, error });
   }
 
-  reject(id: string, error: Error, socket?: WebSocket): boolean {
-    const record = this.byId.get(id);
-    if (!record || (socket && record.socket !== socket)) return false;
-    this.take(id)?.reject(error);
-    return true;
+  async cancelRequest(requestKey: string, onCancel: (record: PendingCallRecord) => Error): Promise<boolean> {
+    const id = this.byRequestKey.get(requestKey); return id ? this.fail(id, onCancel, "pending daemon call was cancelled") : false;
   }
 
-  cancelRequest(requestKey: string, onCancel: (record: PendingCallRecord) => Error): boolean {
-    const id = this.byRequestKey.get(requestKey);
-    if (!id) return false;
-    const record = this.take(id);
-    if (!record) return false;
-    record.reject(onCancel(record));
-    return true;
+  async cancelAuthority(revocation: AuthorityRevocation, onCancel: (record: PendingCallRecord) => Error): Promise<number> {
+    const ids = [...this.byId.values()].filter((record) => recordMatchesAuthorityRevocation(record, revocation)).map((record) => record.id);
+    let cancelled = 0;
+    for (const id of ids) cancelled += Number(await this.fail(id, onCancel, "pending daemon authority was revoked"));
+    return cancelled;
   }
 
-  rejectSocket(socket: WebSocket, createError: (record: PendingCallRecord) => Error): number {
+  async rejectSocket(socket: DaemonChannel, createError: (record: PendingCallRecord) => Error): Promise<number> {
     const ids = [...this.byId.values()].filter((record) => record.socket === socket).map((record) => record.id);
+    return this.rejectSocketIds(ids, socket, createError, "pending daemon call failed");
+  }
+
+  async rejectSocketIds(ids: Iterable<string>, socket: DaemonChannel, createError: (record: PendingCallRecord) => Error, fallback = "pending daemon call was not received", beforeReject?: (record: PendingCallRecord) => boolean): Promise<number> {
+    let rejected = 0;
     for (const id of ids) {
-      const record = this.take(id);
-      if (record) record.reject(createError(record));
+      const record = this.byId.get(id); if (record?.socket === socket && beforeReject?.(record) !== true) rejected += Number(await this.fail(id, createError, fallback));
     }
-    return ids.length;
+    return rejected;
   }
 
-  detachSocket(
-    socket: WebSocket,
-    graceMs: number,
-    createError: (record: PendingCallRecord) => Error,
-  ): number {
+  detachSocket(socket: DaemonChannel, graceMs: number, createError: (record: PendingCallRecord) => Error): number {
     const records = [...this.byId.values()].filter((record) => record.socket === socket);
-    const delay = Math.max(1, Math.floor(Number(graceMs) || 1));
+    const maximumGrace = boundedPendingDelayMs(graceMs, relayContract.reconnectGraceMs);
     for (const record of records) {
       record.socket = undefined;
-      if (record.reconnectTimeout) clearTimeout(record.reconnectTimeout);
-      record.reconnectTimeout = setTimeout(() => {
-        const current = this.byId.get(record.id);
-        if (!current || current.socket) return;
-        const expired = this.take(record.id);
-        if (expired) expired.reject(createError(expired));
-      }, delay);
+      record.onReconnectTimeout = createError;
+      this.deadlines.pauseOperation(record);
+      const delay = Math.min(maximumGrace, record.remainingTimeoutMs);
+      this.deadlines.armReconnect(record, delay, (id) => { void this.expireReconnect(id); });
     }
     return records.length;
   }
 
-  rebindInstance(daemonInstanceId: string, socket: WebSocket): string[] {
+  rebindInstance(daemonInstanceId: string, socket: DaemonChannel): string[] {
     if (!daemonInstanceId) return [];
     const rebound: string[] = [];
     for (const record of this.byId.values()) {
-      if (record.socket || record.daemonInstanceId !== daemonInstanceId) continue;
-      if (record.reconnectTimeout) clearTimeout(record.reconnectTimeout);
-      record.reconnectTimeout = undefined;
+      if (record.daemonInstanceId !== daemonInstanceId || record.socket === socket) continue;
+      if (record.socket) this.deadlines.pauseOperation(record);
+      else this.deadlines.clearReconnect(record);
+      const remainingTimeoutMs = Math.max(1, Math.ceil(record.deadlineAt - this.deadlines.now()));
+      record.onReconnectTimeout = undefined;
       record.socket = socket;
+      this.deadlines.armOperation(record, remainingTimeoutMs, (id) => { void this.expireOperation(id); });
       rebound.push(record.id);
     }
     return rebound;
   }
 
-  snapshot(): { active: number; detached: number; request_keys: number; maximum: number; oldest_ms: number; by_tool: Record<string, number> } {
-    const now = performance.now();
-    const byTool: Record<string, number> = {};
-    let detached = 0;
-    let oldestMs = 0;
-    for (const record of this.byId.values()) {
-      byTool[record.tool] = (byTool[record.tool] || 0) + 1;
-      if (!record.socket) detached += 1;
-      oldestMs = Math.max(oldestMs, now - record.startedAt);
+  snapshot() {
+    return pendingRegistrySnapshot(this.byId.values(), this.byRequestKey.size, this.deadlines.now(), this.capacity);
+  }
+
+  private assertCanRegister(input: RegisterPendingCall): void {
+    const snapshot = this.snapshot();
+    const decision = toolCallAdmission({ active: snapshot.active, byTool: snapshot.by_tool }, this.capacity, input.tool);
+    if (!decision.allowed) {
+      const message = decision.reason === "ordinary_capacity"
+        ? `ordinary daemon-call capacity reached (${decision.ordinaryMaximum}); control-plane capacity is reserved for diagnosis and recovery`
+        : "too many concurrent daemon tool calls";
+      throw new PendingCallRegistrationError("limit_exceeded", message, true);
     }
-    return {
-      active: this.byId.size,
-      detached,
-      request_keys: this.byRequestKey.size,
-      maximum: this.maximum,
-      oldest_ms: oldestMs,
-      by_tool: byTool,
+    if (this.byId.has(input.id)) throw new PendingCallRegistrationError("conflict", "duplicate internal daemon call id");
+    if (input.clientRequestKey && this.byRequestKey.has(input.clientRequestKey)) {
+      throw new PendingCallRegistrationError("conflict", "duplicate in-flight response-stream request key");
+    }
+  }
+
+  private add(input: RegisterPendingCall, settlement: PendingCallSettlement): void {
+    const startedAt = this.deadlines.now();
+    const timeoutMs = boundedPendingDelayMs(input.timeoutMs, relayContract.maximumRelayToolTimeoutMs);
+    const abortHandler = input.signal ? () => { void this.expire(input.id, input.onAbort, "pending daemon call was cancelled"); } : undefined;
+    const record: PendingCallRecord = {
+      id: input.id, socket: input.socket, daemonInstanceId: input.daemonInstanceId, clientRequestKey: input.clientRequestKey,
+      ...(input.authority ? {
+        owner_kind: "account" as const, owner_account_id: input.authority.accountId,
+        owner_account_version: input.authority.accountVersion, owner_client_id: input.authority.clientId,
+        owner_family_id: input.authority.familyId,
+      } : {}),
+      tool: String(input.tool || "unknown"), ...(input.recovery ? { recovery: input.recovery } : {}),
+      startedAt, deadlineAt: startedAt + timeoutMs, remainingTimeoutMs: timeoutMs,
+      onTimeout: input.onTimeout, redeliverAfterProvenMissing: input.redeliverAfterProvenMissing, settlement, signal: input.signal, abortHandler,
     };
+    this.byId.set(input.id, record);
+    if (input.clientRequestKey) this.byRequestKey.set(input.clientRequestKey, input.id);
+    this.deadlines.armOperation(record, timeoutMs, (id) => { void this.expireOperation(id); });
+    if (input.signal?.aborted) void this.expire(input.id, input.onAbort, "pending daemon call was cancelled");
+    else if (input.signal && abortHandler) input.signal.addEventListener("abort", abortHandler, { once: true });
   }
 
+  private expireOperation(id: string): Promise<boolean> { return this.expireRecord(this.byId.get(id)); }
+  private expireReconnect(id: string): Promise<boolean> {
+    const record = this.byId.get(id); return record && !record.socket ? this.expireRecord(record) : Promise.resolve(false);
+  }
+  private expireRecord(record?: PendingCallRecord): Promise<boolean> {
+    if (!record) return Promise.resolve(false);
+    return record.socket
+      ? this.fail(record.id, record.onTimeout, "pending daemon call timed out")
+      : this.fail(record.id, record.onReconnectTimeout, "pending daemon reconnect expired");
+  }
+  private expire(id: string, createError: ((record: PendingCallRecord) => Error) | undefined, fallback: string): Promise<boolean> {
+    const record = this.byId.get(id);
+    const applicable = record && (fallback.includes("reconnect") ? !record.socket : true);
+    return applicable ? this.fail(id, createError, fallback) : Promise.resolve(false);
+  }
+  private async fail(id: string, createError: ((record: PendingCallRecord) => Error) | undefined, fallback: string): Promise<boolean> {
+    const record = this.byId.get(id);
+    if (!record) return false;
+    let error: Error;
+    try { error = createError?.(record) ?? new Error(fallback); } catch { error = new Error(fallback); }
+    return this.finish(id, { ok: false, error });
+  }
+  private async finish(id: string, outcome: PendingCallOutcome): Promise<boolean> {
+    const record = this.take(id);
+    if (!record) return false;
+    outcome.ok ? record.settlement.resolve(outcome.value) : record.settlement.reject(outcome.error);
+    return true;
+  }
   private take(id: string): PendingCallRecord | undefined {
     const record = this.byId.get(id);
     if (!record) return undefined;
-    clearTimeout(record.timeout);
-    if (record.reconnectTimeout) clearTimeout(record.reconnectTimeout);
+    this.deadlines.clear(record);
     if (record.signal && record.abortHandler) record.signal.removeEventListener("abort", record.abortHandler);
     this.byId.delete(id);
-    if (record.clientRequestKey && this.byRequestKey.get(record.clientRequestKey) === id) {
-      this.byRequestKey.delete(record.clientRequestKey);
-    }
+    if (record.clientRequestKey && this.byRequestKey.get(record.clientRequestKey) === id) this.byRequestKey.delete(record.clientRequestKey);
     return record;
   }
 }

package/src/worker/runtime-alarm-storage.ts

@@ -0,0 +1,37 @@
+export interface AlarmStorage {
+  getAlarm(): Promise<number | null>;
+  setAlarm(scheduledTime: number | Date): Promise<void>;
+  deleteAlarm(): Promise<void>;
+}
+
+export async function writeEarliestRuntimeAlarm(input: {
+  storage: AlarmStorage;
+  nextDeadline: number;
+  now: number;
+  onError: (error: unknown) => void;
+  onMutation?: (action: "set" | "delete" | "noop") => void;
+  currentAlarm?: number | null;
+}): Promise<void> {
+  try {
+    const current = input.currentAlarm === undefined ? await input.storage.getAlarm() : input.currentAlarm;
+    if (!Number.isFinite(input.nextDeadline)) {
+      if (current === null) {
+        input.onMutation?.("noop");
+        return;
+      }
+      await input.storage.deleteAlarm();
+      input.onMutation?.("delete");
+      return;
+    }
+    const target = Math.max(input.now, input.nextDeadline);
+    if (current !== null && current > input.now && current <= target) {
+      input.onMutation?.("noop");
+      return;
+    }
+    await input.storage.setAlarm(target);
+    input.onMutation?.("set");
+  } catch (error) {
+    try { input.onError(error); }
+    catch { /* Alarm persistence already failed; observer failure cannot repair that storage outcome. */ }
+  }
+}

package/src/worker/runtime-alarm.ts

@@ -0,0 +1,136 @@
+import { DAEMON_HELLO_TIMEOUT_MS, daemonLivenessDeadlineMs, daemonReadyDeadlineMs } from "./daemon-liveness.ts";
+import type { DaemonChannel } from "./daemon-channel.ts";
+import type { DaemonRegistry } from "./daemon-registry.ts";
+import type { PendingCallRegistry } from "./pending-calls.ts";
+import { writeEarliestRuntimeAlarm, type AlarmStorage } from "./runtime-alarm-storage.ts";
+
+type InvalidateDaemonSocket = (
+  socket: WebSocket,
+  message: string,
+  closeReason: string,
+  errorCode?: string,
+) => Promise<void>;
+interface RuntimeAlarmContext {
+  storage: AlarmStorage;
+  pending: PendingCallRegistry;
+  daemonRegistry: DaemonRegistry;
+  invalidateDaemonSocket: InvalidateDaemonSocket;
+  invalidateDaemonChannel: (channel: DaemonChannel, message: string, errorCode?: string) => Promise<void>;
+  onScheduleError: (error: unknown) => void;
+  onAlarmMutation?: (action: "set" | "delete" | "noop") => void;
+}
+export async function processRuntimeAlarm(context: RuntimeAlarmContext, now = Date.now()): Promise<void> {
+  await context.pending.expireDue();
+  let nextDeadline = Number.POSITIVE_INFINITY;
+  for (const socket of context.daemonRegistry.candidateSockets()) {
+    const attachment = context.daemonRegistry.attachment(socket);
+    const connectedAt = Date.parse(attachment?.connectedAt ?? "");
+    const deadline = connectedAt + DAEMON_HELLO_TIMEOUT_MS;
+    if (!Number.isFinite(connectedAt) || deadline <= now) {
+      await context.invalidateDaemonSocket(
+        socket,
+        "daemon did not complete authentication",
+        "daemon hello timeout",
+        "daemon_hello_timeout",
+      );
+      continue;
+    }
+    nextDeadline = Math.min(nextDeadline, deadline);
+  }
+  for (const socket of context.daemonRegistry.probingSockets()) {
+    const attachment = context.daemonRegistry.attachment(socket);
+    const readyDeadline = daemonReadyDeadlineMs(attachment);
+    const liveDeadline = daemonLivenessDeadlineMs(attachment);
+    if (!Number.isFinite(readyDeadline) || !Number.isFinite(liveDeadline) || Math.min(readyDeadline, liveDeadline) <= now) {
+      await context.invalidateDaemonSocket(
+        socket,
+        "daemon did not complete end-to-end readiness verification",
+        "daemon ready timeout",
+        "daemon_ready_timeout",
+      );
+      continue;
+    }
+    nextDeadline = Math.min(nextDeadline, readyDeadline, liveDeadline);
+  }
+  for (const socket of context.daemonRegistry.readyRoleSockets()) {
+    const deadline = daemonLivenessDeadlineMs(context.daemonRegistry.readyAttachment(socket));
+    if (!Number.isFinite(deadline) || deadline <= now) {
+      await context.invalidateDaemonSocket(socket, "daemon became unresponsive", "daemon liveness timeout");
+      continue;
+    }
+    nextDeadline = Math.min(nextDeadline, deadline);
+  }
+  if (context.daemonRegistry.http) {
+    context.daemonRegistry.httpCandidates(now);
+    for (const channel of context.daemonRegistry.http.staleOwned(now)) {
+      await context.invalidateDaemonChannel(channel, "HTTPS fallback became unresponsive", "daemon_liveness_timeout");
+    }
+    nextDeadline = Math.min(nextDeadline, context.daemonRegistry.http.nextDeadline(now));
+  }
+  nextDeadline = Math.min(nextDeadline, pendingAlarmDeadline(context, now));
+  await writeEarliestRuntimeAlarm({
+    storage: context.storage,
+    nextDeadline,
+    now,
+    onError: context.onScheduleError,
+    onMutation: context.onAlarmMutation,
+  });
+}
+export async function scheduleRuntimeAlarm(context: RuntimeAlarmContext, now = Date.now()): Promise<void> {
+  try {
+    let nextDeadline = Number.POSITIVE_INFINITY;
+    for (const socket of context.daemonRegistry.candidateSockets()) {
+      const connectedAt = Date.parse(context.daemonRegistry.attachment(socket)?.connectedAt ?? "");
+      if (!Number.isFinite(connectedAt)) {
+        await context.invalidateDaemonSocket(
+          socket,
+          "daemon candidate timestamp is invalid",
+          "invalid daemon candidate timestamp",
+          "daemon_hello_timeout",
+        );
+        continue;
+      }
+      nextDeadline = Math.min(nextDeadline, connectedAt + DAEMON_HELLO_TIMEOUT_MS);
+    }
+    for (const socket of context.daemonRegistry.probingSockets()) {
+      const attachment = context.daemonRegistry.attachment(socket);
+      const readyDeadline = daemonReadyDeadlineMs(attachment);
+      const liveDeadline = daemonLivenessDeadlineMs(attachment);
+      if (!Number.isFinite(readyDeadline) || !Number.isFinite(liveDeadline)) {
+        await context.invalidateDaemonSocket(
+          socket,
+          "daemon readiness state is invalid",
+          "daemon ready timeout",
+          "daemon_ready_timeout",
+        );
+        continue;
+      }
+      nextDeadline = Math.min(nextDeadline, readyDeadline, liveDeadline);
+    }
+    for (const socket of context.daemonRegistry.readyRoleSockets()) {
+      const deadline = daemonLivenessDeadlineMs(context.daemonRegistry.readyAttachment(socket));
+      if (!Number.isFinite(deadline)) {
+        await context.invalidateDaemonSocket(socket, "daemon became unresponsive", "invalid daemon liveness timestamp");
+        continue;
+      }
+      nextDeadline = Math.min(nextDeadline, deadline);
+    }
+    if (context.daemonRegistry.http) {
+      context.daemonRegistry.httpCandidates(now);
+      nextDeadline = Math.min(nextDeadline, context.daemonRegistry.http.nextDeadline(now));
+    }
+    const currentAlarm = await context.storage.getAlarm();
+    nextDeadline = Math.min(nextDeadline, pendingAlarmDeadline(context, now));
+    await writeEarliestRuntimeAlarm({
+      storage: context.storage, nextDeadline, now, currentAlarm,
+      onError: context.onScheduleError, onMutation: context.onAlarmMutation,
+    });
+  } catch (error) {
+    try { context.onScheduleError(error); }
+    catch { /* The error observer must not recursively fail the Durable Object alarm callback. */ }
+  }
+}
+function pendingAlarmDeadline(context: RuntimeAlarmContext, now: number): number {
+  const delay = context.pending.nextDeadlineDelayMs();
+  return Number.isFinite(delay) ? now + Math.max(1, Math.ceil(delay)) : Number.POSITIVE_INFINITY;
+}

package/src/worker/server-info-activity.ts

@@ -0,0 +1,36 @@
+export function workerGlobalActivityVisible(authorization: { account_role_is_owner?: unknown }): boolean {
+  return authorization.account_role_is_owner === true;
+}
+
+export function hiddenWorkerPending(value: Record<string, unknown>): Record<string, unknown> {
+  return {
+    maximum: value.maximum ?? 0,
+    ordinary_capacity: value.ordinary_capacity ?? 0,
+    reserved_capacity: value.reserved_capacity ?? 0,
+    activity_hidden_by_authority: true,
+  };
+}
+
+export function hiddenWorkerActivity(): Record<string, unknown> {
+  return { activity_hidden_by_authority: true };
+}
+
+export function projectDaemonStatus(value: Record<string, unknown>, fullToolNamesVisible: boolean): Record<string, unknown> {
+  if (fullToolNamesVisible) return value;
+  return {
+    connected: value.connected ?? false,
+    count: value.count ?? 0,
+    tool_count: value.tool_count ?? 0,
+    connected_at: value.connected_at ?? null,
+    last_seen_at: value.last_seen_at ?? null,
+    readiness_verified: value.readiness_verified ?? false,
+    readiness_timeout_ms: value.readiness_timeout_ms ?? null,
+    liveness_timeout_ms: value.liveness_timeout_ms ?? null,
+    policy: value.policy ?? null,
+    policy_scope: value.policy_scope ?? "daemon_capability_ceiling_not_account_authority",
+    tools: [],
+    tools_scope: value.tools_scope ?? "daemon_advertised_before_account_role_filtering",
+    tools_hidden_by_authority: true,
+    relay_transport: value.relay_transport ?? null,
+  };
+}