@spotpatch/runtime 1.9.0 → 1.10.0

package/dist/external-handoff-panel.cjs

@@ -0,0 +1,1002 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/external-handoff-panel-entry.ts
+var external_handoff_panel_entry_exports = {};
+__export(external_handoff_panel_entry_exports, {
+  createExternalHandoffPanel: () => createExternalHandoffPanel,
+  createExternalHandoffWorkflow: () => createExternalHandoffWorkflow,
+  getExternalHandoffExtension: () => getExternalHandoffExtension,
+  registerExternalHandoffExtension: () => registerExternalHandoffExtension
+});
+module.exports = __toCommonJS(external_handoff_panel_entry_exports);
+
+// src/controller/external-handoff-workflow.ts
+var import_external_handoff_browser = require("@spotpatch/shared/external-handoff-browser");
+var MAX_SUMMARY_RESPONSE_BYTES = 64 * 1024;
+var OPAQUE_ID_PATTERN = /^[A-Za-z0-9_-]{22,128}$/u;
+var ExternalHandoffApiError = class extends Error {
+  constructor(code) {
+    super("SpotPatch external handoff API request failed.");
+    this.code = code;
+    this.name = "ExternalHandoffApiError";
+  }
+  code;
+};
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function validTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function parseActiveAdapter(value) {
+  if (value === null) return null;
+  if (!record(value) || !exactKeys(value, ["canDispatch", "connectedAt", "kind", "state", "updatedAt"]) || value.kind !== "claude-channel" && value.kind !== "codex-app-server" || value.state !== "ready" && value.state !== "busy" && value.state !== "blocked" || typeof value.canDispatch !== "boolean" || value.canDispatch !== (value.state === "ready") || !validTimestamp(value.connectedAt) || !validTimestamp(value.updatedAt)) {
+    throw new ExternalHandoffApiError();
+  }
+  return Object.freeze({
+    kind: value.kind,
+    state: value.state,
+    canDispatch: value.canDispatch,
+    connectedAt: value.connectedAt,
+    updatedAt: value.updatedAt
+  });
+}
+function parseDispatch(value) {
+  if (value === null) return null;
+  if (!record(value)) throw new ExternalHandoffApiError();
+  if (!exactKeys(value, ["adapterKind", "phase", "revision", "updatedAt"]) || value.adapterKind !== "claude-channel" && value.adapterKind !== "codex-app-server" || !Number.isSafeInteger(value.revision) || value.revision <= 0 || value.phase !== "queued" && value.phase !== "dispatching" && value.phase !== "dispatched" && value.phase !== "working" && value.phase !== "completed" && value.phase !== "failed" && value.phase !== "delivery-unknown" || !validTimestamp(value.updatedAt)) {
+    throw new ExternalHandoffApiError();
+  }
+  return Object.freeze({
+    adapterKind: value.adapterKind,
+    revision: value.revision,
+    phase: value.phase,
+    updatedAt: value.updatedAt
+  });
+}
+function parseCapability(value) {
+  if (!record(value) || !exactKeys(value, [
+    "activeAdapter",
+    "activeWaitCount",
+    "brokerProtocolVersion",
+    "brokerReady",
+    "dispatch",
+    "enabled",
+    "snapshotSchemaVersion"
+  ]) || value.enabled !== true || typeof value.brokerReady !== "boolean" || !Number.isSafeInteger(value.activeWaitCount) || value.activeWaitCount < 0 || value.activeWaitCount > import_external_handoff_browser.EXTERNAL_HANDOFF_LIMITS.maximumWaiters || value.snapshotSchemaVersion !== import_external_handoff_browser.EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION || value.brokerProtocolVersion !== import_external_handoff_browser.EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION) {
+    throw new ExternalHandoffApiError();
+  }
+  return Object.freeze({
+    enabled: true,
+    brokerReady: value.brokerReady,
+    activeWaitCount: value.activeWaitCount,
+    activeAdapter: parseActiveAdapter(value.activeAdapter),
+    dispatch: parseDispatch(value.dispatch),
+    snapshotSchemaVersion: import_external_handoff_browser.EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION,
+    brokerProtocolVersion: import_external_handoff_browser.EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION
+  });
+}
+function parsePublishResult(value) {
+  if (!record(value) || !exactKeys(value, ["delivery", "handoff", "replayed"]) || typeof value.replayed !== "boolean" || !record(value.delivery)) {
+    throw new ExternalHandoffApiError();
+  }
+  const handoff = parseSummary(value.handoff);
+  if (value.delivery.mode === "inbox") {
+    if (!exactKeys(value.delivery, ["mode"])) {
+      throw new ExternalHandoffApiError();
+    }
+    return Object.freeze({
+      handoff,
+      delivery: Object.freeze({ mode: "inbox" }),
+      replayed: value.replayed
+    });
+  }
+  if (value.delivery.mode !== "active" || !exactKeys(value.delivery, ["adapter", "dispatch", "mode"])) {
+    throw new ExternalHandoffApiError();
+  }
+  const adapter = parseActiveAdapter(value.delivery.adapter);
+  const dispatch = parseDispatch(value.delivery.dispatch);
+  if (adapter === null || dispatch?.revision !== handoff.revision) {
+    throw new ExternalHandoffApiError();
+  }
+  return Object.freeze({
+    handoff,
+    delivery: Object.freeze({ mode: "active", adapter, dispatch }),
+    replayed: value.replayed
+  });
+}
+function parseStatusResult(value) {
+  if (!record(value) || !exactKeys(value, ["activeAdapter", "dispatch", "handoff"])) {
+    throw new ExternalHandoffApiError();
+  }
+  const handoff = parseSummary(value.handoff);
+  const dispatch = parseDispatch(value.dispatch);
+  if (dispatch !== null && dispatch.revision !== handoff.revision) {
+    throw new ExternalHandoffApiError();
+  }
+  return Object.freeze({
+    handoff,
+    activeAdapter: parseActiveAdapter(value.activeAdapter),
+    dispatch
+  });
+}
+function parseSummary(value) {
+  if (!record(value)) throw new ExternalHandoffApiError();
+  const expectedKeys = [
+    "cursor",
+    "expiresAt",
+    "framework",
+    "page",
+    "pickupCount",
+    "publishedAt",
+    "revision",
+    "sessionId",
+    "state",
+    "targetCount",
+    ...value.pickedUpAt === void 0 ? [] : ["pickedUpAt"]
+  ];
+  if (!exactKeys(value, expectedKeys) || typeof value.sessionId !== "string" || !OPAQUE_ID_PATTERN.test(value.sessionId) || value.framework !== "vite" && value.framework !== "next" || !Number.isSafeInteger(value.revision) || value.revision <= 0 || typeof value.cursor !== "string" || !OPAQUE_ID_PATTERN.test(value.cursor) || !Number.isSafeInteger(value.targetCount) || value.targetCount <= 0 || !record(value.page) || !exactKeys(value.page, ["origin", "pathname"]) || typeof value.page.origin !== "string" || typeof value.page.pathname !== "string" || !validTimestamp(value.publishedAt) || !validTimestamp(value.expiresAt) || value.state !== "available" && value.state !== "expired" && value.state !== "superseded" || !Number.isSafeInteger(value.pickupCount) || value.pickupCount < 0 || value.pickupCount > import_external_handoff_browser.EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts || value.pickedUpAt !== void 0 && !validTimestamp(value.pickedUpAt)) {
+    throw new ExternalHandoffApiError();
+  }
+  return Object.freeze({
+    sessionId: value.sessionId,
+    framework: value.framework,
+    revision: value.revision,
+    cursor: value.cursor,
+    targetCount: value.targetCount,
+    page: Object.freeze({ origin: value.page.origin, pathname: value.page.pathname }),
+    publishedAt: value.publishedAt,
+    expiresAt: value.expiresAt,
+    state: value.state,
+    pickupCount: value.pickupCount,
+    ...value.pickedUpAt === void 0 ? {} : { pickedUpAt: value.pickedUpAt }
+  });
+}
+async function boundedJson(response) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_SUMMARY_RESPONSE_BYTES) {
+    await response.body?.cancel();
+    throw new ExternalHandoffApiError();
+  }
+  if (response.body === null) throw new ExternalHandoffApiError();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      total += chunk.value.byteLength;
+      if (total > MAX_SUMMARY_RESPONSE_BYTES) {
+        await reader.cancel();
+        throw new ExternalHandoffApiError();
+      }
+      chunks.push(chunk.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const payload = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    payload.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(payload)
+    );
+  } catch {
+    throw new ExternalHandoffApiError();
+  }
+}
+function failureCode(value) {
+  return record(value) && value.ok === false && record(value.error) && (0, import_external_handoff_browser.isErrorCode)(value.error.code) ? value.error.code : void 0;
+}
+function successData(value) {
+  if (!record(value) || !exactKeys(value, ["data", "ok"]) || value.ok !== true) {
+    throw new ExternalHandoffApiError();
+  }
+  return value.data;
+}
+function omitBrowserCode(annotation) {
+  return {
+    ...annotation,
+    targets: annotation.targets.map((target) => ({
+      instruction: target.instruction,
+      ...target.page === void 0 ? {} : { page: target.page },
+      source: target.source,
+      react: target.react,
+      element: target.element,
+      styles: target.styles,
+      warnings: target.warnings
+    }))
+  };
+}
+function createRequestId(window) {
+  const bytes = new Uint8Array(24);
+  window.crypto.getRandomValues(bytes);
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function dispatchIsPending(dispatch) {
+  return dispatch !== null && dispatch.phase !== "completed" && dispatch.phase !== "failed" && dispatch.phase !== "delivery-unknown";
+}
+function api(options) {
+  const pending = /* @__PURE__ */ new Set();
+  const request = async (endpoint, body) => {
+    const controller = new AbortController();
+    pending.add(controller);
+    try {
+      const response = await options.fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          [import_external_handoff_browser.SPOTPATCH_TOKEN_HEADER]: options.sessionToken
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const envelope = await boundedJson(response);
+      if (!response.ok) throw new ExternalHandoffApiError(failureCode(envelope));
+      return successData(envelope);
+    } finally {
+      pending.delete(controller);
+    }
+  };
+  return Object.freeze({
+    cancel() {
+      for (const controller of pending) controller.abort();
+      pending.clear();
+    },
+    async capability() {
+      return parseCapability(
+        await request(import_external_handoff_browser.SPOTPATCH_ENDPOINTS.externalHandoffCapability, {})
+      );
+    },
+    async publish(requestId, annotation) {
+      return parsePublishResult(
+        await request(import_external_handoff_browser.SPOTPATCH_ENDPOINTS.externalHandoffPublish, {
+          annotation: omitBrowserCode(annotation),
+          requestId
+        })
+      );
+    },
+    async status(cursor) {
+      return parseStatusResult(
+        await request(
+          import_external_handoff_browser.SPOTPATCH_ENDPOINTS.externalHandoffStatus,
+          cursor === void 0 ? {} : { cursor }
+        )
+      );
+    },
+    async resolveDelivery(cursor) {
+      return parseStatusResult(
+        await request(import_external_handoff_browser.SPOTPATCH_ENDPOINTS.externalHandoffResolveDelivery, {
+          confirmation: "workspace-reviewed",
+          cursor
+        })
+      );
+    }
+  });
+}
+function createExternalHandoffWorkflow(fetch, panel, selectedAnnotation, sessionToken, window) {
+  const options = {
+    fetch,
+    panel,
+    selectedAnnotation,
+    sessionToken,
+    window
+  };
+  const client = api(options);
+  const timers = /* @__PURE__ */ new Set();
+  const lifecycle = {
+    disposed: false,
+    mounted: false,
+    operation: 0,
+    userActionPending: false
+  };
+  let capability;
+  let current;
+  let retryablePublish;
+  const clearTimers = () => {
+    for (const timer of timers) options.window.clearTimeout(timer);
+    timers.clear();
+  };
+  const errorCode = (error) => error instanceof ExternalHandoffApiError ? error.code : void 0;
+  const restorePanel = () => {
+    if (current !== void 0) options.panel.renderStatus(current);
+    else if (capability !== void 0) options.panel.renderCapability(capability);
+  };
+  const refreshCapability = async (revision) => {
+    try {
+      const result = await client.capability();
+      if (lifecycle.disposed || revision !== lifecycle.operation) return;
+      capability = result;
+      options.panel.renderCapability(result);
+      if (result.dispatch !== null) {
+        const status = await client.status();
+        if (revision !== lifecycle.operation) return;
+        current = status;
+        options.panel.renderStatus(status);
+      }
+    } catch (error) {
+      if (lifecycle.disposed || revision !== lifecycle.operation || error instanceof DOMException && error.name === "AbortError")
+        return;
+      options.panel.renderError(errorCode(error));
+    }
+  };
+  const refreshStatus = async (revision) => {
+    if (current === void 0) {
+      await refreshCapability(revision);
+      return;
+    }
+    try {
+      const result = await client.status(current.handoff.cursor);
+      if (lifecycle.disposed || revision !== lifecycle.operation) return;
+      current = result;
+      options.panel.renderStatus(result);
+    } catch (error) {
+      if (lifecycle.disposed || revision !== lifecycle.operation || error instanceof DOMException && error.name === "AbortError")
+        return;
+      options.panel.renderError(errorCode(error));
+    }
+  };
+  const scheduleRefresh = (delay, continueWhilePending) => {
+    const revision = lifecycle.operation;
+    const timer = options.window.setTimeout(() => {
+      timers.delete(timer);
+      void refreshStatus(revision).then(() => {
+        if (continueWhilePending && !lifecycle.disposed && revision === lifecycle.operation && !lifecycle.userActionPending && current !== void 0 && dispatchIsPending(current.dispatch)) {
+          scheduleRefresh(
+            import_external_handoff_browser.EXTERNAL_HANDOFF_LIMITS.activeStatusPollMs,
+            continueWhilePending
+          );
+        }
+      });
+    }, delay);
+    timers.add(timer);
+  };
+  const handleSend = async () => {
+    if (lifecycle.userActionPending) return;
+    lifecycle.userActionPending = true;
+    let pending = retryablePublish;
+    if (pending === void 0) {
+      const annotation = options.selectedAnnotation();
+      if (annotation === void 0) {
+        lifecycle.userActionPending = false;
+        options.panel.renderError(import_external_handoff_browser.ERROR_CODES.HANDOFF_VALIDATION_FAILED);
+        return;
+      }
+      const disclosureRevision = lifecycle.operation;
+      options.panel.setBusy(true);
+      const confirmed = await options.panel.confirmDisclosure(annotation);
+      if (!confirmed || disclosureRevision !== lifecycle.operation) {
+        lifecycle.userActionPending = false;
+        options.panel.setBusy(false);
+        return;
+      }
+      pending = Object.freeze({
+        annotation,
+        requestId: createRequestId(options.window)
+      });
+    }
+    retryablePublish = pending;
+    lifecycle.operation += 1;
+    const revision = lifecycle.operation;
+    clearTimers();
+    client.cancel();
+    options.panel.renderPublishing();
+    try {
+      const result = await client.publish(pending.requestId, pending.annotation);
+      if (revision !== lifecycle.operation) return;
+      retryablePublish = void 0;
+      current = Object.freeze({
+        handoff: result.handoff,
+        activeAdapter: result.delivery.mode === "active" ? result.delivery.adapter : null,
+        dispatch: result.delivery.mode === "active" ? result.delivery.dispatch : null
+      });
+      options.panel.renderPublishResult(result);
+      scheduleRefresh(
+        result.delivery.mode === "active" ? import_external_handoff_browser.EXTERNAL_HANDOFF_LIMITS.activeStatusPollMs : 500,
+        result.delivery.mode === "active"
+      );
+    } catch (error) {
+      if (revision !== lifecycle.operation || error instanceof DOMException && error.name === "AbortError")
+        return;
+      const code = errorCode(error);
+      const retryable = code === void 0;
+      if (!retryable) retryablePublish = void 0;
+      options.panel.renderError(code, retryable);
+    } finally {
+      if (revision === lifecycle.operation) {
+        lifecycle.userActionPending = false;
+        options.panel.setBusy(false);
+      }
+    }
+  };
+  const handleRefresh = async () => {
+    if (lifecycle.userActionPending) return;
+    lifecycle.userActionPending = true;
+    lifecycle.operation += 1;
+    const revision = lifecycle.operation;
+    clearTimers();
+    client.cancel();
+    options.panel.setBusy(true);
+    try {
+      await refreshStatus(revision);
+    } finally {
+      if (!lifecycle.disposed && revision === lifecycle.operation) {
+        lifecycle.userActionPending = false;
+        options.panel.setBusy(false);
+      }
+    }
+  };
+  const handleResolveDelivery = async () => {
+    if (lifecycle.userActionPending || current === void 0 || current.dispatch?.phase !== "delivery-unknown") {
+      return;
+    }
+    lifecycle.userActionPending = true;
+    lifecycle.operation += 1;
+    const revision = lifecycle.operation;
+    clearTimers();
+    client.cancel();
+    options.panel.setBusy(true);
+    try {
+      const result = await client.resolveDelivery(current.handoff.cursor);
+      if (lifecycle.disposed || revision !== lifecycle.operation) return;
+      current = result;
+      options.panel.renderStatus(result);
+    } catch (error) {
+      if (lifecycle.disposed || revision !== lifecycle.operation || error instanceof DOMException && error.name === "AbortError") {
+        return;
+      }
+      options.panel.renderError(errorCode(error));
+    } finally {
+      if (!lifecycle.disposed && revision === lifecycle.operation) {
+        lifecycle.userActionPending = false;
+        options.panel.setBusy(false);
+      }
+    }
+  };
+  const handleSendClick = () => {
+    void handleSend();
+  };
+  const handleRefreshClick = () => {
+    void handleRefresh();
+  };
+  const handleResolveClick = () => {
+    void handleResolveDelivery();
+  };
+  const cancelPending = () => {
+    lifecycle.operation += 1;
+    lifecycle.userActionPending = false;
+    retryablePublish = void 0;
+    clearTimers();
+    client.cancel();
+    restorePanel();
+    if (capability === void 0 && lifecycle.mounted && !lifecycle.disposed) {
+      void refreshCapability(lifecycle.operation);
+    }
+  };
+  return Object.freeze({
+    mount() {
+      if (lifecycle.mounted || lifecycle.disposed) return;
+      lifecycle.mounted = true;
+      options.panel.sendButton.addEventListener("click", handleSendClick);
+      options.panel.refreshButton.addEventListener("click", handleRefreshClick);
+      options.panel.resolveButton.addEventListener("click", handleResolveClick);
+      void refreshCapability(lifecycle.operation);
+    },
+    cancelPending,
+    dispose() {
+      if (lifecycle.disposed) return;
+      lifecycle.disposed = true;
+      lifecycle.operation += 1;
+      lifecycle.userActionPending = false;
+      retryablePublish = void 0;
+      clearTimers();
+      client.cancel();
+      options.panel.sendButton.removeEventListener("click", handleSendClick);
+      options.panel.refreshButton.removeEventListener("click", handleRefreshClick);
+      options.panel.resolveButton.removeEventListener("click", handleResolveClick);
+    }
+  });
+}
+
+// src/ui/ui-constants.ts
+var UI_MARKER_ATTRIBUTE = "data-spotpatch-ui";
+var UI_Z_INDEX = Object.freeze({
+  highlight: 2147483646,
+  controls: 2147483647
+});
+
+// src/ui/dom.ts
+function createMarkedElement(document, tagName) {
+  const element = document.createElement(tagName);
+  element.setAttribute(UI_MARKER_ATTRIBUTE, "");
+  return element;
+}
+function createButton(document, label, className = "") {
+  const button = createMarkedElement(document, "button");
+  button.type = "button";
+  button.className = className;
+  button.textContent = label;
+  return button;
+}
+
+// src/ui/external-handoff-panel.ts
+var MESSAGES = Object.freeze({
+  "en-US": Object.freeze({
+    title: "External Agent connection",
+    description: "Send through a ready active adapter, or publish to the project Agent inbox when no active adapter is connected.",
+    ready: "Local Broker ready. No Agent connection is assumed until a connector reads or waits.",
+    readyWaiting: (count) => `${String(count)} active connector wait request(s); publishing can wake them immediately.`,
+    activeReady: (agent) => `${agent} is connected and idle. The next send will dispatch immediately.`,
+    publishing: "Authorizing current source and publishing the handoff\u2026",
+    published: (revision, expiresAt) => `Revision ${String(revision)} is available until ${expiresAt}. It has not been claimed as edited.`,
+    queued: (agent, revision) => `Revision ${String(revision)} is reserved for ${agent}.`,
+    dispatching: (agent, revision) => `Dispatching revision ${String(revision)} to ${agent}\u2026`,
+    dispatched: (agent, revision) => agent === "Claude Code" ? `Revision ${String(revision)} was written to the Claude Channel transport; there is no model ACK yet.` : `Codex App Server accepted revision ${String(revision)}; waiting for the matching turn to start.`,
+    working: (agent, revision) => `${agent} is working on revision ${String(revision)}.`,
+    completed: (agent, revision) => `${agent} ended revision ${String(revision)} normally. Review the diff and checks; this does not prove the requested change is correct.`,
+    failed: (agent, revision) => `${agent} reported revision ${String(revision)} as failed. The connector is idle again.`,
+    unknown: (agent, revision) => `Delivery of revision ${String(revision)} to ${agent} is uncertain. The managed writer stopped; review the workspace before allowing another task.`,
+    unknownResolved: (agent, revision) => `Revision ${String(revision)} for ${agent} remains delivery-unknown, but the workspace review was confirmed. A new connector or inbox task may now be used.`,
+    pickedUp: (revision, count, time) => `Revision ${String(revision)} was picked up by ${String(count)} connector instance(s)${time === void 0 ? "." : `; last pickup ${time}.`} This does not prove a code change.`,
+    expired: (revision) => `Revision ${String(revision)} expired. Review the current selection and publish again.`,
+    superseded: (revision) => `Revision ${String(revision)} was superseded by a newer handoff.`,
+    send: "Send to Agent",
+    inboxSend: "Publish to Agent inbox",
+    retry: "Retry same send",
+    refresh: "Refresh pickup status",
+    resolveUnknown: "Workspace reviewed \u2014 allow a new task",
+    settingsTitle: "Project connection setup",
+    settingsHelp: "Setup commands are project-scoped dry runs; append --write only after review. Claude active mode also needs the shown Research Preview launch flag. Codex active mode is zero-setup: run its explicit connector command and keep it open.",
+    disclosureTitle: "Confirm external Agent handoff",
+    disclosureIntro: (targets, files) => `Publish ${String(targets)} selected target(s) referencing ${String(files)} relative file(s).`,
+    disclosureData: "The handoff includes your instructions, component/page context, sanitized DOM/CSS, and bounded source read again by the local Node service.",
+    disclosureInbox: "Any SpotPatch connector configured for this project may read it during the 15-minute lifetime.",
+    disclosureProvider: "The Agent host may send the content to its cloud provider under that product's data policy.",
+    disclosureNoGuarantee: "External edits do not receive SpotPatch's built-in worktree, Apply, or Revert guarantees.",
+    cancel: "Cancel",
+    confirm: "Confirm and send",
+    error: (code) => code === "EXTERNAL_AGENT_BUSY" ? "The active Agent is still busy or blocked by an uncertain delivery." : code === "ACTIVE_DISPATCH_INVALID" ? "The active delivery state changed. Refresh before continuing." : code === "HANDOFF_SOURCE_STALE" ? "The selected source changed. Select the current component again." : code === "HANDOFF_RESPONSE_TOO_LARGE" ? "The handoff is too large. Reduce the selected context." : code === "EXTERNAL_HANDOFF_DISABLED" ? "External Agent handoff is disabled in trusted project configuration." : code === "EXTERNAL_HANDOFF_UNAVAILABLE" || code === "SESSION_CLOSED" ? "The local external Agent Broker is unavailable. Restart the development server." : "The external Agent handoff request failed without publishing a partial revision."
+  }),
+  "zh-CN": Object.freeze({
+    title: "\u5916\u90E8 Agent \u8FDE\u63A5",
+    description: "\u6709\u4E3B\u52A8\u9002\u914D\u5668\u5C31\u7ACB\u5373\u6D3E\u53D1\uFF1B\u672A\u8FDE\u63A5\u4E3B\u52A8\u9002\u914D\u5668\u65F6\uFF0C\u8BDA\u5B9E\u964D\u7EA7\u4E3A\u9879\u76EE Agent \u6536\u4EF6\u7BB1\u3002",
+    ready: "\u672C\u5730 Broker \u5DF2\u5C31\u7EEA\u3002\u53EA\u6709\u8FDE\u63A5\u5668\u8BFB\u53D6\u6216\u7B49\u5F85\u540E\uFF0C\u624D\u80FD\u8BC1\u660E\u53D1\u751F\u8FC7\u8FDE\u63A5\u3002",
+    readyWaiting: (count) => `\u5F53\u524D\u6709 ${String(count)} \u4E2A\u8FDE\u63A5\u5668\u7B49\u5F85\u8BF7\u6C42\uFF0C\u53D1\u5E03\u540E\u53EF\u7ACB\u5373\u5524\u9192\u3002`,
+    activeReady: (agent) => `${agent} \u5DF2\u8FDE\u63A5\u5E76\u5904\u4E8E\u7A7A\u95F2\u72B6\u6001\uFF0C\u4E0B\u6B21\u53D1\u9001\u4F1A\u7ACB\u5373\u6D3E\u53D1\u3002`,
+    publishing: "\u6B63\u5728\u91CD\u65B0\u6388\u6743\u5F53\u524D\u6E90\u7801\u5E76\u53D1\u5E03\u4EA4\u63A5\u2026\u2026",
+    published: (revision, expiresAt) => `\u4EA4\u63A5 revision ${String(revision)} \u53EF\u8BFB\u53D6\u81F3 ${expiresAt}\uFF1B\u8FD9\u4E0D\u8868\u793A\u4EE3\u7801\u5DF2\u88AB\u4FEE\u6539\u3002`,
+    queued: (agent, revision) => `\u4EA4\u63A5 revision ${String(revision)} \u5DF2\u4E3A ${agent} \u9884\u7559\u3002`,
+    dispatching: (agent, revision) => `\u6B63\u5728\u628A revision ${String(revision)} \u6D3E\u53D1\u7ED9 ${agent}\u2026\u2026`,
+    dispatched: (agent, revision) => agent === "Claude Code" ? `revision ${String(revision)} \u5DF2\u5199\u5165 Claude Channel transport\uFF1B\u5F53\u524D\u6CA1\u6709\u6A21\u578B ACK\u3002` : `Codex App Server \u5DF2\u63A5\u53D7 revision ${String(revision)}\uFF0C\u6B63\u5728\u7B49\u5F85\u5339\u914D turn \u542F\u52A8\u3002`,
+    working: (agent, revision) => `${agent} \u6B63\u5728\u5904\u7406 revision ${String(revision)}\u3002`,
+    completed: (agent, revision) => `${agent} \u5DF2\u6B63\u5E38\u7ED3\u675F revision ${String(revision)}\u3002\u8BF7\u6838\u5BF9 diff \u548C\u68C0\u67E5\u7ED3\u679C\uFF1B\u8FD9\u4E0D\u8BC1\u660E\u4FEE\u6539\u8981\u6C42\u5DF2\u7ECF\u6B63\u786E\u5B8C\u6210\u3002`,
+    failed: (agent, revision) => `${agent} \u5DF2\u5C06 revision ${String(revision)} \u62A5\u544A\u4E3A\u5931\u8D25\uFF0C\u8FDE\u63A5\u5668\u5DF2\u6062\u590D\u7A7A\u95F2\u3002`,
+    unknown: (agent, revision) => `revision ${String(revision)} \u5411 ${agent} \u7684\u6295\u9012\u7ED3\u679C\u4E0D\u786E\u5B9A\u3002\u53D7\u7BA1 writer \u5DF2\u505C\u6B62\uFF0C\u8BF7\u5148\u6838\u5BF9\u5DE5\u4F5C\u533A\u518D\u5141\u8BB8\u65B0\u4EFB\u52A1\u3002`,
+    unknownResolved: (agent, revision) => `${agent} \u7684 revision ${String(revision)} \u4ECD\u8BB0\u4E3A\u6295\u9012\u672A\u77E5\uFF0C\u4F46\u5DE5\u4F5C\u533A\u6838\u5BF9\u5DF2\u7ECF\u786E\u8BA4\uFF1B\u73B0\u5728\u53EF\u4EE5\u91CD\u65B0\u8FDE\u63A5\u6216\u53D1\u5E03\u65B0\u7684\u6536\u4EF6\u7BB1\u4EFB\u52A1\u3002`,
+    pickedUp: (revision, count, time) => `\u4EA4\u63A5 revision ${String(revision)} \u5DF2\u88AB ${String(count)} \u4E2A\u8FDE\u63A5\u5668\u5B9E\u4F8B\u53D6\u8D70${time === void 0 ? "\u3002" : `\uFF0C\u6700\u8FD1\u53D6\u4EF6\u4E8E ${time}\u3002`}\u8FD9\u4E0D\u80FD\u8BC1\u660E\u4EE3\u7801\u5DF2\u7ECF\u4FEE\u6539\u3002`,
+    expired: (revision) => `\u4EA4\u63A5 revision ${String(revision)} \u5DF2\u8FC7\u671F\uFF0C\u8BF7\u6838\u5BF9\u5F53\u524D\u9009\u62E9\u540E\u91CD\u65B0\u53D1\u5E03\u3002`,
+    superseded: (revision) => `\u4EA4\u63A5 revision ${String(revision)} \u5DF2\u88AB\u66F4\u65B0\u7248\u672C\u53D6\u4EE3\u3002`,
+    send: "\u53D1\u9001\u7ED9 Agent",
+    inboxSend: "\u53D1\u5E03\u5230 Agent \u6536\u4EF6\u7BB1",
+    retry: "\u91CD\u8BD5\u540C\u4E00\u6B21\u53D1\u9001",
+    refresh: "\u5237\u65B0\u53D6\u4EF6\u72B6\u6001",
+    resolveUnknown: "\u5DF2\u6838\u5BF9\u5DE5\u4F5C\u533A\uFF0C\u5141\u8BB8\u65B0\u4EFB\u52A1",
+    settingsTitle: "\u9879\u76EE\u8FDE\u63A5\u8BBE\u7F6E",
+    settingsHelp: "setup \u547D\u4EE4\u5747\u4E3A\u9879\u76EE\u7EA7 dry-run\uFF0C\u6838\u5BF9\u540E\u624D\u8FFD\u52A0 --write\u3002Claude \u4E3B\u52A8\u6A21\u5F0F\u8FD8\u9700\u4F7F\u7528\u4E0B\u65B9 Research Preview \u542F\u52A8\u53C2\u6570\uFF1BCodex \u4E3B\u52A8\u6A21\u5F0F\u65E0\u9700 setup\uFF0C\u53EA\u9700\u663E\u5F0F\u542F\u52A8\u5E76\u4FDD\u6301 Connector \u547D\u4EE4\u8FD0\u884C\u3002",
+    disclosureTitle: "\u786E\u8BA4\u53D1\u5E03\u5230\u5916\u90E8 Agent",
+    disclosureIntro: (targets, files) => `\u5C06\u53D1\u5E03 ${String(targets)} \u4E2A\u76EE\u6807\uFF0C\u6D89\u53CA ${String(files)} \u4E2A\u9879\u76EE\u76F8\u5BF9\u6587\u4EF6\u3002`,
+    disclosureData: "\u4EA4\u63A5\u5305\u542B\u4FEE\u6539\u8BF4\u660E\u3001\u7EC4\u4EF6\u4E0E\u9875\u9762\u4E0A\u4E0B\u6587\u3001\u5DF2\u6E05\u6D17\u7684 DOM/CSS\uFF0C\u4EE5\u53CA\u672C\u5730 Node \u670D\u52A1\u91CD\u65B0\u8BFB\u53D6\u7684\u6709\u754C\u6E90\u7801\u3002",
+    disclosureInbox: "15 \u5206\u949F\u6709\u6548\u671F\u5185\uFF0C\u672C\u9879\u76EE\u4E2D\u4EFB\u4F55\u5DF2\u914D\u7F6E\u7684 SpotPatch Connector \u90FD\u53EF\u80FD\u8BFB\u53D6\u3002",
+    disclosureProvider: "Agent \u5BBF\u4E3B\u53EF\u80FD\u4F9D\u636E\u5176\u4EA7\u54C1\u6570\u636E\u7B56\u7565\uFF0C\u5C06\u5185\u5BB9\u53D1\u9001\u7ED9\u4E91\u7AEF\u6A21\u578B\u670D\u52A1\u3002",
+    disclosureNoGuarantee: "\u5916\u90E8\u4FEE\u6539\u4E0D\u5177\u5907 SpotPatch \u5185\u5EFA Agent \u7684 worktree\u3001Apply \u6216 Revert \u4FDD\u8BC1\u3002",
+    cancel: "\u53D6\u6D88",
+    confirm: "\u786E\u8BA4\u5E76\u53D1\u9001",
+    error: (code) => code === "EXTERNAL_AGENT_BUSY" ? "\u4E3B\u52A8 Agent \u4ECD\u5728\u5DE5\u4F5C\uFF0C\u6216\u5B58\u5728\u5C1A\u672A\u6838\u5BF9\u7684\u6295\u9012\u672A\u77E5\u72B6\u6001\u3002" : code === "ACTIVE_DISPATCH_INVALID" ? "\u4E3B\u52A8\u6295\u9012\u72B6\u6001\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u5237\u65B0\u540E\u518D\u7EE7\u7EED\u3002" : code === "HANDOFF_SOURCE_STALE" ? "\u9009\u4E2D\u6E90\u7801\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u9009\u62E9\u5F53\u524D\u7EC4\u4EF6\u3002" : code === "HANDOFF_RESPONSE_TOO_LARGE" ? "\u4EA4\u63A5\u5185\u5BB9\u8D85\u8FC7\u4E0A\u9650\uFF0C\u8BF7\u51CF\u5C11\u6240\u9009\u4E0A\u4E0B\u6587\u3002" : code === "EXTERNAL_HANDOFF_DISABLED" ? "\u53EF\u4FE1\u9879\u76EE\u914D\u7F6E\u6CA1\u6709\u542F\u7528\u5916\u90E8 Agent \u4EA4\u63A5\u3002" : code === "EXTERNAL_HANDOFF_UNAVAILABLE" || code === "SESSION_CLOSED" ? "\u672C\u5730\u5916\u90E8 Agent Broker \u4E0D\u53EF\u7528\uFF0C\u8BF7\u91CD\u542F\u5F00\u53D1\u670D\u52A1\u3002" : "\u5916\u90E8 Agent \u4EA4\u63A5\u8BF7\u6C42\u5931\u8D25\uFF0C\u672A\u53D1\u5E03\u4EFB\u4F55\u90E8\u5206 revision\u3002"
+  })
+});
+function createStyles(document) {
+  const styles = document.createElement("style");
+  styles.textContent = `
+    .spotpatch-external-handoff { margin-top: 12px; padding: 12px; border: 1px solid var(--spotpatch-border); border-radius: var(--spotpatch-radius-card); background: rgb(82 168 255 / 5%); }
+    .spotpatch-external-handoff[hidden] { display: none; }
+    .spotpatch-external-heading { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
+    .spotpatch-external-heading strong { font-size: 12px; font-weight: 680; color: var(--spotpatch-text); }
+    .spotpatch-external-description, .spotpatch-external-status, .spotpatch-external-settings p { margin: 6px 0 0; font-size: 11px; line-height: 1.5; color: var(--spotpatch-text-secondary); }
+    .spotpatch-external-status { padding-left: 10px; border-left: 2px solid var(--spotpatch-accent-cyan); color: #cbd5e1; }
+    .spotpatch-external-status[data-state="error"] { border-color: var(--spotpatch-danger); color: #fecdd3; }
+    .spotpatch-external-status[data-state="picked-up"] { border-color: var(--spotpatch-success); color: #a7f3d0; }
+    .spotpatch-external-settings { margin-top: 9px; }
+    .spotpatch-external-settings summary { cursor: pointer; color: #c4b5fd; font-size: 11px; }
+    .spotpatch-external-command { display: block; margin-top: 6px; padding: 6px 8px; overflow: auto; border-radius: 6px; background: var(--spotpatch-bg-input); color: #d8d6ff; font: 10px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: nowrap; }
+    .spotpatch-external-refresh { padding: 3px 7px; border: 1px solid var(--spotpatch-border); border-radius: 6px; background: transparent; color: var(--spotpatch-text-secondary); font: inherit; font-size: 10px; cursor: pointer; }
+    .spotpatch-external-refresh:disabled { cursor: default; opacity: .45; }
+    .spotpatch-external-resolve { margin-top: 8px; padding: 6px 8px; border: 1px solid #f59e0b; border-radius: 6px; background: rgb(245 158 11 / 10%); color: #fde68a; font: inherit; font-size: 10px; cursor: pointer; }
+    .spotpatch-external-resolve[hidden] { display: none; }
+    .spotpatch-external-resolve:disabled { cursor: default; opacity: .45; }
+    .spotpatch-external-disclosure { position: fixed; inset: 0; z-index: 4; display: grid; place-items: center; padding: 20px; background: rgb(3 3 8 / 72%); backdrop-filter: blur(3px); }
+    .spotpatch-external-disclosure[hidden] { display: none; }
+    .spotpatch-external-disclosure-card { width: min(420px, calc(100vw - 40px)); max-height: calc(100vh - 40px); overflow: auto; padding: 18px; border: 1px solid rgb(139 123 255 / 55%); border-radius: 14px; background: var(--spotpatch-bg-raised); box-shadow: var(--spotpatch-shadow-panel); }
+    .spotpatch-external-disclosure-card h3 { margin: 0; color: var(--spotpatch-text); font-size: 15px; }
+    .spotpatch-external-disclosure-card p { margin: 9px 0 0; color: #c4c7d0; font-size: 11.5px; line-height: 1.55; }
+    .spotpatch-external-files { max-height: 96px; overflow: auto; color: #a5b4fc; font: 10px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: pre-wrap; }
+    .spotpatch-external-disclosure-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 15px; }
+    .spotpatch-external-disclosure-actions button { padding: 7px 10px; border: 1px solid var(--spotpatch-border); border-radius: 7px; background: var(--spotpatch-bg-active); color: var(--spotpatch-text); font: inherit; cursor: pointer; }
+    .spotpatch-external-disclosure-actions .spotpatch-primary { border-color: transparent; background: var(--spotpatch-accent); color: var(--spotpatch-text-on-accent); }
+  `;
+  return styles;
+}
+function formatTime(value, locale) {
+  const date = new Date(value);
+  return Number.isNaN(date.valueOf()) ? value : new Intl.DateTimeFormat(locale, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).format(date);
+}
+function agentName(kind) {
+  return kind === "claude-channel" ? "Claude Code" : "Codex";
+}
+function dispatchMessage(messages, dispatch) {
+  const agent = agentName(dispatch.adapterKind);
+  if (dispatch.phase === "queued") {
+    return messages.queued(agent, dispatch.revision);
+  }
+  if (dispatch.phase === "dispatching") {
+    return messages.dispatching(agent, dispatch.revision);
+  }
+  if (dispatch.phase === "dispatched") {
+    return messages.dispatched(agent, dispatch.revision);
+  }
+  if (dispatch.phase === "working") {
+    return messages.working(agent, dispatch.revision);
+  }
+  if (dispatch.phase === "completed") {
+    return messages.completed(agent, dispatch.revision);
+  }
+  if (dispatch.phase === "failed") {
+    return messages.failed(agent, dispatch.revision);
+  }
+  return messages.unknown(agent, dispatch.revision);
+}
+function disclosurePaths(annotation) {
+  return Object.freeze([
+    ...new Set(
+      annotation.targets.flatMap((target) => {
+        const relativePath = target.code?.relativePath ?? target.source.relativePath;
+        return relativePath === void 0 ? [] : [relativePath];
+      })
+    )
+  ]);
+}
+function createExternalHandoffPanel(document, framework, locale, sessionId, subscribeLocale, onViewChange) {
+  const options = {
+    document,
+    framework,
+    locale,
+    onViewChange,
+    sessionId,
+    subscribeLocale
+  };
+  let messages = MESSAGES[options.locale()];
+  let activeAdapter = null;
+  let brokerReady = false;
+  let dispatchBlocksSend = false;
+  let operationBusy = false;
+  let retryable = false;
+  let unknownDelivery = false;
+  let contextReady = false;
+  let visible = false;
+  let pendingDisclosure;
+  let previousFocus;
+  const consentKey = `spotpatch:external-handoff-consent:${options.sessionId}`;
+  const root = createMarkedElement(document, "section");
+  root.className = "spotpatch-external-handoff";
+  root.hidden = true;
+  const heading = createMarkedElement(document, "div");
+  heading.className = "spotpatch-external-heading";
+  const title = createMarkedElement(document, "strong");
+  const refreshButton = createButton(document, "", "spotpatch-external-refresh");
+  heading.append(title, refreshButton);
+  const description = createMarkedElement(document, "p");
+  description.className = "spotpatch-external-description";
+  const status = createMarkedElement(document, "p");
+  status.className = "spotpatch-external-status";
+  status.setAttribute("role", "status");
+  status.setAttribute("aria-live", "polite");
+  const resolveButton = createButton(document, "", "spotpatch-external-resolve");
+  resolveButton.hidden = true;
+  const settings = createMarkedElement(document, "details");
+  settings.className = "spotpatch-external-settings";
+  const settingsTitle = createMarkedElement(document, "summary");
+  const settingsHelp = createMarkedElement(document, "p");
+  const cliPrefix = `node ./node_modules/@spotpatch/${options.framework}/dist/cli.js`;
+  const bridgePrefix = `${cliPrefix} bridge`;
+  const commands = [
+    `${bridgePrefix} setup --client claude --scope project --mode active`,
+    "MCP_PROTOCOL_NEGOTIATION=legacy claude --dangerously-load-development-channels server:spotpatch",
+    `${cliPrefix} connect codex --allow-workspace-write`,
+    `${bridgePrefix} setup --client cursor --scope project`
+  ].map((value) => {
+    const command = createMarkedElement(document, "code");
+    command.className = "spotpatch-external-command";
+    command.textContent = value;
+    return command;
+  });
+  settings.append(settingsTitle, settingsHelp, ...commands);
+  root.append(heading, description, status, resolveButton, settings);
+  const sendButton = createButton(document, "", "spotpatch-primary");
+  sendButton.hidden = true;
+  const disclosure = createMarkedElement(document, "div");
+  disclosure.className = "spotpatch-external-disclosure";
+  disclosure.hidden = true;
+  const disclosureCard = createMarkedElement(document, "section");
+  disclosureCard.className = "spotpatch-external-disclosure-card";
+  disclosureCard.tabIndex = -1;
+  disclosureCard.setAttribute("role", "alertdialog");
+  disclosureCard.setAttribute("aria-modal", "true");
+  const disclosureTitle = createMarkedElement(document, "h3");
+  const disclosureIntro = createMarkedElement(document, "p");
+  const disclosureFiles = createMarkedElement(document, "p");
+  disclosureFiles.className = "spotpatch-external-files";
+  const disclosureData = createMarkedElement(document, "p");
+  const disclosureInbox = createMarkedElement(document, "p");
+  const disclosureProvider = createMarkedElement(document, "p");
+  const disclosureNoGuarantee = createMarkedElement(document, "p");
+  const disclosureActions = createMarkedElement(document, "div");
+  disclosureActions.className = "spotpatch-external-disclosure-actions";
+  const cancelButton = createButton(document, "");
+  const confirmButton = createButton(document, "", "spotpatch-primary");
+  disclosureActions.append(cancelButton, confirmButton);
+  disclosureCard.append(
+    disclosureTitle,
+    disclosureIntro,
+    disclosureFiles,
+    disclosureData,
+    disclosureInbox,
+    disclosureProvider,
+    disclosureNoGuarantee,
+    disclosureActions
+  );
+  disclosure.append(disclosureCard);
+  root.append(disclosure);
+  const hasConsent = () => {
+    try {
+      return document.defaultView?.sessionStorage.getItem(consentKey) === "confirmed";
+    } catch {
+      return false;
+    }
+  };
+  const rememberConsent = () => {
+    try {
+      document.defaultView?.sessionStorage.setItem(consentKey, "confirmed");
+    } catch {
+    }
+  };
+  const refreshActions = () => {
+    sendButton.textContent = retryable ? messages.retry : activeAdapter?.canDispatch === true ? messages.send : messages.inboxSend;
+    sendButton.disabled = !visible || !brokerReady || !contextReady || operationBusy || !retryable && dispatchBlocksSend;
+    sendButton.setAttribute("aria-busy", String(operationBusy));
+    refreshButton.disabled = !visible || operationBusy;
+    resolveButton.hidden = !unknownDelivery;
+    resolveButton.disabled = !visible || operationBusy || !unknownDelivery;
+  };
+  const settleDisclosure = (confirmed) => {
+    if (pendingDisclosure === void 0) return;
+    const resolve = pendingDisclosure;
+    pendingDisclosure = void 0;
+    disclosure.hidden = true;
+    if (confirmed) rememberConsent();
+    previousFocus?.focus({ preventScroll: true });
+    previousFocus = void 0;
+    resolve(confirmed);
+    options.onViewChange();
+  };
+  const handleDisclosureKeydown = (event) => {
+    if (event.key === "Escape") {
+      event.preventDefault();
+      settleDisclosure(false);
+      return;
+    }
+    if (event.key !== "Tab") return;
+    const first = cancelButton;
+    const last = confirmButton;
+    const rootNode = disclosure.getRootNode();
+    const activeElement = "activeElement" in rootNode ? rootNode.activeElement : document.activeElement;
+    if (event.shiftKey && activeElement === first) {
+      event.preventDefault();
+      last.focus();
+    } else if (!event.shiftKey && activeElement === last) {
+      event.preventDefault();
+      first.focus();
+    }
+  };
+  const applyMessages = () => {
+    messages = MESSAGES[options.locale()];
+    title.textContent = messages.title;
+    description.textContent = messages.description;
+    refreshButton.textContent = messages.refresh;
+    refreshButton.title = messages.refresh;
+    settingsTitle.textContent = messages.settingsTitle;
+    settingsHelp.textContent = messages.settingsHelp;
+    disclosureTitle.textContent = messages.disclosureTitle;
+    disclosureData.textContent = messages.disclosureData;
+    disclosureInbox.textContent = messages.disclosureInbox;
+    disclosureProvider.textContent = messages.disclosureProvider;
+    disclosureNoGuarantee.textContent = messages.disclosureNoGuarantee;
+    cancelButton.textContent = messages.cancel;
+    confirmButton.textContent = messages.confirm;
+    resolveButton.textContent = messages.resolveUnknown;
+    refreshActions();
+  };
+  cancelButton.addEventListener("click", () => {
+    settleDisclosure(false);
+  });
+  confirmButton.addEventListener("click", () => {
+    settleDisclosure(true);
+  });
+  disclosure.addEventListener("keydown", handleDisclosureKeydown);
+  settings.addEventListener("toggle", options.onViewChange);
+  const unsubscribeLocale = options.subscribeLocale(applyMessages);
+  applyMessages();
+  status.textContent = messages.ready;
+  refreshActions();
+  const summaryMessage = (summary) => summary.state === "expired" ? messages.expired(summary.revision) : summary.state === "superseded" ? messages.superseded(summary.revision) : summary.pickupCount > 0 ? messages.pickedUp(
+    summary.revision,
+    summary.pickupCount,
+    summary.pickedUpAt === void 0 ? void 0 : formatTime(summary.pickedUpAt, options.locale())
+  ) : messages.published(
+    summary.revision,
+    formatTime(summary.expiresAt, options.locale())
+  );
+  const applyStatus = (result) => {
+    operationBusy = false;
+    retryable = false;
+    activeAdapter = result.activeAdapter;
+    unknownDelivery = result.dispatch?.phase === "delivery-unknown" && result.activeAdapter?.state === "blocked";
+    dispatchBlocksSend = unknownDelivery || result.activeAdapter !== null && !result.activeAdapter.canDispatch;
+    if (result.dispatch !== null) {
+      status.dataset.state = result.dispatch.phase;
+      status.textContent = result.dispatch.phase === "delivery-unknown" && !unknownDelivery ? messages.unknownResolved(
+        agentName(result.dispatch.adapterKind),
+        result.dispatch.revision
+      ) : dispatchMessage(messages, result.dispatch);
+    } else {
+      status.dataset.state = result.handoff.state === "available" && result.handoff.pickupCount > 0 ? "picked-up" : result.handoff.state;
+      status.textContent = summaryMessage(result.handoff);
+    }
+    refreshActions();
+    options.onViewChange();
+  };
+  return Object.freeze({
+    root,
+    styles: createStyles(document),
+    sendButton,
+    refreshButton,
+    resolveButton,
+    confirmDisclosure(annotation) {
+      if (hasConsent()) return Promise.resolve(true);
+      if (pendingDisclosure !== void 0) return Promise.resolve(false);
+      const paths = disclosurePaths(annotation);
+      disclosureIntro.textContent = messages.disclosureIntro(
+        annotation.targets.length,
+        paths.length
+      );
+      disclosureFiles.textContent = paths.length === 0 ? "\u2014" : paths.join("\n");
+      disclosure.hidden = false;
+      const rootNode = root.getRootNode();
+      const activeElement = "activeElement" in rootNode ? rootNode.activeElement : document.activeElement;
+      previousFocus = activeElement instanceof HTMLElement ? activeElement : void 0;
+      options.onViewChange();
+      disclosureCard.focus({ preventScroll: true });
+      return new Promise((resolve) => {
+        pendingDisclosure = resolve;
+      });
+    },
+    renderCapability(capability) {
+      brokerReady = capability.brokerReady;
+      operationBusy = false;
+      retryable = false;
+      activeAdapter = capability.activeAdapter;
+      unknownDelivery = false;
+      dispatchBlocksSend = capability.activeAdapter !== null && !capability.activeAdapter.canDispatch;
+      status.dataset.state = capability.brokerReady ? "ready" : "error";
+      status.textContent = capability.brokerReady ? capability.activeAdapter?.canDispatch === true ? messages.activeReady(agentName(capability.activeAdapter.kind)) : capability.dispatch !== null && capability.activeAdapter !== null ? dispatchMessage(messages, capability.dispatch) : capability.activeWaitCount > 0 ? messages.readyWaiting(capability.activeWaitCount) : messages.ready : messages.error("EXTERNAL_HANDOFF_UNAVAILABLE");
+      refreshActions();
+      options.onViewChange();
+    },
+    renderPublishing() {
+      operationBusy = true;
+      retryable = false;
+      status.dataset.state = "publishing";
+      status.textContent = messages.publishing;
+      refreshActions();
+      options.onViewChange();
+    },
+    renderPublishResult(result) {
+      applyStatus(
+        Object.freeze({
+          handoff: result.handoff,
+          activeAdapter: result.delivery.mode === "active" ? result.delivery.adapter : null,
+          dispatch: result.delivery.mode === "active" ? result.delivery.dispatch : null
+        })
+      );
+    },
+    renderStatus(result) {
+      applyStatus(result);
+    },
+    renderError(code, canRetry = false) {
+      operationBusy = false;
+      retryable = canRetry;
+      if (code === "EXTERNAL_AGENT_BUSY") dispatchBlocksSend = true;
+      status.dataset.state = "error";
+      status.textContent = canRetry ? `${messages.error(code)} ${messages.retry}.` : messages.error(code);
+      refreshActions();
+      options.onViewChange();
+    },
+    setBusy(nextBusy) {
+      operationBusy = nextBusy;
+      refreshActions();
+    },
+    setContextReady(ready) {
+      contextReady = ready;
+      refreshActions();
+    },
+    setSelectionVisible(nextVisible) {
+      visible = nextVisible;
+      root.hidden = !nextVisible;
+      sendButton.hidden = !nextVisible;
+      if (!nextVisible) settleDisclosure(false);
+      refreshActions();
+    },
+    dispose() {
+      settleDisclosure(false);
+      disclosure.removeEventListener("keydown", handleDisclosureKeydown);
+      settings.removeEventListener("toggle", options.onViewChange);
+      unsubscribeLocale();
+    }
+  });
+}
+
+// src/ui/external-handoff-contract.ts
+var EXTERNAL_HANDOFF_EXTENSION_KEY = /* @__PURE__ */ Symbol.for("spotpatch.external-handoff.v1");
+function registerExternalHandoffExtension(extension) {
+  globalThis[EXTERNAL_HANDOFF_EXTENSION_KEY] = extension;
+}
+function getExternalHandoffExtension() {
+  return globalThis[EXTERNAL_HANDOFF_EXTENSION_KEY];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExternalHandoffPanel,
+  createExternalHandoffWorkflow,
+  getExternalHandoffExtension,
+  registerExternalHandoffExtension
+});
+//# sourceMappingURL=external-handoff-panel.cjs.map