@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-intercom/broker/broker.ts

@@ -1,9 +1,9 @@
 import net from "net";
-import { chmodSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { chmodSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomBytes, randomUUID } from "crypto";
 import { writeMessage, createMessageReader } from "./framing.ts";
-import { isMessage, isMessageReceipt, isSessionId, isSessionRegistration } from "./protocol.ts";
+import { isMessage, isMessageReceipt, isSessionId, isSessionInfo, isSessionRegistration, messageDeliveryFingerprint } from "./protocol.ts";
 import {
   ensureIntercomRuntimeDir,
   getBrokerListenTarget,
@@ -22,12 +22,17 @@ import { EXACT_SEND_FEATURE, EXTENSION_BUS_FEATURE } from "../types.ts";
 import type { DeliveryState, SessionInfo, Message, BrokerMessage, ExtensionCapability, MessageControl } from "../types.ts";
 import { ExtensionStateManager } from "./extension-state.ts";
 import { assertNoLiveBroker } from "./runtime-claim.ts";
+import { resolveHerdrLocations } from "../herdr-location.ts";
 
 const INTERCOM_DIR = getIntercomDirPath();
 const LISTEN_TARGET = getBrokerListenTarget();
 const PID_PATH = join(INTERCOM_DIR, "broker.pid");
 const PORT_PATH = getBrokerPortFilePath(INTERCOM_DIR);
 const PENDING_ASKS_DIR = join(INTERCOM_DIR, "pending-asks");
+const MAILBOX_DIR = join(INTERCOM_DIR, "mailbox");
+const DISCONNECTED_SESSIONS_DIR = join(INTERCOM_DIR, "disconnected-sessions");
+const PERSISTED_RECORD_VERSION = 1;
+const MAX_PERSISTED_ID_FILENAME_CHARS = 100;
 const BROKER_STATE_ID = randomUUID();
 const MAX_SESSIONS = 128;
 const MAX_UNREGISTERED_CONNECTIONS = 32;
@@ -62,6 +67,9 @@ interface ConnectedSession {
   lastPresenceBroadcastAt: number;
   ownerOrder: number;
   extensions?: ExtensionCapability[];
+  /** Stable Pi session identity used only for live Herdr snapshot joins. This
+   * is a self-asserted local-client hint, not authenticated location evidence. */
+  herdrSessionPath?: string;
 }
 
 interface DeliveryRecord {
@@ -199,12 +207,113 @@ function ensurePendingAskRecordDir(): void {
   }
 }
 
+function sha256Hex(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+// One file per queued message. The sender key is part of the name because
+// message ids are only unique per sender (delivery records key on both).
+function mailboxFilePath(scopeId: string | undefined, fromKey: string, messageId: string): string {
+  const scopePart = scopeId ? sha256Hex(scopeId).slice(0, 16) : "global";
+  const encodedId = encodeURIComponent(messageId);
+  const idPart = encodedId.length <= MAX_PERSISTED_ID_FILENAME_CHARS ? encodedId : sha256Hex(messageId);
+  return join(MAILBOX_DIR, `${scopePart}-${sha256Hex(fromKey).slice(0, 16)}-${idPart}.json`);
+}
+
+function disconnectedSessionFilePath(sessionKey: string): string {
+  return join(DISCONNECTED_SESSIONS_DIR, `${sha256Hex(sessionKey)}.json`);
+}
+
+function ensureRuntimeDir(dirPath: string): void {
+  mkdirSync(dirPath, { recursive: true, mode: INTERCOM_DIR_MODE });
+  if (process.platform !== "win32") {
+    chmodSync(dirPath, INTERCOM_DIR_MODE);
+  }
+}
+
+// Temp file + rename so a crash mid-write never leaves a half-written record.
+// Temp names end in .tmp (never .json) so loaders ignore and sweep them.
+function writeFileAtomic(filePath: string, content: string): void {
+  const tempPath = `${filePath}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tempPath, content, { mode: INTERCOM_RUNTIME_FILE_MODE });
+    restrictIntercomRuntimeFile(tempPath);
+    renameSync(tempPath, filePath);
+  } catch (error) {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+      // The temp file may never have been created.
+    }
+    throw error;
+  }
+}
+
+function isOptionalString(value: unknown): value is string | undefined {
+  return value === undefined || typeof value === "string";
+}
+
+function parseMailboxRecord(value: unknown): MailboxMessage | null {
+  if (!isRecord(value) || value.version !== PERSISTED_RECORD_VERSION) {
+    return null;
+  }
+  if (
+    !isSessionInfo(value.from)
+    || typeof value.fromKey !== "string"
+    || !isOptionalString(value.fromScopeId)
+    || !isSessionInfo(value.target)
+    || typeof value.targetKey !== "string"
+    || !isOptionalString(value.targetScopeId)
+    || !isMessage(value.message)
+    || !Number.isSafeInteger(value.queuedAt)
+  ) {
+    return null;
+  }
+  // Blocking asks are never queued; a record claiming otherwise is not ours.
+  if (value.message.expectsReply) {
+    return null;
+  }
+  return {
+    from: value.from,
+    fromKey: value.fromKey,
+    ...(value.fromScopeId ? { fromScopeId: value.fromScopeId } : {}),
+    target: value.target,
+    targetKey: value.targetKey,
+    ...(value.targetScopeId ? { targetScopeId: value.targetScopeId } : {}),
+    message: value.message,
+    queuedAt: value.queuedAt as number,
+  };
+}
+
+function parseDisconnectedSessionRecord(value: unknown): DisconnectedSession | null {
+  if (!isRecord(value) || value.version !== PERSISTED_RECORD_VERSION) {
+    return null;
+  }
+  if (
+    typeof value.key !== "string"
+    || !isSessionInfo(value.info)
+    || !isOptionalString(value.scopeId)
+    || !Number.isSafeInteger(value.disconnectedAt)
+  ) {
+    return null;
+  }
+  return {
+    info: value.info,
+    key: value.key,
+    ...(value.scopeId ? { scopeId: value.scopeId } : {}),
+    disconnectedAt: value.disconnectedAt as number,
+  };
+}
+
 class IntercomBroker {
   private sessions = new Map<string, ConnectedSession>();
   private askEdges = new Map<string, AskEdge>();
   private messageReceiptRoutes = new Map<string, MessageReceiptRoute>();
   private disconnectedSessions = new Map<string, DisconnectedSession>();
   private mailboxMessages: MailboxMessage[] = [];
+  // Where each queued message is persisted, so removal deletes the exact file
+  // it was loaded from or written to.
+  private mailboxFilePaths = new WeakMap<MailboxMessage, string>();
   private deliveryRecords = new Map<string, DeliveryRecord>();
   private connections = new Set<net.Socket>();
   private unregisteredConnections = new Set<net.Socket>();
@@ -220,6 +329,8 @@ class IntercomBroker {
     assertNoLiveBroker(PID_PATH);
     ensurePendingAskRecordDir();
     this.prunePendingAskRecords();
+    this.loadDisconnectedSessions();
+    this.loadMailboxMessages();
     this.extensionStateManager = new ExtensionStateManager(INTERCOM_DIR);
     if (typeof LISTEN_TARGET === "string" && process.platform !== "win32") {
       try {
@@ -473,6 +584,7 @@ class IntercomBroker {
           lastActivity: session.lastActivity,
           ...(session.status !== undefined ? { status: session.status } : {}),
           ...(session.tmuxPane !== undefined ? { tmuxPane: session.tmuxPane } : {}),
+          ...(session.herdrPaneId !== undefined ? { herdrPaneId: session.herdrPaneId } : {}),
           trustedLocal: typeof LISTEN_TARGET === "string" && process.platform !== "win32",
         };
 
@@ -484,9 +596,10 @@ class IntercomBroker {
           lastPresenceBroadcastAt: Date.now(),
           ownerOrder: previous?.ownerOrder ?? this.nextOwnerOrder++,
           extensions,
+          ...(session.herdrSessionPath ? { herdrSessionPath: session.herdrSessionPath } : {}),
         };
         this.sessions.set(key, connectedSession);
-        this.disconnectedSessions.delete(key);
+        this.forgetDisconnectedSession(key);
         
         if (this.shutdownTimer) {
           clearTimeout(this.shutdownTimer);
@@ -596,7 +709,26 @@ class IntercomBroker {
         const sessions = Array.from(this.sessions.values())
           .filter(session => sameScope(session.scopeId, requester.scopeId))
           .map(s => s.info);
-        writeMessage(socket, { type: "sessions", requestId: clientMessage.requestId, sessions });
+        const requestId = clientMessage.requestId;
+        // Resolve all hosted panes from one bounded live snapshot. Never retain
+        // the result: moved panes must be re-resolved by the next list request.
+        const herdrSessionPaths = new Map(
+          Array.from(this.sessions.values())
+            .filter(session => sameScope(session.scopeId, requester.scopeId) && session.herdrSessionPath)
+            .map(session => [session.info.id, session.herdrSessionPath!] as const),
+        );
+        void resolveHerdrLocations(sessions, { sessionPaths: herdrSessionPaths })
+          .then((resolvedSessions) => writeMessage(socket, { type: "sessions", requestId, sessions: resolvedSessions }))
+          .catch((cause) => {
+            const detail = cause instanceof Error ? cause.message : String(cause);
+            const fallback = sessions.map((session) => ({
+              ...session,
+              herdrLocation: session.herdrPaneId
+                ? { status: "unavailable" as const, paneId: session.herdrPaneId, reason: "command_failed" as const, detail }
+                : { status: "not_hosted" as const },
+            }));
+            writeMessage(socket, { type: "sessions", requestId, sessions: fallback });
+          });
         break;
       }
 
@@ -819,7 +951,8 @@ class IntercomBroker {
         const sender = this.sessions.get(currentKey);
         const queuedIndex = this.mailboxMessages.findIndex(entry => entry.message.id === clientMessage.messageId && entry.fromKey === currentKey);
         if (queuedIndex >= 0 && sender?.socket === socket) {
-          this.mailboxMessages.splice(queuedIndex, 1);
+          const [cancelled] = this.mailboxMessages.splice(queuedIndex, 1);
+          this.removeMailboxFile(cancelled!);
           this.updateDeliveryRecord(currentKey, clientMessage.messageId, "failed", "Sender cancelled the queued delivery", "E_DELIVERY_CANCELLED");
           const edge = this.askEdges.get(clientMessage.messageId);
           if (edge?.from === currentKey) {
@@ -976,20 +1109,153 @@ class IntercomBroker {
   }
 
   private rememberDisconnectedSession(session: ConnectedSession, now = Date.now()): void {
-    this.disconnectedSessions.set(session.key, {
+    const remembered: DisconnectedSession = {
       info: { ...session.info },
       key: session.key,
       ...(session.scopeId ? { scopeId: session.scopeId } : {}),
       disconnectedAt: now,
-    });
+    };
+    this.disconnectedSessions.set(session.key, remembered);
+    this.persistDisconnectedSession(remembered);
     this.pruneDisconnectedSessions(now);
   }
 
+  private forgetDisconnectedSession(sessionKey: string): void {
+    if (this.disconnectedSessions.delete(sessionKey)) {
+      this.removePersistedFile(disconnectedSessionFilePath(sessionKey), "disconnected session");
+    }
+  }
+
   private pruneDisconnectedSessions(now = Date.now()): void {
     for (const [sessionId, session] of this.disconnectedSessions) {
       if (now - session.disconnectedAt > DISCONNECTED_SESSION_RETENTION_MS) {
-        this.disconnectedSessions.delete(sessionId);
+        this.forgetDisconnectedSession(sessionId);
+      }
+    }
+  }
+
+  // Persistence is best effort: a full disk or bad permissions must never break
+  // live delivery, so failures are logged and the broker keeps going in memory.
+  private persistDisconnectedSession(session: DisconnectedSession): void {
+    try {
+      mkdirSync(DISCONNECTED_SESSIONS_DIR, { recursive: true, mode: INTERCOM_DIR_MODE });
+      const record = { version: PERSISTED_RECORD_VERSION, ...session };
+      writeFileAtomic(disconnectedSessionFilePath(session.key), `${JSON.stringify(record, null, 2)}\n`);
+    } catch (error) {
+      console.error("Failed to persist disconnected intercom session:", error);
+    }
+  }
+
+  private persistMailboxMessage(entry: MailboxMessage): void {
+    try {
+      mkdirSync(MAILBOX_DIR, { recursive: true, mode: INTERCOM_DIR_MODE });
+      const filePath = mailboxFilePath(entry.fromScopeId, entry.fromKey, entry.message.id);
+      const record = { version: PERSISTED_RECORD_VERSION, ...entry };
+      writeFileAtomic(filePath, `${JSON.stringify(record, null, 2)}\n`);
+      this.mailboxFilePaths.set(entry, filePath);
+    } catch (error) {
+      console.error("Failed to persist intercom mailbox message:", error);
+    }
+  }
+
+  /** Call at every place an entry leaves `mailboxMessages` (never on shutdown). */
+  private removeMailboxFile(entry: MailboxMessage): void {
+    const filePath = this.mailboxFilePaths.get(entry) ?? mailboxFilePath(entry.fromScopeId, entry.fromKey, entry.message.id);
+    this.mailboxFilePaths.delete(entry);
+    this.removePersistedFile(filePath, "mailbox message");
+  }
+
+  private removePersistedFile(filePath: string, label: string): void {
+    try {
+      unlinkSync(filePath);
+    } catch (error) {
+      if (!isRecord(error) || error.code !== "ENOENT") {
+        console.error(`Failed to remove persisted intercom ${label}:`, error);
+      }
+    }
+  }
+
+  /**
+   * Reads every `*.json` record in `dirPath`, deleting corrupt, invalid and
+   * (via `isExpired`) stale files. Leftover `*.tmp` files from an interrupted
+   * atomic write are swept. Never throws: an unreadable directory just means
+   * nothing is restored.
+   */
+  private loadPersistedRecords<T>(
+    dirPath: string,
+    label: string,
+    parse: (value: unknown) => T | null,
+    isExpired: (record: T) => boolean,
+  ): Array<{ record: T; filePath: string }> {
+    const loaded: Array<{ record: T; filePath: string }> = [];
+    try {
+      ensureRuntimeDir(dirPath);
+      for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+        if (!entry.isFile()) {
+          continue;
+        }
+        const filePath = join(dirPath, entry.name);
+        if (entry.name.endsWith(".tmp")) {
+          this.removePersistedFile(filePath, label);
+          continue;
+        }
+        if (!entry.name.endsWith(".json")) {
+          continue;
+        }
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+        } catch {
+          this.removePersistedFile(filePath, label);
+          continue;
+        }
+        const record = parse(parsed);
+        if (!record || isExpired(record)) {
+          this.removePersistedFile(filePath, label);
+          continue;
+        }
+        loaded.push({ record, filePath });
+      }
+    } catch (error) {
+      console.error(`Failed to load persisted intercom ${label}s:`, error);
+    }
+    return loaded;
+  }
+
+  private loadDisconnectedSessions(now = Date.now()): void {
+    const loaded = this.loadPersistedRecords(
+      DISCONNECTED_SESSIONS_DIR,
+      "disconnected session",
+      parseDisconnectedSessionRecord,
+      (session) => now - session.disconnectedAt > DISCONNECTED_SESSION_RETENTION_MS,
+    );
+    for (const { record, filePath } of loaded) {
+      const existing = this.disconnectedSessions.get(record.key);
+      if (existing && existing.disconnectedAt >= record.disconnectedAt) {
+        this.removePersistedFile(filePath, "disconnected session");
+        continue;
       }
+      this.disconnectedSessions.set(record.key, record);
+    }
+  }
+
+  private loadMailboxMessages(now = Date.now()): void {
+    const loaded = this.loadPersistedRecords(
+      MAILBOX_DIR,
+      "mailbox message",
+      parseMailboxRecord,
+      (entry) => now - entry.queuedAt > MAILBOX_MESSAGE_RETENTION_MS,
+    );
+    // Array.prototype.sort is stable, so equal timestamps keep directory order.
+    loaded.sort((a, b) => a.record.queuedAt - b.record.queuedAt);
+    // Same bound as live queueing: keep the newest, drop the oldest.
+    const overflow = Math.max(0, loaded.length - MAX_MAILBOX_MESSAGES);
+    for (const { filePath } of loaded.slice(0, overflow)) {
+      this.removePersistedFile(filePath, "mailbox message");
+    }
+    for (const { record, filePath } of loaded.slice(overflow)) {
+      this.mailboxFilePaths.set(record, filePath);
+      this.mailboxMessages.push(record);
     }
   }
 
@@ -1004,6 +1270,7 @@ class IntercomBroker {
         this.messageReceiptRoutes.delete(entry.message.id);
         this.updateDeliveryRecord(entry.fromKey, entry.message.id, "failed", "Mailbox delivery expired", "E_DELIVERY_EXPIRED");
         this.mailboxMessages.splice(index, 1);
+        this.removeMailboxFile(entry);
       }
     }
   }
@@ -1013,6 +1280,7 @@ class IntercomBroker {
     while (this.mailboxMessages.length >= MAX_MAILBOX_MESSAGES) {
       const evicted = this.mailboxMessages.shift();
       if (!evicted) break;
+      this.removeMailboxFile(evicted);
       if (evicted.message.expectsReply) {
         this.askEdges.delete(evicted.message.id);
         this.removePendingAskRecord(evicted.message.id, evicted.fromScopeId);
@@ -1020,7 +1288,7 @@ class IntercomBroker {
       this.messageReceiptRoutes.delete(evicted.message.id);
       this.updateDeliveryRecord(evicted.fromKey, evicted.message.id, "failed", "Mailbox capacity evicted the delivery", "E_DELIVERY_EVICTED");
     }
-    this.mailboxMessages.push({
+    const queued: MailboxMessage = {
       from: { ...from.info },
       fromKey: from.key,
       ...(from.scopeId ? { fromScopeId: from.scopeId } : {}),
@@ -1029,7 +1297,9 @@ class IntercomBroker {
       ...(target.scopeId ? { targetScopeId: target.scopeId } : {}),
       message: { ...message, brokerReceivedAt },
       queuedAt: brokerReceivedAt,
-    });
+    };
+    this.mailboxMessages.push(queued);
+    this.persistMailboxMessage(queued);
   }
 
   private writeDeliverySuccess(socket: net.Socket, messageId: string, delivery: "socket_delivered" | "queued"): void {
@@ -1041,16 +1311,7 @@ class IntercomBroker {
   }
 
   private deliveryFingerprint(message: Message, targetId: string): string {
-    return JSON.stringify({
-      targetId,
-      text: message.content.text,
-      attachments: message.content.attachments,
-      replyTo: message.replyTo,
-      expectsReply: message.expectsReply,
-      supersedes: message.supersedes,
-      retryOf: message.retryOf,
-      provenance: message.provenance,
-    });
+    return messageDeliveryFingerprint(message, targetId);
   }
 
   private deliveryRecordKey(fromSessionId: string, messageId: string): string {
@@ -1141,6 +1402,9 @@ class IntercomBroker {
       }
 
       this.mailboxMessages.splice(index, 1);
+      // Drop the file before the socket write: a failed write already loses the
+      // in-memory entry, so keeping the file would only risk a duplicate later.
+      this.removeMailboxFile(entry);
       const edge = this.askEdges.get(entry.message.id);
       if (edge?.to === entry.targetKey) {
         edge.to = session.key;
@@ -1173,11 +1437,25 @@ class IntercomBroker {
     }
   }
 
-  private clearAskEdgesForSession(sessionKey: string): void {
+  /**
+   * Intentionally NOT called on disconnect/unregister: edges age out via
+   * `pruneAskEdges`, and a late reply to a disconnected asker is mailboxed on
+   * purpose so a resumed asker (or target) still receives it.
+   * `asker`: drop asks this session was waiting on. `target`: drop asks
+   * addressed to this session.
+   */
+  private clearAskEdgesForSession(sessionKey: string, role: "asker" | "target" | "either"): void {
     for (const [messageId, edge] of this.askEdges) {
-      if (edge.from === sessionKey || edge.to === sessionKey) {
-        this.askEdges.delete(messageId);
+      const matches = (role !== "target" && edge.from === sessionKey) || (role !== "asker" && edge.to === sessionKey);
+      if (!matches) {
+        continue;
+      }
+      this.askEdges.delete(messageId);
+      try {
         this.removePendingAskRecord(messageId, edge.scopeId);
+      } catch (error) {
+        // Disconnect cleanup must not throw out of a socket event handler.
+        console.error("Failed to remove pending ask record:", error);
       }
     }
   }
@@ -1694,6 +1972,8 @@ class IntercomBroker {
     this.sessions.clear();
     this.askEdges.clear();
     this.messageReceiptRoutes.clear();
+    // Only the in-memory copies are cleared. The persisted mailbox and
+    // disconnected-session files are kept on purpose: the next broker reloads them.
     this.disconnectedSessions.clear();
     this.mailboxMessages.length = 0;
     if (typeof LISTEN_TARGET === "string" && process.platform !== "win32") {

package/dist/extensions/pi-intercom/broker/client.ts

@@ -9,6 +9,7 @@ import { EXACT_SEND_FEATURE, EXTENSION_BUS_FEATURE, type DeliveryDetails } from
 import type {
   Attachment,
   BrokerMessage,
+  CrossMachineProvenance,
   ClientMessage,
   Message,
   MessageControl,
@@ -27,6 +28,7 @@ interface SendOptions {
   supersedes?: string;
   retryOf?: string;
   provenance?: MessageProvenance;
+  crossMachine?: CrossMachineProvenance;
 }
 
 export interface SendResult extends DeliveryDetails {
@@ -383,7 +385,9 @@ export class IntercomClient extends EventEmitter {
         }
 
         this.pendingSends.delete(messageId);
-        pending.resolve({ id: messageId, delivered: true, delivery: delivery as "socket_delivered" | "queued" | undefined ?? "socket_delivered", retryable: retryable as boolean | undefined ?? false, outcomeKnown: outcomeKnown as boolean | undefined ?? true, ...(typeof brokerMessage.code === "string" ? { code: brokerMessage.code } : {}) });
+        const result: SendResult = { id: messageId, delivered: true, delivery: delivery as "socket_delivered" | "queued" | undefined ?? "socket_delivered", retryable: retryable as boolean | undefined ?? false, outcomeKnown: outcomeKnown as boolean | undefined ?? true, ...(typeof brokerMessage.code === "string" ? { code: brokerMessage.code } : {}) };
+        pending.resolve(result);
+        this.emit("broker_message", { type: "delivered", messageId, delivery: result.delivery, retryable: result.retryable, outcomeKnown: result.outcomeKnown, ...(result.code ? { code: result.code } : {}) });
         break;
       }
 
@@ -400,7 +404,9 @@ export class IntercomClient extends EventEmitter {
         }
 
         this.pendingSends.delete(messageId);
-        pending.resolve({ id: messageId, delivered: false, reason, delivery: delivery as "failed" | "unknown" | undefined ?? "failed", retryable: retryable as boolean | undefined ?? false, outcomeKnown: outcomeKnown as boolean | undefined ?? true, ...(typeof brokerMessage.code === "string" ? { code: brokerMessage.code } : {}) });
+        const result: SendResult = { id: messageId, delivered: false, reason, delivery: delivery as "failed" | "unknown" | undefined ?? "failed", retryable: retryable as boolean | undefined ?? false, outcomeKnown: outcomeKnown as boolean | undefined ?? true, ...(typeof brokerMessage.code === "string" ? { code: brokerMessage.code } : {}) };
+        pending.resolve(result);
+        this.emit("broker_message", { type: "delivery_failed", messageId, reason, delivery: result.delivery, retryable: result.retryable, outcomeKnown: result.outcomeKnown, ...(result.code ? { code: result.code } : {}) });
         break;
       }
 
@@ -636,6 +642,7 @@ export class IntercomClient extends EventEmitter {
       replyTo: options.replyTo,
       expectsReply: options.expectsReply,
       provenance: options.provenance,
+      crossMachine: options.crossMachine,
       content: {
         text: options.text,
         attachments: options.attachments,

package/dist/extensions/pi-intercom/broker/cross-machine-provenance.test.ts

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { isMessage, messageDeliveryFingerprint } from "./protocol.ts";
+import type { CrossMachineProvenance, Message } from "../types.ts";
+
+const origin = { name: "worker", sessionId: "origin-session", machine: "laptop" };
+const provenance: CrossMachineProvenance = {
+  type: "ssh-relay",
+  version: 1,
+  trust: "ssh-asserted",
+  origin,
+};
+
+function messageWith(crossMachine: unknown): unknown {
+  return {
+    id: "message-1",
+    timestamp: 1,
+    crossMachine,
+    content: { text: "hello" },
+  };
+}
+
+test("protocol validates the complete SSH relay provenance discriminator and origin", () => {
+  assert.equal(isMessage(messageWith(provenance)), true);
+
+  const invalid: unknown[] = [
+    { ...provenance, type: "ssh" },
+    { ...provenance, type: undefined },
+    { ...provenance, version: 2 },
+    { ...provenance, version: undefined },
+    { ...provenance, trust: "verified" },
+    { ...provenance, trust: undefined },
+    { ...provenance, origin: undefined },
+    { ...provenance, origin: { ...origin, name: 1 } },
+    { ...provenance, origin: { ...origin, sessionId: 1 } },
+    { ...provenance, origin: { ...origin, machine: 1 } },
+  ];
+  for (const crossMachine of invalid) {
+    assert.equal(isMessage(messageWith(crossMachine)), false, JSON.stringify(crossMachine));
+  }
+
+  assert.equal(isMessage({
+    ...(messageWith(provenance) as Record<string, unknown>),
+    provenance: {
+      type: "extension_outbox",
+      extensionId: "extension-id",
+      extensionName: "Extension",
+      requestId: "request-id",
+    },
+  }), true);
+});
+
+test("broker replay fingerprints distinguish every asserted origin field", () => {
+  const message = messageWith(provenance) as Message;
+  const original = messageDeliveryFingerprint(message, "receiver-session");
+  for (const [field, value] of [["name", "other"], ["sessionId", "other"], ["machine", "other"]] as const) {
+    const changed: Message = {
+      ...message,
+      crossMachine: { ...provenance, origin: { ...origin, [field]: value } },
+    };
+    assert.notEqual(messageDeliveryFingerprint(changed, "receiver-session"), original);
+  }
+});