@spotpatch/shared 1.9.0 → 1.11.0

package/dist/index.cjs

@@ -44,6 +44,32 @@ __export(index_exports, {
   DEFAULT_DATA_FLOW_LIMITS: () => DEFAULT_DATA_FLOW_LIMITS,
   DEFAULT_RUNTIME_DATA_FLOW_LIMITS: () => DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
   ERROR_CODES: () => ERROR_CODES,
+  ERROR_CODE_VALUES: () => ERROR_CODE_VALUES,
+  EXTERNAL_AGENT_ACTIONS: () => EXTERNAL_AGENT_ACTIONS,
+  EXTERNAL_AGENT_AUTH_READINESS: () => EXTERNAL_AGENT_AUTH_READINESS,
+  EXTERNAL_AGENT_CONNECTION_STATES: () => EXTERNAL_AGENT_CONNECTION_STATES,
+  EXTERNAL_AGENT_CONTROL_LIMITS: () => EXTERNAL_AGENT_CONTROL_LIMITS,
+  EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION: () => EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+  EXTERNAL_AGENT_DELIVERY_STATUSES: () => EXTERNAL_AGENT_DELIVERY_STATUSES,
+  EXTERNAL_AGENT_ERROR_CODES: () => EXTERNAL_AGENT_ERROR_CODES,
+  EXTERNAL_AGENT_ERROR_RECOVERABILITY: () => EXTERNAL_AGENT_ERROR_RECOVERABILITY,
+  EXTERNAL_AGENT_ERROR_STAGES: () => EXTERNAL_AGENT_ERROR_STAGES,
+  EXTERNAL_AGENT_EXECUTION_STATUSES: () => EXTERNAL_AGENT_EXECUTION_STATUSES,
+  EXTERNAL_AGENT_GRANT_STATES: () => EXTERNAL_AGENT_GRANT_STATES,
+  EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS: () => EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS,
+  EXTERNAL_AGENT_MANAGED_PHASES: () => EXTERNAL_AGENT_MANAGED_PHASES,
+  EXTERNAL_AGENT_MANAGED_PROFILE: () => EXTERNAL_AGENT_MANAGED_PROFILE,
+  EXTERNAL_AGENT_MODES: () => EXTERNAL_AGENT_MODES,
+  EXTERNAL_AGENT_VALIDATION_OUTCOMES: () => EXTERNAL_AGENT_VALIDATION_OUTCOMES,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS: () => EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES: () => EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES,
+  EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION: () => EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION,
+  EXTERNAL_HANDOFF_DISPATCH_PHASES: () => EXTERNAL_HANDOFF_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_FRAMEWORKS: () => EXTERNAL_HANDOFF_FRAMEWORKS,
+  EXTERNAL_HANDOFF_LIMITS: () => EXTERNAL_HANDOFF_LIMITS,
+  EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES: () => EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION: () => EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION,
+  EXTERNAL_HANDOFF_STATES: () => EXTERNAL_HANDOFF_STATES,
   MAX_ANNOTATION_INSTRUCTION_CHARACTERS: () => MAX_ANNOTATION_INSTRUCTION_CHARACTERS,
   MAX_ANNOTATION_TARGETS: () => MAX_ANNOTATION_TARGETS,
   MAX_TARGET_INSTRUCTION_CHARACTERS: () => MAX_TARGET_INSTRUCTION_CHARACTERS,
@@ -58,6 +84,7 @@ __export(index_exports, {
   SPOTPATCH_REPOSITORY_URL: () => SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER: () => SPOTPATCH_TOKEN_HEADER,
   SpotPatchError: () => SpotPatchError,
+  activeAdapterSummarySchema: () => activeAdapterSummarySchema,
   agentCapabilityRequestSchema: () => agentCapabilityRequestSchema,
   agentCapabilitySnapshotSchema: () => agentCapabilitySnapshotSchema,
   agentChangedFileSchema: () => agentChangedFileSchema,
@@ -74,10 +101,37 @@ __export(index_exports, {
   dataDependencySchema: () => dataDependencySchema,
   dataFlowComponentReportRequestSchema: () => dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema: () => dataFlowPageReportRequestSchema,
+  dispatchSummarySchema: () => dispatchSummarySchema,
+  externalAgentControlCancelRequestSchema: () => externalAgentControlCancelRequestSchema,
+  externalAgentControlConnectRequestSchema: () => externalAgentControlConnectRequestSchema,
+  externalAgentControlDisconnectRequestSchema: () => externalAgentControlDisconnectRequestSchema,
+  externalAgentControlStatusRequestSchema: () => externalAgentControlStatusRequestSchema,
+  externalAgentControlStatusSchema: () => externalAgentControlStatusSchema,
+  externalAgentErrorSchema: () => externalAgentErrorSchema,
+  externalAgentEventSchema: () => externalAgentEventSchema,
+  externalAgentEventsRequestSchema: () => externalAgentEventsRequestSchema,
+  externalAgentManagedResultSchema: () => externalAgentManagedResultSchema,
+  externalAgentResultRequestSchema: () => externalAgentResultRequestSchema,
+  externalHandoffCapabilityRequestSchema: () => externalHandoffCapabilityRequestSchema,
+  externalHandoffCapabilitySchema: () => externalHandoffCapabilitySchema,
+  externalHandoffPublishDeliverySchema: () => externalHandoffPublishDeliverySchema,
+  externalHandoffPublishRequestSchema: () => externalHandoffPublishRequestSchema,
+  externalHandoffPublishResultSchema: () => externalHandoffPublishResultSchema,
+  externalHandoffReportableDispatchPhaseSchema: () => externalHandoffReportableDispatchPhaseSchema,
+  externalHandoffResolveDeliveryRequestSchema: () => externalHandoffResolveDeliveryRequestSchema,
+  externalHandoffSnapshotSchema: () => externalHandoffSnapshotSchema,
+  externalHandoffStatusRequestSchema: () => externalHandoffStatusRequestSchema,
+  externalHandoffStatusResultSchema: () => externalHandoffStatusResultSchema,
+  externalHandoffSummarySchema: () => externalHandoffSummarySchema,
   formatSourceMarker: () => formatSourceMarker,
   getAgentJobEndpoint: () => getAgentJobEndpoint,
+  isErrorCode: () => isErrorCode,
   isSensitiveName: () => isSensitiveName,
   limitDataFlowReportCollections: () => limitDataFlowReportCollections,
+  managedCheckSummarySchema: () => managedCheckSummarySchema,
+  managedFileSummarySchema: () => managedFileSummarySchema,
+  managedTaskStatusSchema: () => managedTaskStatusSchema,
+  managedTimingSummarySchema: () => managedTimingSummarySchema,
   networkObservationSchema: () => networkObservationSchema,
   openEditorRequestSchema: () => openEditorRequestSchema,
   pageDataFlowReportSchema: () => pageDataFlowReportSchema,
@@ -125,6 +179,24 @@ var ERROR_CODES = {
   AGENT_BUSY: "AGENT_BUSY",
   AGENT_LIMIT_EXCEEDED: "AGENT_LIMIT_EXCEEDED",
   AGENT_CANCELLED: "AGENT_CANCELLED",
+  EXTERNAL_HANDOFF_DISABLED: "EXTERNAL_HANDOFF_DISABLED",
+  EXTERNAL_HANDOFF_UNAVAILABLE: "EXTERNAL_HANDOFF_UNAVAILABLE",
+  HANDOFF_VALIDATION_FAILED: "HANDOFF_VALIDATION_FAILED",
+  HANDOFF_SOURCE_STALE: "HANDOFF_SOURCE_STALE",
+  HANDOFF_NOT_FOUND: "HANDOFF_NOT_FOUND",
+  HANDOFF_EXPIRED: "HANDOFF_EXPIRED",
+  HANDOFF_CURSOR_INVALID: "HANDOFF_CURSOR_INVALID",
+  HANDOFF_RESPONSE_TOO_LARGE: "HANDOFF_RESPONSE_TOO_LARGE",
+  BRIDGE_UNAUTHORIZED: "BRIDGE_UNAUTHORIZED",
+  BRIDGE_PROTOCOL_MISMATCH: "BRIDGE_PROTOCOL_MISMATCH",
+  BRIDGE_BUSY: "BRIDGE_BUSY",
+  EXTERNAL_AGENT_BUSY: "EXTERNAL_AGENT_BUSY",
+  ACTIVE_ADAPTER_CONFLICT: "ACTIVE_ADAPTER_CONFLICT",
+  ACTIVE_ADAPTER_LEASE_INVALID: "ACTIVE_ADAPTER_LEASE_INVALID",
+  ACTIVE_DISPATCH_INVALID: "ACTIVE_DISPATCH_INVALID",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_AMBIGUOUS: "SESSION_AMBIGUOUS",
+  SESSION_CLOSED: "SESSION_CLOSED",
   WORKTREE_DIRTY: "WORKTREE_DIRTY",
   WORKTREE_NOT_REPOSITORY: "WORKTREE_NOT_REPOSITORY",
   WORKTREE_OPERATION_IN_PROGRESS: "WORKTREE_OPERATION_IN_PROGRESS",
@@ -142,6 +214,10 @@ var ERROR_CODES = {
   APPLY_CONFLICT: "APPLY_CONFLICT",
   INTERNAL_ERROR: "INTERNAL_ERROR"
 };
+var ERROR_CODE_VALUES = Object.freeze(Object.values(ERROR_CODES));
+function isErrorCode(value) {
+  return typeof value === "string" && ERROR_CODE_VALUES.includes(value);
+}
 
 // src/security/redaction.ts
 var INLINE_DATA_PATTERN = /data:[^\s"'<>]*;base64,[a-z0-9+/_=-]+/giu;
@@ -712,7 +788,17 @@ var SPOTPATCH_ENDPOINTS = Object.freeze({
   dataFlowPageReport: `${SPOTPATCH_API_BASE}/data-flow/page-report`,
   agentCapability: `${SPOTPATCH_API_BASE}/agent/capability`,
   agentWorkspaceHealth: `${SPOTPATCH_API_BASE}/agent/workspace-health`,
-  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`
+  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`,
+  externalHandoffCapability: `${SPOTPATCH_API_BASE}/external-handoff/capability`,
+  externalHandoffPublish: `${SPOTPATCH_API_BASE}/external-handoff/publish`,
+  externalHandoffStatus: `${SPOTPATCH_API_BASE}/external-handoff/status`,
+  externalHandoffResolveDelivery: `${SPOTPATCH_API_BASE}/external-handoff/resolve-delivery`,
+  externalAgentControlStatus: `${SPOTPATCH_API_BASE}/external-agent/control/status`,
+  externalAgentControlConnect: `${SPOTPATCH_API_BASE}/external-agent/control/connect`,
+  externalAgentControlDisconnect: `${SPOTPATCH_API_BASE}/external-agent/control/disconnect`,
+  externalAgentControlCancel: `${SPOTPATCH_API_BASE}/external-agent/control/cancel`,
+  externalAgentEvents: `${SPOTPATCH_API_BASE}/external-agent/events`,
+  externalAgentResult: `${SPOTPATCH_API_BASE}/external-agent/result`
 });
 function getAgentJobEndpoint(jobId, action) {
   return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
@@ -834,6 +920,7 @@ var runtimeConfigBaseShape = {
   debug: import_zod2.z.boolean(),
   dataFlow: runtimeDataFlowConfigSchema,
   editor: import_zod2.z.enum(SPOTPATCH_EDITOR_PREFERENCES),
+  externalAgent: import_zod2.z.strictObject({ enabled: import_zod2.z.boolean() }),
   frameworkVersion: boundedText2(64),
   locale: import_zod2.z.enum(SPOTPATCH_LOCALE_PREFERENCES),
   maxTargets: import_zod2.z.number().int().min(1).max(MAX_ANNOTATION_TARGETS),
@@ -879,110 +966,345 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
-// src/protocol/requests.ts
+// src/protocol/external-agent-control.ts
 var import_zod3 = require("zod");
-var runtimeBootstrapRequestSchema = import_zod3.z.strictObject({});
-var sourceCoordinatesSchema = import_zod3.z.strictObject({
-  fileId: import_zod3.z.string().min(1).max(128),
-  line: import_zod3.z.number().int().positive(),
-  column: import_zod3.z.number().int().positive()
+var EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION = 1;
+var EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS = Object.freeze(["codex"]);
+var EXTERNAL_AGENT_MODES = Object.freeze(["inbox", "managed"]);
+var EXTERNAL_AGENT_CONNECTION_STATES = Object.freeze([
+  "disconnected",
+  "diagnosing",
+  "awaiting-consent",
+  "connecting",
+  "ready",
+  "busy",
+  "degraded",
+  "error",
+  "disconnecting"
+]);
+var EXTERNAL_AGENT_AUTH_READINESS = Object.freeze([
+  "authenticated",
+  "auth-not-required",
+  "signed-out",
+  "unknown"
+]);
+var EXTERNAL_AGENT_GRANT_STATES = Object.freeze([
+  "missing",
+  "valid",
+  "invalid"
+]);
+var EXTERNAL_AGENT_DELIVERY_STATUSES = Object.freeze([
+  "queued",
+  "dispatching",
+  "accepted",
+  "unknown"
+]);
+var EXTERNAL_AGENT_EXECUTION_STATUSES = Object.freeze([
+  "not-observable",
+  "started",
+  "terminal-succeeded",
+  "terminal-failed",
+  "interrupted",
+  "unknown"
+]);
+var EXTERNAL_AGENT_MANAGED_PHASES = Object.freeze([
+  "preparing",
+  "running",
+  "auditing",
+  "validating",
+  "applying",
+  "completed",
+  "review-required",
+  "failed",
+  "cancelled",
+  "cleanup-warning"
+]);
+var EXTERNAL_AGENT_VALIDATION_OUTCOMES = Object.freeze([
+  "passed",
+  "failed",
+  "not-configured",
+  "unavailable"
+]);
+var EXTERNAL_AGENT_CHECK_OUTCOMES = Object.freeze([
+  "passed",
+  "failed",
+  "unavailable"
+]);
+var EXTERNAL_AGENT_ERROR_STAGES = Object.freeze([
+  "integration",
+  "binary",
+  "handshake",
+  "auth",
+  "model",
+  "protocol",
+  "snapshot",
+  "audit",
+  "validation",
+  "apply",
+  "cleanup"
+]);
+var EXTERNAL_AGENT_ERROR_RECOVERABILITY = Object.freeze([
+  "retry",
+  "user-action",
+  "reconfigure",
+  "none"
+]);
+var EXTERNAL_AGENT_ERROR_CODES = Object.freeze([
+  "AGENT_BINARY_NOT_FOUND",
+  "AGENT_BINARY_UNTRUSTED",
+  "AGENT_VERSION_UNSUPPORTED",
+  "APP_SERVER_HANDSHAKE_FAILED",
+  "AGENT_AUTH_REQUIRED",
+  "AGENT_MODEL_UNAVAILABLE",
+  "AGENT_PROTOCOL_INCOMPATIBLE",
+  "CODEX_CONFIG_ISOLATION_UNSUPPORTED",
+  "MANAGED_GRANT_INVALID",
+  "MANAGED_PLATFORM_UNSUPPORTED",
+  "MANAGED_GIT_REQUIRED",
+  "MANAGED_SNAPSHOT_FAILED",
+  "MANAGED_SCOPE_VIOLATION",
+  "MANAGED_CHANGE_LIMIT_EXCEEDED",
+  "MANAGED_VALIDATION_FAILED",
+  "MANAGED_WORKSPACE_CONFLICT",
+  "MANAGED_APPLY_FAILED",
+  "MANAGED_CLEANUP_INCOMPLETE"
+]);
+var EXTERNAL_AGENT_ACTIONS = Object.freeze([
+  "install-agent",
+  "use-supported-version",
+  "sign-in",
+  "choose-available-model",
+  "use-inbox",
+  "confirm-managed-access",
+  "review-candidate-diff",
+  "review-workspace-conflict",
+  "retry",
+  "inspect-cleanup-warning"
+]);
+var EXTERNAL_AGENT_MANAGED_PROFILE = "managed-apply-v1";
+var EXTERNAL_AGENT_CONTROL_LIMITS = Object.freeze({
+  maximumEventSubscribers: 4,
+  eventHeartbeatMs: 15e3,
+  eventReconnectMinimumMs: 500,
+  eventReconnectMaximumMs: 1e4,
+  maximumChangedFiles: DEFAULT_AGENT_LIMITS.maxChangedFiles,
+  maximumChecks: 64,
+  maximumEventLineBytes: 64 * 1024,
+  maximumResultDiffBytes: DEFAULT_AGENT_LIMITS.maxDiffBytes
+});
+var isoTimestampSchema = import_zod3.z.iso.datetime();
+var requestIdSchema = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var safeRelativePathSchema = import_zod3.z.string().min(1).max(4096).superRefine((value, context) => {
+  const segments = value.split("/");
+  if (value.startsWith("/") || value.includes("\\") || segments.some(
+    (segment) => segment.length === 0 || segment === "." || segment === ".."
+  )) {
+    context.addIssue({ code: "custom", message: "Expected a safe relative path." });
+  }
+});
+var externalAgentErrorSchema = import_zod3.z.strictObject({
+  code: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_CODES),
+  stage: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_STAGES),
+  recoverability: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_RECOVERABILITY),
+  action: import_zod3.z.enum(EXTERNAL_AGENT_ACTIONS)
+});
+var managedFileSummarySchema = import_zod3.z.strictObject({
+  path: safeRelativePathSchema,
+  additions: import_zod3.z.number().int().nonnegative(),
+  deletions: import_zod3.z.number().int().nonnegative()
+});
+var managedCheckSummarySchema = import_zod3.z.strictObject({
+  id: import_zod3.z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/u),
+  outcome: import_zod3.z.enum(EXTERNAL_AGENT_CHECK_OUTCOMES),
+  durationMs: import_zod3.z.number().int().nonnegative(),
+  exitCode: import_zod3.z.number().int().optional()
+});
+var managedTimingSummarySchema = import_zod3.z.strictObject({
+  preparing: import_zod3.z.number().int().nonnegative().optional(),
+  agent: import_zod3.z.number().int().nonnegative().optional(),
+  auditing: import_zod3.z.number().int().nonnegative().optional(),
+  validating: import_zod3.z.number().int().nonnegative().optional(),
+  applying: import_zod3.z.number().int().nonnegative().optional(),
+  total: import_zod3.z.number().int().nonnegative().optional()
+});
+var managedTaskStatusSchema = import_zod3.z.strictObject({
+  revision: import_zod3.z.number().int().positive(),
+  deliveryStatus: import_zod3.z.enum(EXTERNAL_AGENT_DELIVERY_STATUSES),
+  executionStatus: import_zod3.z.enum(EXTERNAL_AGENT_EXECUTION_STATUSES),
+  managedPhase: import_zod3.z.enum(EXTERNAL_AGENT_MANAGED_PHASES),
+  validationOutcome: import_zod3.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES).optional(),
+  files: import_zod3.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: import_zod3.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  resultExpiresAt: isoTimestampSchema.optional()
+});
+var externalAgentControlStatusSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION),
+  sequence: import_zod3.z.number().int().nonnegative(),
+  mode: import_zod3.z.enum(EXTERNAL_AGENT_MODES),
+  adapter: import_zod3.z.strictObject({
+    kind: import_zod3.z.enum(EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS),
+    maturity: import_zod3.z.literal("experimental"),
+    availability: import_zod3.z.enum(["available", "unavailable"])
+  }),
+  connectionState: import_zod3.z.enum(EXTERNAL_AGENT_CONNECTION_STATES),
+  authReadiness: import_zod3.z.enum(EXTERNAL_AGENT_AUTH_READINESS),
+  grantState: import_zod3.z.enum(EXTERNAL_AGENT_GRANT_STATES),
+  requestedModel: import_zod3.z.string().min(1).max(128).optional(),
+  effectiveModel: import_zod3.z.string().min(1).max(128).optional(),
+  task: managedTaskStatusSchema.optional(),
+  error: externalAgentErrorSchema.optional(),
+  updatedAt: isoTimestampSchema
+});
+var externalAgentControlStatusRequestSchema = import_zod3.z.strictObject({});
+var externalAgentControlConnectRequestSchema = import_zod3.z.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: import_zod3.z.literal("codex"),
+  profile: import_zod3.z.literal(EXTERNAL_AGENT_MANAGED_PROFILE)
+});
+var externalAgentControlDisconnectRequestSchema = import_zod3.z.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: import_zod3.z.literal("codex"),
+  revokeGrant: import_zod3.z.boolean()
+});
+var externalAgentControlCancelRequestSchema = import_zod3.z.strictObject({
+  requestId: requestIdSchema,
+  revision: import_zod3.z.number().int().positive()
+});
+var externalAgentEventsRequestSchema = import_zod3.z.strictObject({
+  afterSequence: import_zod3.z.number().int().nonnegative().optional()
+});
+var externalAgentEventSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.strictObject({
+    type: import_zod3.z.literal("status"),
+    data: externalAgentControlStatusSchema
+  }),
+  import_zod3.z.strictObject({
+    type: import_zod3.z.literal("heartbeat"),
+    sequence: import_zod3.z.number().int().nonnegative(),
+    emittedAt: isoTimestampSchema
+  })
+]);
+var externalAgentResultRequestSchema = import_zod3.z.strictObject({
+  revision: import_zod3.z.number().int().positive()
+});
+var externalAgentManagedResultSchema = import_zod3.z.strictObject({
+  revision: import_zod3.z.number().int().positive(),
+  diff: import_zod3.z.string().max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumResultDiffBytes),
+  files: import_zod3.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: import_zod3.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  validationOutcome: import_zod3.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES),
+  expiresAt: isoTimestampSchema
+});
+
+// src/protocol/external-handoff.ts
+var import_zod5 = require("zod");
+
+// src/protocol/requests.ts
+var import_zod4 = require("zod");
+var runtimeBootstrapRequestSchema = import_zod4.z.strictObject({});
+var sourceCoordinatesSchema = import_zod4.z.strictObject({
+  fileId: import_zod4.z.string().min(1).max(128),
+  line: import_zod4.z.number().int().positive(),
+  column: import_zod4.z.number().int().positive()
 });
 var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: import_zod3.z.number().int().positive()
+  maxLines: import_zod4.z.number().int().positive()
 }).strict();
 var openEditorRequestSchema = sourceCoordinatesSchema.strict();
 var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
-  schemaVersion: import_zod3.z.literal(1),
-  sourceVersion: import_zod3.z.string().min(1).max(128).optional()
+  schemaVersion: import_zod4.z.literal(1),
+  sourceVersion: import_zod4.z.string().min(1).max(128).optional()
 }).strict();
-var dataFlowComponentIdentityRequestSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(1),
-  componentSourceId: import_zod3.z.string().min(1).max(128),
-  sourceVersion: import_zod3.z.string().min(1).max(128)
+var dataFlowComponentIdentityRequestSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(1),
+  componentSourceId: import_zod4.z.string().min(1).max(128),
+  sourceVersion: import_zod4.z.string().min(1).max(128)
 });
-var dataFlowComponentReportRequestSchema = import_zod3.z.union([
+var dataFlowComponentReportRequestSchema = import_zod4.z.union([
   dataFlowSourceCoordinatesRequestSchema,
   dataFlowComponentIdentityRequestSchema
 ]);
-var dataFlowPageReportRequestSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(1),
-  targets: import_zod3.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
+var dataFlowPageReportRequestSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(1),
+  targets: import_zod4.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
 });
-var profileIdSchema2 = import_zod3.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString = (maximum) => import_zod3.z.string().max(maximum);
-var sourceRefSchema = import_zod3.z.strictObject({
+var profileIdSchema2 = import_zod4.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString = (maximum) => import_zod4.z.string().max(maximum);
+var sourceRefSchema = import_zod4.z.strictObject({
   fileId: boundedString(128).optional(),
   relativePath: boundedString(1024).optional(),
-  line: import_zod3.z.number().int().positive().optional(),
-  column: import_zod3.z.number().int().positive().optional(),
-  origin: import_zod3.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
-  confidence: import_zod3.z.enum(["exact", "probable", "approximate", "unknown"])
+  line: import_zod4.z.number().int().positive().optional(),
+  column: import_zod4.z.number().int().positive().optional(),
+  origin: import_zod4.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  confidence: import_zod4.z.enum(["exact", "probable", "approximate", "unknown"])
 });
-var matchedStyleRuleSchema = import_zod3.z.strictObject({
+var matchedStyleRuleSchema = import_zod4.z.strictObject({
   selector: boundedString(2048),
   declarations: boundedString(8192),
   source: boundedString(1024).optional(),
   media: boundedString(1024).optional()
 });
-var codeContextSchema = import_zod3.z.strictObject({
+var codeContextSchema = import_zod4.z.strictObject({
   relativePath: boundedString(1024),
-  language: import_zod3.z.enum(["tsx", "jsx"]),
-  startLine: import_zod3.z.number().int().positive(),
-  endLine: import_zod3.z.number().int().positive(),
+  language: import_zod4.z.enum(["tsx", "jsx"]),
+  startLine: import_zod4.z.number().int().positive(),
+  endLine: import_zod4.z.number().int().positive(),
   excerpt: boundedString(16e3),
-  boundary: import_zod3.z.enum(["component", "nearby-lines"])
+  boundary: import_zod4.z.enum(["component", "nearby-lines"])
 });
-var pageContextSchema = import_zod3.z.strictObject({
+var pageContextSchema = import_zod4.z.strictObject({
   url: boundedString(2048),
   pathname: boundedString(2048),
   title: boundedString(1024),
-  viewportWidth: import_zod3.z.number().nonnegative(),
-  viewportHeight: import_zod3.z.number().nonnegative(),
-  devicePixelRatio: import_zod3.z.number().positive()
+  viewportWidth: import_zod4.z.number().nonnegative(),
+  viewportHeight: import_zod4.z.number().nonnegative(),
+  devicePixelRatio: import_zod4.z.number().positive()
 });
-var spotTargetContextRequestSchema = import_zod3.z.strictObject({
-  instruction: import_zod3.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+var spotTargetContextRequestSchema = import_zod4.z.strictObject({
+  instruction: import_zod4.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
   page: pageContextSchema.optional(),
   source: sourceRefSchema,
-  react: import_zod3.z.strictObject({
-    supported: import_zod3.z.boolean(),
+  react: import_zod4.z.strictObject({
+    supported: import_zod4.z.boolean(),
     version: boundedString(64).optional(),
     componentName: boundedString(256).optional(),
     componentSourceId: boundedString(128).optional(),
     sourceVersion: boundedString(128).optional(),
-    componentStack: import_zod3.z.array(boundedString(256)).max(64),
+    componentStack: import_zod4.z.array(boundedString(256)).max(64),
     source: sourceRefSchema.optional()
   }),
-  element: import_zod3.z.strictObject({
+  element: import_zod4.z.strictObject({
     tagName: boundedString(128),
     selector: boundedString(2048),
     sanitizedHtml: boundedString(8192),
     textPreview: boundedString(2048).optional(),
     role: boundedString(256).optional(),
-    rect: import_zod3.z.strictObject({
-      x: import_zod3.z.number(),
-      y: import_zod3.z.number(),
-      width: import_zod3.z.number().nonnegative(),
-      height: import_zod3.z.number().nonnegative()
+    rect: import_zod4.z.strictObject({
+      x: import_zod4.z.number(),
+      y: import_zod4.z.number(),
+      width: import_zod4.z.number().nonnegative(),
+      height: import_zod4.z.number().nonnegative()
     })
   }),
-  styles: import_zod3.z.strictObject({
-    classNames: import_zod3.z.array(boundedString(512)).max(256),
+  styles: import_zod4.z.strictObject({
+    classNames: import_zod4.z.array(boundedString(512)).max(256),
     inlineStyle: boundedString(8192).optional(),
-    matchedRules: import_zod3.z.array(matchedStyleRuleSchema).max(256),
-    computed: import_zod3.z.record(boundedString(256), boundedString(2048)),
-    warnings: import_zod3.z.array(boundedString(1024)).max(64)
+    matchedRules: import_zod4.z.array(matchedStyleRuleSchema).max(256),
+    computed: import_zod4.z.record(boundedString(256), boundedString(2048)),
+    warnings: import_zod4.z.array(boundedString(1024)).max(64)
   }),
   code: codeContextSchema.optional(),
-  warnings: import_zod3.z.array(boundedString(1024)).max(64)
+  warnings: import_zod4.z.array(boundedString(1024)).max(64)
 });
-var spotAnnotationRequestSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(3),
+var spotAnnotationRequestSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(3),
   id: boundedString(128),
-  locale: import_zod3.z.enum(SPOTPATCH_LOCALES),
+  locale: import_zod4.z.enum(SPOTPATCH_LOCALES),
   page: pageContextSchema,
-  targets: import_zod3.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
-  createdAt: import_zod3.z.iso.datetime()
+  targets: import_zod4.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  createdAt: import_zod4.z.iso.datetime()
 }).superRefine((annotation, context) => {
   const total = annotation.targets.reduce(
     (characters, target) => characters + target.instruction.length,
@@ -996,53 +1318,212 @@ var spotAnnotationRequestSchema = import_zod3.z.strictObject({
     });
   }
 });
-var agentCapabilityRequestSchema = import_zod3.z.strictObject({
+var agentCapabilityRequestSchema = import_zod4.z.strictObject({
   providerProfileId: profileIdSchema2,
   modelProfileId: profileIdSchema2
 });
-var agentWorkspaceHealthRequestSchema = import_zod3.z.strictObject({});
-var agentJobCreateRequestSchema = import_zod3.z.strictObject({
+var agentWorkspaceHealthRequestSchema = import_zod4.z.strictObject({});
+var agentJobCreateRequestSchema = import_zod4.z.strictObject({
   annotation: spotAnnotationRequestSchema,
-  applyMode: import_zod3.z.enum(AGENT_APPLY_MODES).optional(),
+  applyMode: import_zod4.z.enum(AGENT_APPLY_MODES).optional(),
   providerProfileId: profileIdSchema2,
   modelProfileId: profileIdSchema2,
-  providerDataConsent: import_zod3.z.literal(true),
-  trustedFastModeConsent: import_zod3.z.literal(true).optional(),
-  workingTreeMode: import_zod3.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+  providerDataConsent: import_zod4.z.literal(true),
+  trustedFastModeConsent: import_zod4.z.literal(true).optional(),
+  workingTreeMode: import_zod4.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+});
+var agentJobActionRequestSchema = import_zod4.z.strictObject({});
+
+// src/protocol/external-handoff-constants.ts
+var EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION = 1;
+var EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION = 2;
+var EXTERNAL_HANDOFF_STATES = Object.freeze([
+  "available",
+  "expired",
+  "superseded"
+]);
+var EXTERNAL_HANDOFF_FRAMEWORKS = Object.freeze(["vite", "next"]);
+var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS = Object.freeze([
+  "claude-channel",
+  "codex-app-server"
+]);
+var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES = Object.freeze([
+  "ready",
+  "busy",
+  "blocked"
+]);
+var EXTERNAL_HANDOFF_DISPATCH_PHASES = Object.freeze([
+  "queued",
+  "dispatching",
+  "dispatched",
+  "working",
+  "completed",
+  "failed",
+  "delivery-unknown"
+]);
+var EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES = Object.freeze([
+  "dispatching",
+  "dispatched",
+  "working",
+  "completed",
+  "failed",
+  "delivery-unknown"
+]);
+var EXTERNAL_HANDOFF_LIMITS = Object.freeze({
+  maximumSnapshotBytes: 256 * 1024,
+  maximumPublishBodyBytes: 256 * 1024,
+  maximumBrokerRequestBytes: 8 * 1024,
+  maximumDescriptorBytes: 8 * 1024,
+  maximumHistorySummaries: 8,
+  maximumConnectorReceipts: 64,
+  handoffTtlMs: 15 * 60 * 1e3,
+  defaultWaitMs: 2e4,
+  maximumWaitMs: 25e3,
+  maximumWaiters: 8,
+  maximumDescriptorsPerScan: 32,
+  maximumProjectAncestors: 64,
+  maximumBrokerHeaderBytes: 8 * 1024,
+  maximumBrokerSockets: 32,
+  brokerDiscoveryTimeoutMs: 750,
+  brokerRequestTimeoutMs: 2e3,
+  brokerWaitGraceMs: 2e3,
+  maximumSetupConfigBytes: 1024 * 1024,
+  maximumRequestIdRecords: 16,
+  requestIdTtlMs: 15 * 60 * 1e3,
+  activeHeartbeatIntervalMs: 3e3,
+  activeLeaseDurationMs: 1e4,
+  activeTransportWriteTimeoutMs: 5e3,
+  activeDispatchTimeoutMs: 30 * 60 * 1e3,
+  activeStatusPollMs: 1e3
+});
+
+// src/protocol/external-handoff.ts
+var opaqueIdSchema2 = import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var isoTimestampSchema2 = import_zod5.z.iso.datetime();
+var externalHandoffReportableDispatchPhaseSchema = import_zod5.z.enum(
+  EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES
+);
+var externalHandoffPageSummarySchema = import_zod5.z.strictObject({
+  origin: import_zod5.z.string().min(1).max(2048),
+  pathname: import_zod5.z.string().min(1).max(2048)
+});
+var externalHandoffSummarySchema = import_zod5.z.strictObject({
+  sessionId: opaqueIdSchema2,
+  framework: import_zod5.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  revision: import_zod5.z.number().int().positive(),
+  cursor: opaqueIdSchema2,
+  targetCount: import_zod5.z.number().int().positive(),
+  page: externalHandoffPageSummarySchema,
+  publishedAt: isoTimestampSchema2,
+  expiresAt: isoTimestampSchema2,
+  state: import_zod5.z.enum(EXTERNAL_HANDOFF_STATES),
+  pickupCount: import_zod5.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
+  pickedUpAt: isoTimestampSchema2.optional()
+});
+var externalHandoffSnapshotSchema = import_zod5.z.strictObject({
+  schemaVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  cursor: opaqueIdSchema2,
+  session: import_zod5.z.strictObject({
+    id: opaqueIdSchema2,
+    framework: import_zod5.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
+  }),
+  revision: import_zod5.z.number().int().positive(),
+  publishedAt: isoTimestampSchema2,
+  expiresAt: isoTimestampSchema2,
+  annotation: spotAnnotationRequestSchema
+});
+var activeAdapterSummarySchema = import_zod5.z.strictObject({
+  kind: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  state: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
+  canDispatch: import_zod5.z.boolean(),
+  connectedAt: isoTimestampSchema2,
+  updatedAt: isoTimestampSchema2
+}).superRefine((value, context) => {
+  if (value.canDispatch !== (value.state === "ready")) {
+    context.addIssue({
+      code: "custom",
+      message: "canDispatch must match the ready state.",
+      path: ["canDispatch"]
+    });
+  }
+});
+var dispatchSummarySchema = import_zod5.z.strictObject({
+  adapterKind: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  revision: import_zod5.z.number().int().positive(),
+  phase: import_zod5.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
+  updatedAt: isoTimestampSchema2
+});
+var externalHandoffCapabilityRequestSchema = import_zod5.z.strictObject({});
+var externalHandoffPublishRequestSchema = import_zod5.z.strictObject({
+  requestId: opaqueIdSchema2,
+  annotation: spotAnnotationRequestSchema
+});
+var externalHandoffStatusRequestSchema = import_zod5.z.strictObject({
+  cursor: opaqueIdSchema2.optional()
+});
+var externalHandoffResolveDeliveryRequestSchema = import_zod5.z.strictObject({
+  cursor: opaqueIdSchema2,
+  confirmation: import_zod5.z.literal("workspace-reviewed")
+});
+var externalHandoffCapabilitySchema = import_zod5.z.strictObject({
+  enabled: import_zod5.z.literal(true),
+  brokerReady: import_zod5.z.boolean(),
+  activeWaitCount: import_zod5.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
+  snapshotSchemaVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  brokerProtocolVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  activeAdapter: activeAdapterSummarySchema.nullable(),
+  dispatch: dispatchSummarySchema.nullable()
+});
+var externalHandoffPublishDeliverySchema = import_zod5.z.discriminatedUnion("mode", [
+  import_zod5.z.strictObject({ mode: import_zod5.z.literal("inbox") }),
+  import_zod5.z.strictObject({
+    mode: import_zod5.z.literal("active"),
+    adapter: activeAdapterSummarySchema,
+    dispatch: dispatchSummarySchema
+  })
+]);
+var externalHandoffPublishResultSchema = import_zod5.z.strictObject({
+  handoff: externalHandoffSummarySchema,
+  delivery: externalHandoffPublishDeliverySchema,
+  replayed: import_zod5.z.boolean()
+});
+var externalHandoffStatusResultSchema = import_zod5.z.strictObject({
+  handoff: externalHandoffSummarySchema,
+  activeAdapter: activeAdapterSummarySchema.nullable(),
+  dispatch: dispatchSummarySchema.nullable()
 });
-var agentJobActionRequestSchema = import_zod3.z.strictObject({});
 
 // src/protocol/agent-schemas.ts
-var import_zod4 = require("zod");
-var profileIdSchema3 = import_zod4.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString2 = (maximum) => import_zod4.z.string().max(maximum);
-var errorCodeSchema = import_zod4.z.enum(ERROR_CODES);
-var agentCapabilitySnapshotSchema = import_zod4.z.strictObject({
+var import_zod6 = require("zod");
+var profileIdSchema3 = import_zod6.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString2 = (maximum) => import_zod6.z.string().max(maximum);
+var errorCodeSchema = import_zod6.z.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = import_zod6.z.strictObject({
   providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
   modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
-  protocol: import_zod4.z.enum(["responses", "chat-completions"]),
-  state: import_zod4.z.enum(AGENT_CAPABILITY_STATES),
-  authenticated: import_zod4.z.boolean(),
-  modelAvailable: import_zod4.z.boolean(),
-  toolCalling: import_zod4.z.boolean(),
-  toolResultContinuation: import_zod4.z.boolean(),
-  streaming: import_zod4.z.boolean(),
-  checkedAt: import_zod4.z.iso.datetime().optional(),
+  protocol: import_zod6.z.enum(["responses", "chat-completions"]),
+  state: import_zod6.z.enum(AGENT_CAPABILITY_STATES),
+  authenticated: import_zod6.z.boolean(),
+  modelAvailable: import_zod6.z.boolean(),
+  toolCalling: import_zod6.z.boolean(),
+  toolResultContinuation: import_zod6.z.boolean(),
+  streaming: import_zod6.z.boolean(),
+  checkedAt: import_zod6.z.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-var agentWorkspaceHealthSnapshotSchema = import_zod4.z.strictObject({
-  state: import_zod4.z.enum(AGENT_WORKSPACE_STATES),
-  checkedAt: import_zod4.z.iso.datetime(),
-  changes: import_zod4.z.strictObject({
-    staged: import_zod4.z.number().int().nonnegative(),
-    unstaged: import_zod4.z.number().int().nonnegative(),
-    untracked: import_zod4.z.number().int().nonnegative(),
-    conflicted: import_zod4.z.number().int().nonnegative(),
-    total: import_zod4.z.number().int().nonnegative()
+var agentWorkspaceHealthSnapshotSchema = import_zod6.z.strictObject({
+  state: import_zod6.z.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: import_zod6.z.iso.datetime(),
+  changes: import_zod6.z.strictObject({
+    staged: import_zod6.z.number().int().nonnegative(),
+    unstaged: import_zod6.z.number().int().nonnegative(),
+    untracked: import_zod6.z.number().int().nonnegative(),
+    conflicted: import_zod6.z.number().int().nonnegative(),
+    total: import_zod6.z.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: import_zod4.z.boolean(),
+  canIncludeLocalChanges: import_zod6.z.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -1060,42 +1541,42 @@ var agentWorkspaceHealthSnapshotSchema = import_zod4.z.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = import_zod4.z.strictObject({
+var agentChangedFileSchema = import_zod6.z.strictObject({
   relativePath: boundedString2(1024),
-  kind: import_zod4.z.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: import_zod4.z.number().int().nonnegative(),
-  deletions: import_zod4.z.number().int().nonnegative()
+  kind: import_zod6.z.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: import_zod6.z.number().int().nonnegative(),
+  deletions: import_zod6.z.number().int().nonnegative()
 });
-var agentCheckResultSchema = import_zod4.z.strictObject({
+var agentCheckResultSchema = import_zod6.z.strictObject({
   checkId: profileIdSchema3,
   label: boundedString2(100),
-  status: import_zod4.z.enum(AGENT_CHECK_STATUSES),
-  durationMs: import_zod4.z.number().int().nonnegative(),
+  status: import_zod6.z.enum(AGENT_CHECK_STATUSES),
+  durationMs: import_zod6.z.number().int().nonnegative(),
   output: boundedString2(8e4)
 });
-var agentJobSnapshotSchema = import_zod4.z.strictObject({
-  jobId: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod4.z.enum(AGENT_JOB_STATUSES),
+var agentJobSnapshotSchema = import_zod6.z.strictObject({
+  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod6.z.enum(AGENT_JOB_STATUSES),
   providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
   modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
   phaseMessage: boundedString2(1024),
-  createdAt: import_zod4.z.iso.datetime(),
-  updatedAt: import_zod4.z.iso.datetime(),
-  canCancel: import_zod4.z.boolean(),
-  canApply: import_zod4.z.boolean(),
-  canRevert: import_zod4.z.boolean(),
+  createdAt: import_zod6.z.iso.datetime(),
+  updatedAt: import_zod6.z.iso.datetime(),
+  canCancel: import_zod6.z.boolean(),
+  canApply: import_zod6.z.boolean(),
+  canRevert: import_zod6.z.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = import_zod4.z.strictObject({
-  jobId: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+var agentJobResultSchema = import_zod6.z.strictObject({
+  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
   summary: boundedString2(8e4),
   diff: boundedString2(1e6),
-  files: import_zod4.z.array(agentChangedFileSchema).max(100),
-  checks: import_zod4.z.array(agentCheckResultSchema).max(100)
+  files: import_zod6.z.array(agentChangedFileSchema).max(100),
+  checks: import_zod6.z.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = import_zod4.z.strictObject({
+var agentJobResultResponseSchema = import_zod6.z.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -1107,44 +1588,44 @@ var agentJobResultResponseSchema = import_zod4.z.strictObject({
     });
   }
 });
-var agentJobEventBaseSchema = import_zod4.z.strictObject({
-  schemaVersion: import_zod4.z.literal(2),
-  sequence: import_zod4.z.number().int().positive(),
-  jobId: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod4.z.enum(AGENT_JOB_STATUSES),
-  timestamp: import_zod4.z.iso.datetime()
+var agentJobEventBaseSchema = import_zod6.z.strictObject({
+  schemaVersion: import_zod6.z.literal(2),
+  sequence: import_zod6.z.number().int().positive(),
+  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod6.z.enum(AGENT_JOB_STATUSES),
+  timestamp: import_zod6.z.iso.datetime()
 });
-var agentJobEventSchema = import_zod4.z.discriminatedUnion("type", [
+var agentJobEventSchema = import_zod6.z.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("snapshot"),
-    data: import_zod4.z.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: import_zod6.z.literal("snapshot"),
+    data: import_zod6.z.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("phase"),
-    data: import_zod4.z.strictObject({ message: boundedString2(1024) })
+    type: import_zod6.z.literal("phase"),
+    data: import_zod6.z.strictObject({ message: boundedString2(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("tool"),
-    data: import_zod4.z.strictObject({
-      turn: import_zod4.z.number().int().positive(),
+    type: import_zod6.z.literal("tool"),
+    data: import_zod6.z.strictObject({
+      turn: import_zod6.z.number().int().positive(),
       toolCallId: boundedString2(256),
       toolName: boundedString2(100),
-      state: import_zod4.z.enum(["started", "succeeded", "failed"]),
+      state: import_zod6.z.enum(["started", "succeeded", "failed"]),
       relativePath: boundedString2(1024).optional(),
       checkLabel: boundedString2(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("check"),
-    data: import_zod4.z.strictObject({ result: agentCheckResultSchema })
+    type: import_zod6.z.literal("check"),
+    data: import_zod6.z.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("result-ready"),
-    data: import_zod4.z.strictObject({ hasResult: import_zod4.z.literal(true) })
+    type: import_zod6.z.literal("result-ready"),
+    data: import_zod6.z.strictObject({ hasResult: import_zod6.z.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("error"),
-    data: import_zod4.z.strictObject({
+    type: import_zod6.z.literal("error"),
+    data: import_zod6.z.strictObject({
       code: errorCodeSchema,
       message: boundedString2(1024)
     })
@@ -1197,6 +1678,32 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   DEFAULT_DATA_FLOW_LIMITS,
   DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
   ERROR_CODES,
+  ERROR_CODE_VALUES,
+  EXTERNAL_AGENT_ACTIONS,
+  EXTERNAL_AGENT_AUTH_READINESS,
+  EXTERNAL_AGENT_CONNECTION_STATES,
+  EXTERNAL_AGENT_CONTROL_LIMITS,
+  EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+  EXTERNAL_AGENT_DELIVERY_STATUSES,
+  EXTERNAL_AGENT_ERROR_CODES,
+  EXTERNAL_AGENT_ERROR_RECOVERABILITY,
+  EXTERNAL_AGENT_ERROR_STAGES,
+  EXTERNAL_AGENT_EXECUTION_STATUSES,
+  EXTERNAL_AGENT_GRANT_STATES,
+  EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS,
+  EXTERNAL_AGENT_MANAGED_PHASES,
+  EXTERNAL_AGENT_MANAGED_PROFILE,
+  EXTERNAL_AGENT_MODES,
+  EXTERNAL_AGENT_VALIDATION_OUTCOMES,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES,
+  EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION,
+  EXTERNAL_HANDOFF_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_FRAMEWORKS,
+  EXTERNAL_HANDOFF_LIMITS,
+  EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION,
+  EXTERNAL_HANDOFF_STATES,
   MAX_ANNOTATION_INSTRUCTION_CHARACTERS,
   MAX_ANNOTATION_TARGETS,
   MAX_TARGET_INSTRUCTION_CHARACTERS,
@@ -1211,6 +1718,7 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER,
   SpotPatchError,
+  activeAdapterSummarySchema,
   agentCapabilityRequestSchema,
   agentCapabilitySnapshotSchema,
   agentChangedFileSchema,
@@ -1227,10 +1735,37 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   dataDependencySchema,
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
+  dispatchSummarySchema,
+  externalAgentControlCancelRequestSchema,
+  externalAgentControlConnectRequestSchema,
+  externalAgentControlDisconnectRequestSchema,
+  externalAgentControlStatusRequestSchema,
+  externalAgentControlStatusSchema,
+  externalAgentErrorSchema,
+  externalAgentEventSchema,
+  externalAgentEventsRequestSchema,
+  externalAgentManagedResultSchema,
+  externalAgentResultRequestSchema,
+  externalHandoffCapabilityRequestSchema,
+  externalHandoffCapabilitySchema,
+  externalHandoffPublishDeliverySchema,
+  externalHandoffPublishRequestSchema,
+  externalHandoffPublishResultSchema,
+  externalHandoffReportableDispatchPhaseSchema,
+  externalHandoffResolveDeliveryRequestSchema,
+  externalHandoffSnapshotSchema,
+  externalHandoffStatusRequestSchema,
+  externalHandoffStatusResultSchema,
+  externalHandoffSummarySchema,
   formatSourceMarker,
   getAgentJobEndpoint,
+  isErrorCode,
   isSensitiveName,
   limitDataFlowReportCollections,
+  managedCheckSummarySchema,
+  managedFileSummarySchema,
+  managedTaskStatusSchema,
+  managedTimingSummarySchema,
   networkObservationSchema,
   openEditorRequestSchema,
   pageDataFlowReportSchema,