harnery 0.42.0 → 0.44.0

package/src/core/hooks/shell-tokens.ts

@@ -0,0 +1,96 @@
+/** Shared, deliberately small shell lexer for PreToolUse command guards. */
+
+export interface Token {
+  value: string;
+  quoted: boolean;
+  operator?: boolean;
+}
+
+/** Keep quoted arguments opaque, including examples and heredoc bodies. */
+export function tokenize(source: string): Token[] {
+  const out: Token[] = [];
+  const heredocs: { end: string; tabs: boolean }[] = [];
+  for (let i = 0; i < source.length; ) {
+    const ch = source[i]!;
+    if (ch === "\\" && source[i + 1] === "\n") {
+      i += 2;
+      continue;
+    }
+    if (ch === "\n") {
+      out.push({ value: ";", quoted: false, operator: true });
+      i++;
+      for (const doc of heredocs.splice(0)) {
+        while (i < source.length) {
+          const end = source.indexOf("\n", i);
+          const stop = end === -1 ? source.length : end;
+          const line = source.slice(i, stop);
+          i = end === -1 ? source.length : end + 1;
+          if ((doc.tabs ? line.replace(/^\t+/, "") : line) === doc.end) break;
+        }
+      }
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === "#") {
+      const end = source.indexOf("\n", i);
+      i = end === -1 ? source.length : end;
+      continue;
+    }
+    if (";|&(){}<>".includes(ch)) {
+      const op = source.slice(i).match(/^(?:<<-?|>>|&&|\|\||[;|&(){}<>])/)![0];
+      out.push({ value: op, quoted: false, operator: true });
+      i += op.length;
+      continue;
+    }
+    let value = "";
+    let quoted = false;
+    while (i < source.length && !/[\s;|&(){}<>]/.test(source[i]!)) {
+      const next = source[i++]!;
+      if (next === "'" || next === '"' || next === "`") {
+        quoted = true;
+        while (i < source.length && source[i] !== next) {
+          if (source[i] === "\\" && next !== "'" && i + 1 < source.length) i++;
+          value += source[i++]!;
+        }
+        if (source[i] === next) i++;
+      } else if (next === "\\" && i < source.length) {
+        const escaped = source[i++]!;
+        if (escaped !== "\n") value += escaped;
+      } else {
+        value += next;
+      }
+    }
+    const previous = out.at(-1)?.value;
+    if (previous === "<<" || previous === "<<-") {
+      heredocs.push({ end: value, tabs: previous === "<<-" });
+    }
+    out.push({ value, quoted });
+  }
+  return out;
+}
+
+export function basename(value: string): string {
+  return value.split(/[\\/]/).at(-1) ?? value;
+}
+
+/** The command string of a Bash-style tool call, or null for any other tool. */
+export function shellCommandFromTool(toolName: unknown, toolInput: unknown): string | null {
+  if (typeof toolName !== "string") return null;
+  const name = toolName.toLowerCase().replace(/^functions\./, "");
+  if (!["bash", "shell", "shell_command", "exec_command"].includes(name)) return null;
+  let input = toolInput;
+  if (typeof input === "string") {
+    try {
+      input = JSON.parse(input);
+    } catch {
+      return null;
+    }
+  }
+  if (!input || typeof input !== "object") return null;
+  const args = input as Record<string, unknown>;
+  const command = args.command ?? args.cmd;
+  return typeof command === "string" ? command : null;
+}

package/src/core/hooks/shell-waiter.ts

@@ -1,3 +1,5 @@
+import { basename, shellCommandFromTool, tokenize } from "./shell-tokens.ts";
+
 /** Recognize inline waiters; this is not a proof of arbitrary shell termination. */
 const REASON =
   "Inline shell waiter blocked: polling loops and delayed log-only checks can outlive the job " +
@@ -6,82 +8,6 @@ const REASON =
   "nonzero timeout exit, and producer-exit/failure detection. Do not create another waiter " +
   "to check progress or infer completion from a broad pgrep -f pattern.";
 
-interface Token {
-  value: string;
-  quoted: boolean;
-  operator?: boolean;
-}
-
-/** Keep quoted arguments opaque, including examples and heredoc bodies. */
-function tokenize(source: string): Token[] {
-  const out: Token[] = [];
-  const heredocs: { end: string; tabs: boolean }[] = [];
-  for (let i = 0; i < source.length; ) {
-    const ch = source[i]!;
-    if (ch === "\\" && source[i + 1] === "\n") {
-      i += 2;
-      continue;
-    }
-    if (ch === "\n") {
-      out.push({ value: ";", quoted: false, operator: true });
-      i++;
-      for (const doc of heredocs.splice(0)) {
-        while (i < source.length) {
-          const end = source.indexOf("\n", i);
-          const stop = end === -1 ? source.length : end;
-          const line = source.slice(i, stop);
-          i = end === -1 ? source.length : end + 1;
-          if ((doc.tabs ? line.replace(/^\t+/, "") : line) === doc.end) break;
-        }
-      }
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      i++;
-      continue;
-    }
-    if (ch === "#") {
-      const end = source.indexOf("\n", i);
-      i = end === -1 ? source.length : end;
-      continue;
-    }
-    if (";|&(){}<>".includes(ch)) {
-      const op = source.slice(i).match(/^(?:<<-?|>>|&&|\|\||[;|&(){}<>])/)![0];
-      out.push({ value: op, quoted: false, operator: true });
-      i += op.length;
-      continue;
-    }
-    let value = "";
-    let quoted = false;
-    while (i < source.length && !/[\s;|&(){}<>]/.test(source[i]!)) {
-      const next = source[i++]!;
-      if (next === "'" || next === '"' || next === "`") {
-        quoted = true;
-        while (i < source.length && source[i] !== next) {
-          if (source[i] === "\\" && next !== "'" && i + 1 < source.length) i++;
-          value += source[i++]!;
-        }
-        if (source[i] === next) i++;
-      } else if (next === "\\" && i < source.length) {
-        const escaped = source[i++]!;
-        if (escaped !== "\n") value += escaped;
-      } else {
-        value += next;
-      }
-    }
-    const previous = out.at(-1)?.value;
-    if (previous === "<<" || previous === "<<-") {
-      heredocs.push({ end: value, tabs: previous === "<<-" });
-    }
-    out.push({ value, quoted });
-  }
-  return out;
-}
-
-function basename(value: string): string {
-  return value.split(/[\\/]/).at(-1) ?? value;
-}
-
 function isWaiter(source: string, depth = 0): boolean {
   if (depth > 8) return false;
   const tokens = tokenize(source);
@@ -148,19 +74,6 @@ function isWaiter(source: string, depth = 0): boolean {
 }
 
 export function shellWaiterReason(toolName: unknown, toolInput: unknown): string | null {
-  if (typeof toolName !== "string") return null;
-  const name = toolName.toLowerCase().replace(/^functions\./, "");
-  if (!["bash", "shell", "shell_command", "exec_command"].includes(name)) return null;
-  let input = toolInput;
-  if (typeof input === "string") {
-    try {
-      input = JSON.parse(input);
-    } catch {
-      return null;
-    }
-  }
-  if (!input || typeof input !== "object") return null;
-  const args = input as Record<string, unknown>;
-  const command = args.command ?? args.cmd;
-  return typeof command === "string" && isWaiter(command) ? REASON : null;
+  const command = shellCommandFromTool(toolName, toolInput);
+  return command !== null && isWaiter(command) ? REASON : null;
 }

package/src/core/inbox/contract.ts

@@ -19,7 +19,8 @@ export interface HarneryInboxMessageRecordV1 {
   schema: typeof HARNERY_INBOX_RECORD_SCHEMA;
   kind: "message";
   message_id: string;
-  sender_instance_id: string;
+  /** A required null identifies an operator; strings identify real agent instances. */
+  sender_instance_id: string | null;
   sender_display_name: string;
   recipient_instance_id: string;
   recipient_display_name: string;

package/src/core/inbox/index.ts

@@ -1,4 +1,6 @@
 export * from "./contract.ts";
 export * from "./lifecycle.ts";
+export * from "./peer-messages.ts";
 export * from "./service.ts";
+export * from "./targets.ts";
 export * from "./watcher.ts";

package/src/core/inbox/peer-messages.ts

@@ -0,0 +1,94 @@
+import { resolveBinName } from "../config.ts";
+import type { HarneryInboxLimits, HarneryInboxMessageRecordV1 } from "./contract.ts";
+import { HarneryInboxService } from "./service.ts";
+import { type MessageTargetInput, resolveMessageTarget } from "./targets.ts";
+
+const DAY = 24 * 60 * 60_000;
+
+/** Preserve the existing ping body/count bounds. Pending messages have no TTL;
+ * the lifecycle planner protects them through the idle finalization window. */
+export const PEER_INBOX_LIMITS: HarneryInboxLimits = {
+  max_message_body_bytes: 4_000,
+  max_pending_count: 25,
+  max_pending_bytes: 100_000,
+  max_history_bytes: 1024 * 1024,
+  max_history_records: 10_000,
+  warning_pressure_ratio: 0.8,
+  max_surface_count: 10,
+  max_surface_bytes: 16_000,
+  max_surface_tokens: 4_000,
+  surfaced_grace_ms: 7 * DAY,
+  terminal_grace_ms: 7 * DAY,
+};
+
+export function peerInbox(coordRoot: string): HarneryInboxService {
+  return new HarneryInboxService({ coord_root: coordRoot, limits: PEER_INBOX_LIMITS });
+}
+
+/** CLI and web use this one path. A receipt proves a synced append, never that
+ * a process is awake or that the recipient has noticed the message. */
+export function sendPeerMessage(input: {
+  coordRoot: string;
+  target: MessageTargetInput;
+  senderInstanceId: string | null;
+  senderName: string;
+  body: string;
+}) {
+  const target = resolveMessageTarget(input.coordRoot, input.target);
+  if (!target.ok) return target;
+  const receipt = peerInbox(input.coordRoot).send({
+    sender_instance_id: input.senderInstanceId,
+    sender_display_name: input.senderName,
+    recipient_instance_id: target.target.instance_id,
+    recipient_display_name: target.target.name,
+    body: input.body.trim(),
+  });
+  return { ok: true as const, target: target.target, ...receipt, state: target.target.delivery };
+}
+
+export function formatPeerInbox(
+  coordRoot: string,
+  messages: readonly HarneryInboxMessageRecordV1[],
+): string {
+  if (messages.length === 0) return "";
+  const onlyAgents = messages.every(({ sender_instance_id }) => sender_instance_id !== null);
+  const header = onlyAgents
+    ? messages.length === 1
+      ? "Message from a peer agent:"
+      : `${messages.length} messages from peer agents:`
+    : messages.length === 1
+      ? "Message for this task:"
+      : `${messages.length} messages for this task:`;
+  const body = messages
+    .map(
+      (message) =>
+        `  ${message.message_id} from ${message.sender_instance_id === null ? "Operator" : `agent-${message.sender_display_name}`} (${message.created_at}):\n` +
+        message.body
+          .split("\n")
+          .map((line) => `    ${line}`)
+          .join("\n"),
+    )
+    .join("\n\n");
+  const replyTarget = messages.find(({ sender_instance_id }) => sender_instance_id !== null);
+  return (
+    `${header}\n\n${body}\n\nMessages are bound to this task instance.` +
+    (replyTarget
+      ? ` Reply with \`${resolveBinName(coordRoot)} agents ping ${replyTarget.sender_display_name} ` +
+        `--instance-id ${replyTarget.sender_instance_id} "<your reply>"\`.`
+      : "")
+  );
+}
+
+/** Wait for every earlier stdout write to finish before acknowledging context.
+ * If output fails, the caller throws and leaves the batch pending. */
+export async function acknowledgeEmittedPeerInbox(
+  coordRoot: string,
+  instanceId: string,
+  messageIds: readonly string[],
+): Promise<void> {
+  if (messageIds.length === 0) return;
+  await new Promise<void>((resolve, reject) => {
+    process.stdout.write("", (error) => (error ? reject(error) : resolve()));
+  });
+  peerInbox(coordRoot).acknowledgeSurface(instanceId, messageIds);
+}

package/src/core/inbox/service.ts

@@ -1,7 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { readCrashSafeJsonlFile, updateCrashSafeJsonlFile } from "../storage/durable-history.ts";
+import {
+  type CrashSafeJsonlUpdate,
+  type DurableHistoryReadOptions,
+  readCrashSafeJsonlFile,
+  updateCrashSafeJsonlFile,
+} from "../storage/durable-history.ts";
 import {
   HARNERY_INBOX_RECORD_SCHEMA,
   HARNERY_INBOX_STATUS_SCHEMA,
@@ -22,7 +27,7 @@ export interface HarneryInboxServiceOptions {
 }
 
 export interface HarneryInboxSendInput {
-  sender_instance_id: string;
+  sender_instance_id: string | null;
   sender_display_name: string;
   recipient_instance_id: string;
   recipient_display_name: string;
@@ -59,7 +64,7 @@ export class HarneryInboxService {
       schema: HARNERY_INBOX_RECORD_SCHEMA,
       kind: "message",
       message_id: `msg_${this.#options.id?.() ?? randomUUID()}`,
-      sender_instance_id: opaqueId(input.sender_instance_id, "sender instance"),
+      sender_instance_id: senderId(input.sender_instance_id),
       sender_display_name: boundedDisplay(input.sender_display_name),
       recipient_instance_id: recipient,
       recipient_display_name: boundedDisplay(input.recipient_display_name),
@@ -68,7 +73,7 @@ export class HarneryInboxService {
       body_bytes: bodyBytes,
     };
     const path = inboxPath(this.#options.coord_root, recipient);
-    return updateCrashSafeJsonlFile<HarneryInboxRecordV1, HarneryInboxSendReceipt>(
+    return updateInboxHistory<HarneryInboxRecordV1, HarneryInboxSendReceipt>(
       path,
       readOptions(limits),
       (records) => {
@@ -88,10 +93,12 @@ export class HarneryInboxService {
   }
 
   records(recipientInstanceId: string): HarneryInboxRecordV1[] {
-    return readCrashSafeJsonlFile<HarneryInboxRecordV1>(
+    const records = readCrashSafeJsonlFile<HarneryInboxRecordV1>(
       inboxPath(this.#options.coord_root, opaqueId(recipientInstanceId, "recipient instance")),
       readOptions(this.#options.limits),
     );
+    for (const record of records) validateRecord(record);
+    return records;
   }
 
   pending(recipientInstanceId: string): HarneryInboxMessageRecordV1[] {
@@ -133,13 +140,45 @@ export class HarneryInboxService {
       max_tokens: this.#options.limits.max_surface_tokens,
     },
   ): Promise<HarneryInboxSurfaceResult> {
-    validateSurfaceBudget(budget);
     const recipient = opaqueId(recipientInstanceId, "recipient instance");
-    const selected = selectOldestFitting(this.pending(recipient), budget);
+    const selected = this.prepareSurface(recipient, budget);
     await emit(selected);
-    if (selected.length > 0) {
+    this.acknowledgeSurface(
+      recipient,
+      selected.map(({ message_id }) => message_id),
+    );
+    const remaining = this.pending(recipient);
+    return {
+      emitted: selected,
+      remaining_pending_count: remaining.length,
+      remaining_pending_bytes: remaining.reduce((sum, record) => sum + record.body_bytes, 0),
+      repeated_after_crash_possible: true,
+    };
+  }
+
+  /** Preparing prompt text is read-only. A failed or abandoned emission must
+   * leave the same messages pending for the recipient's next prompt. */
+  prepareSurface(
+    recipientInstanceId: string,
+    budget: HarneryInboxSurfaceBudget = {
+      max_count: this.#options.limits.max_surface_count,
+      max_bytes: this.#options.limits.max_surface_bytes,
+      max_tokens: this.#options.limits.max_surface_tokens,
+    },
+  ): HarneryInboxMessageRecordV1[] {
+    validateSurfaceBudget(budget);
+    return selectOldestFitting(this.pending(recipientInstanceId), budget);
+  }
+
+  /** Call only after the selected IDs have actually been emitted. A message
+   * appended while output is in flight remains pending rather than being
+   * included in an acknowledgement of an older batch. */
+  acknowledgeSurface(recipientInstanceId: string, messageIds: readonly string[]): void {
+    const recipient = opaqueId(recipientInstanceId, "recipient instance");
+    const selected = new Set(messageIds);
+    if (selected.size > 0) {
       const surfacedAt = now(this.#options).toISOString();
-      updateCrashSafeJsonlFile<HarneryInboxRecordV1, void>(
+      updateInboxHistory<HarneryInboxRecordV1, void>(
         inboxPath(this.#options.coord_root, recipient),
         readOptions(this.#options.limits),
         (records) => {
@@ -147,9 +186,9 @@ export class HarneryInboxService {
             project(records).pending.map(({ message_id }) => message_id),
           );
           return {
-            append: selected
-              .filter(({ message_id }) => stillPending.has(message_id))
-              .map(({ message_id }) => ({
+            append: [...selected]
+              .filter((message_id) => stillPending.has(message_id))
+              .map((message_id) => ({
                 schema: HARNERY_INBOX_RECORD_SCHEMA,
                 kind: "surfaced" as const,
                 message_id,
@@ -160,13 +199,32 @@ export class HarneryInboxService {
         },
       );
     }
-    const remaining = this.pending(recipient);
-    return {
-      emitted: selected,
-      remaining_pending_count: remaining.length,
-      remaining_pending_bytes: remaining.reduce((sum, record) => sum + record.body_bytes, 0),
-      repeated_after_crash_possible: true,
-    };
+  }
+}
+
+/** The shared writer refuses an occupied lease before invoking the update.
+ * Briefly retry only that exact refusal so concurrent peer senders both get
+ * a chance to append. All validation, authority and I/O failures still fail
+ * immediately, and an occupied live lease is never removed or overridden. */
+function updateInboxHistory<T, R>(
+  path: string,
+  options: DurableHistoryReadOptions,
+  update: (records: readonly T[]) => CrashSafeJsonlUpdate<R>,
+): R {
+  const deadline = performance.now() + 2_000;
+  const pause = new Int32Array(new SharedArrayBuffer(4));
+  while (true) {
+    try {
+      return updateCrashSafeJsonlFile(path, options, update);
+    } catch (error) {
+      if (
+        !(error instanceof Error) ||
+        error.message !== `durable history lease busy: ${path}.lease` ||
+        performance.now() >= deadline
+      )
+        throw error;
+      Atomics.wait(pause, 0, 0, Math.min(10, deadline - performance.now()));
+    }
   }
 }
 
@@ -270,10 +328,15 @@ function now(options: HarneryInboxServiceOptions): Date {
 }
 
 function opaqueId(value: string, field: string): string {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value)) throw new Error(`invalid ${field} id`);
+  if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value))
+    throw new Error(`invalid ${field} id`);
   return value;
 }
 
+function senderId(value: string | null): string | null {
+  return value === null ? null : opaqueId(value, "sender instance");
+}
+
 function boundedDisplay(value: string): string {
   const result = value.trim();
   if (result.length === 0 || Buffer.byteLength(result) > 256)
@@ -283,8 +346,11 @@ function boundedDisplay(value: string): string {
 
 function validateRecord(record: HarneryInboxRecordV1): void {
   if (record.schema !== HARNERY_INBOX_RECORD_SCHEMA) throw new Error("unknown inbox record schema");
-  if (record.kind === "message" && Buffer.byteLength(record.body) !== record.body_bytes) {
-    throw new Error(`inbox message ${record.message_id} has invalid body_bytes`);
+  if (record.kind === "message") {
+    senderId(record.sender_instance_id);
+    if (Buffer.byteLength(record.body) !== record.body_bytes) {
+      throw new Error(`inbox message ${record.message_id} has invalid body_bytes`);
+    }
   }
 }
 

package/src/core/inbox/targets.ts

@@ -0,0 +1,148 @@
+import { resolveName } from "../agents/state/names.ts";
+import { coordFreshnessSeconds } from "../config.ts";
+import {
+  type CoordinationGenerationViewV3,
+  type CoordinationViewV3,
+  readCoordinationViewV3,
+  requireAuthoritySafeCoordinationViewV3,
+} from "../events/v3/coordination-view.ts";
+import {
+  liveInstanceIdV3,
+  nativeInstanceIdV3,
+  observeLiveEventLedgerRouteV3,
+} from "../events/v3/live-route-observer.ts";
+
+export interface MessageTargetInput {
+  name?: string;
+  instanceId?: string;
+  requireLive?: boolean;
+  now?: Date;
+}
+
+export type MessageTargetResult =
+  | {
+      ok: true;
+      target: { instance_id: string; name: string; delivery: "written-live" | "queued" };
+    }
+  | {
+      ok: false;
+      code: "no_peer" | "ambiguous_peer" | "not_live" | "authority_unsafe";
+      message: string;
+      candidates?: string[];
+    };
+
+/** Resolve one immutable recipient without extending presence or claiming attention. */
+export function resolveMessageTarget(
+  coordRoot: string,
+  input: MessageTargetInput,
+): MessageTargetResult {
+  const requestedName = normalizeName(input.name);
+  const requestedInstance = input.instanceId?.trim();
+  if (!requestedName && !requestedInstance) {
+    return { ok: false, code: "no_peer", message: "Supply an exact agent name or instance id." };
+  }
+  const now = input.now?.getTime() ?? Date.now();
+  if (!Number.isFinite(now)) return unsafe("The message addressing clock is invalid.");
+
+  let view: CoordinationViewV3;
+  try {
+    if (observeLiveEventLedgerRouteV3(coordRoot).state === "blocked") {
+      return unsafe("The event ledger cannot establish message recipient authority.");
+    }
+    view = requireAuthoritySafeCoordinationViewV3(readCoordinationViewV3(coordRoot));
+    if (!view.source_complete) return unsafe("The event ledger read is incomplete.");
+  } catch {
+    return unsafe("The event ledger cannot establish message recipient authority.");
+  }
+
+  // Address historical instances without reopening them. A current generation
+  // wins over its own terminal history; otherwise use its last ledger position.
+  const byInstance = new Map<string, CoordinationGenerationViewV3>();
+  for (const generation of Object.values(view.terminal_generations)) {
+    const prior = byInstance.get(generation.instance_id);
+    if (!prior || laterPosition(generation, prior))
+      byInstance.set(generation.instance_id, generation);
+  }
+  for (const generation of Object.values(view.instances))
+    byInstance.set(generation.instance_id, generation);
+  const freshnessMs = coordFreshnessSeconds(coordRoot) * 1_000;
+  const candidates = [...byInstance.values()].flatMap((generation) => {
+    const instanceId = nativeInstanceIdV3(generation.instance_id);
+    const name = resolveName(coordRoot, instanceId)?.name;
+    if (!name) return [];
+    if (requestedInstance && liveInstanceIdV3(requestedInstance) !== generation.instance_id)
+      return [];
+    if (requestedName && normalizeName(name) !== requestedName) return [];
+    const age = now - Date.parse(generation.last_observed_at);
+    const diagnostics = view.diagnostics_by_generation[generation.generation_id] ?? [];
+    return [
+      {
+        instanceId,
+        name,
+        safe: !diagnostics.some((diagnostic) => diagnostic.authority_blocking),
+        fresh:
+          generation.phase === "live" && Number.isFinite(age) && age >= 0 && age <= freshnessMs,
+      },
+    ];
+  });
+
+  if (candidates.length === 0) {
+    return {
+      ok: false,
+      code: "no_peer",
+      message: "No known agent matches that exact name and instance.",
+    };
+  }
+  if (candidates.some((candidate) => !candidate.safe)) {
+    return unsafe("A matching agent generation does not have safe coordination authority.");
+  }
+  const fresh = candidates.filter((candidate) => candidate.fresh);
+  const selected = requestedInstance ? candidates : fresh.length > 0 ? fresh : candidates;
+  if (selected.length !== 1) {
+    return {
+      ok: false,
+      code: "ambiguous_peer",
+      message: "Several agent instances hold that exact name; specify --instance-id.",
+      candidates: selected.map(({ instanceId }) => instanceId).sort(),
+    };
+  }
+  const target = selected[0]!;
+  if (input.requireLive && !target.fresh) {
+    return {
+      ok: false,
+      code: "not_live",
+      message:
+        "That agent is known but outside live presence; omit --require-live to queue its message.",
+    };
+  }
+  return {
+    ok: true,
+    target: {
+      instance_id: target.instanceId,
+      name: target.name,
+      delivery: target.fresh ? "written-live" : "queued",
+    },
+  };
+}
+
+function laterPosition(
+  left: CoordinationGenerationViewV3,
+  right: CoordinationGenerationViewV3,
+): boolean {
+  return (
+    left.source_position.segment_ordinal > right.source_position.segment_ordinal ||
+    (left.source_position.segment_ordinal === right.source_position.segment_ordinal &&
+      left.source_position.byte_offset > right.source_position.byte_offset)
+  );
+}
+
+function normalizeName(name: string | undefined): string {
+  return (name ?? "")
+    .trim()
+    .replace(/^agent-/i, "")
+    .toLowerCase();
+}
+
+function unsafe(message: string): MessageTargetResult {
+  return { ok: false, code: "authority_unsafe", message };
+}

package/src/core/inbox/watcher.ts

@@ -23,14 +23,13 @@ export async function* watchInbox(
 
 function delay(ms: number, signal: AbortSignal): Promise<void> {
   return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    signal.addEventListener(
-      "abort",
-      () => {
-        clearTimeout(timer);
-        resolve();
-      },
-      { once: true },
-    );
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", finish, { once: true });
+    if (signal.aborted) finish();
   });
 }