@spotpatch/dev-server 0.6.0 → 0.8.0

package/dist/index.js

@@ -2256,6 +2256,9 @@ import { access as access2, lstat as lstat3, readFile as readFile2, realpath as
 import { createRequire } from "module";
 import path3 from "path";
 import { promisify } from "util";
+import {
+  DEFAULT_AGENT_LIMITS as DEFAULT_AGENT_LIMITS2
+} from "@spotpatch/shared";
 var execFileAsync = promisify(execFile);
 var TYPESCRIPT_CHECK_ID = "spotpatch-typecheck";
 var TYPESCRIPT_CHECK_LABEL = "TypeScript";
@@ -2323,6 +2326,15 @@ async function resolveTypeScriptCli(appRoot) {
 function portableRelativePath(from, to) {
   return path3.relative(from, to).split(path3.sep).join("/");
 }
+function hasRequiredCheck(checks) {
+  return Object.values(checks).some((check) => check.required);
+}
+function availableCheckId(checks, preferred) {
+  if (checks[preferred] === void 0) return preferred;
+  let suffix = 2;
+  while (checks[`${preferred}-${String(suffix)}`] !== void 0) suffix += 1;
+  return `${preferred}-${String(suffix)}`;
+}
 async function discoverProjectValidationCheck(options) {
   const appRoot = await realpath2(options.appRoot);
   const tsconfigPath = path3.join(appRoot, "tsconfig.json");
@@ -2351,6 +2363,8 @@ async function discoverProjectValidationCheck(options) {
       "--noEmit",
       "--pretty",
       "false",
+      "--incremental",
+      "false",
       "--project",
       projectPath
     ]),
@@ -2358,21 +2372,30 @@ async function discoverProjectValidationCheck(options) {
     timeoutMs: options.timeoutMs
   });
 }
-
-// src/project-options.ts
-function hasRequiredCheck(ai) {
-  return Object.values(ai.execution.checks).some((check) => check.required);
+async function resolveProjectValidationChecks(options) {
+  if (hasRequiredCheck(options.checks)) return options.checks;
+  const discovered = await discoverProjectValidationCheck(options);
+  if (discovered === void 0) return options.checks;
+  const id = availableCheckId(options.checks, discovered.id);
+  return Object.freeze({
+    ...options.checks,
+    [id]: Object.freeze({ ...discovered, id })
+  });
 }
-function availableCheckId(checks, preferred) {
-  if (checks[preferred] === void 0) {
-    return preferred;
-  }
-  let suffix = 2;
-  while (checks[`${preferred}-${String(suffix)}`] !== void 0) {
-    suffix += 1;
-  }
-  return `${preferred}-${String(suffix)}`;
+async function resolveManagedExecutionValidation(options) {
+  const checks = options.ai === false ? Object.freeze({}) : options.ai.execution.checks;
+  const limits = options.ai === false ? DEFAULT_AGENT_LIMITS2 : options.ai.execution.limits;
+  return Object.freeze({
+    checks: await resolveProjectValidationChecks({
+      appRoot: options.appRoot,
+      checks,
+      timeoutMs: limits.checkTimeoutMs
+    }),
+    limits
+  });
 }
+
+// src/project-options.ts
 async function resolveProjectOptions(input) {
   const userOptions = input.options ?? {};
   const resolved = resolveOptions(userOptions, input.environmentAi);
@@ -2384,22 +2407,15 @@ async function resolveProjectOptions(input) {
       "SpotPatch trustedFastMode cannot be combined with applyMode auto."
     );
   }
-  let checks = resolved.ai.execution.checks;
-  if (!hasRequiredCheck(resolved.ai)) {
-    const discovered = await discoverProjectValidationCheck({
-      appRoot: input.appRoot,
-      timeoutMs: resolved.ai.execution.limits.checkTimeoutMs
-    });
-    if (discovered === void 0) {
-      throw new RangeError(
-        "SpotPatch trustedFastMode requires a configured required check or a local TypeScript project with tsconfig.json."
-      );
-    }
-    const id = availableCheckId(checks, discovered.id);
-    checks = Object.freeze({
-      ...checks,
-      [id]: Object.freeze({ ...discovered, id })
-    });
+  const checks = await resolveProjectValidationChecks({
+    appRoot: input.appRoot,
+    checks: resolved.ai.execution.checks,
+    timeoutMs: resolved.ai.execution.limits.checkTimeoutMs
+  });
+  if (!Object.values(checks).some((check) => check.required)) {
+    throw new RangeError(
+      "SpotPatch trustedFastMode requires a configured required check or a local TypeScript project with tsconfig.json."
+    );
   }
   const ai = Object.freeze({
     ...resolved.ai,
@@ -2462,6 +2478,7 @@ function createSourceRegistry(options = {}) {
         );
       }
       componentIdsByPath.set(normalizedPath, currentIds);
+      return fileId;
     },
     resolve(fileId) {
       return idToPath.get(fileId);
@@ -2480,10 +2497,10 @@ function createSourceRegistry(options = {}) {
 
 // src/server/middleware.ts
 import {
-  ERROR_CODES as ERROR_CODES15,
+  ERROR_CODES as ERROR_CODES16,
   SPOTPATCH_API_BASE,
-  SPOTPATCH_ENDPOINTS as SPOTPATCH_ENDPOINTS3,
-  SpotPatchError as SpotPatchError15,
+  SPOTPATCH_ENDPOINTS as SPOTPATCH_ENDPOINTS4,
+  SpotPatchError as SpotPatchError16,
   openEditorRequestSchema,
   sourceContextRequestSchema
 } from "@spotpatch/shared";
@@ -3061,11 +3078,171 @@ async function handleExternalHandoffBrowserRequest(request, response, route, opt
   writeSuccess(response, result.replayed ? 200 : 201, result);
 }
 
-// src/server/agent-http.ts
+// src/external-agent/browser-http.ts
 import {
   ERROR_CODES as ERROR_CODES11,
+  EXTERNAL_AGENT_CONTROL_LIMITS,
   SPOTPATCH_ENDPOINTS as SPOTPATCH_ENDPOINTS2,
   SpotPatchError as SpotPatchError11,
+  externalAgentControlCancelRequestSchema,
+  externalAgentControlConnectRequestSchema,
+  externalAgentControlDisconnectRequestSchema,
+  externalAgentControlStatusRequestSchema,
+  externalAgentControlStatusSchema,
+  externalAgentEventSchema,
+  externalAgentEventsRequestSchema,
+  externalAgentManagedResultSchema,
+  externalAgentResultRequestSchema
+} from "@spotpatch/shared";
+function matchExternalAgentBrowserPath(path9) {
+  if (path9 === SPOTPATCH_ENDPOINTS2.externalAgentControlStatus) return "status";
+  if (path9 === SPOTPATCH_ENDPOINTS2.externalAgentControlConnect) return "connect";
+  if (path9 === SPOTPATCH_ENDPOINTS2.externalAgentControlDisconnect) {
+    return "disconnect";
+  }
+  if (path9 === SPOTPATCH_ENDPOINTS2.externalAgentControlCancel) return "cancel";
+  if (path9 === SPOTPATCH_ENDPOINTS2.externalAgentEvents) return "events";
+  if (path9 === SPOTPATCH_ENDPOINTS2.externalAgentResult) return "result";
+  return void 0;
+}
+function writeEvent(response, event) {
+  response.write(`${JSON.stringify(externalAgentEventSchema.parse(event))}
+`);
+}
+function createExternalAgentBrowserController(port) {
+  const streams = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const handleEvents = async (request, response) => {
+    const parsed = externalAgentEventsRequestSchema.safeParse(
+      await readJsonRequestBody(request)
+    );
+    if (!parsed.success) {
+      throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    }
+    if (disposed || streams.size >= EXTERNAL_AGENT_CONTROL_LIMITS.maximumEventSubscribers) {
+      throw new SpotPatchError11(ERROR_CODES11.BRIDGE_BUSY);
+    }
+    response.statusCode = 200;
+    response.setHeader("Cache-Control", "no-store");
+    response.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    streams.add(response);
+    const initial = externalAgentControlStatusSchema.parse(port.getStatus());
+    writeEvent(response, { type: "status", data: initial });
+    const unsubscribe = port.subscribe((status) => {
+      if (!response.destroyed && status.sequence > (parsed.data.afterSequence ?? -1)) {
+        writeEvent(response, { type: "status", data: status });
+      }
+    });
+    const heartbeat = setInterval(() => {
+      if (!response.destroyed) {
+        const status = port.getStatus();
+        writeEvent(response, {
+          type: "heartbeat",
+          sequence: status.sequence,
+          emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }, EXTERNAL_AGENT_CONTROL_LIMITS.eventHeartbeatMs);
+    heartbeat.unref();
+    await new Promise((resolve) => {
+      const close = () => {
+        response.off("close", close);
+        clearInterval(heartbeat);
+        unsubscribe();
+        streams.delete(response);
+        resolve();
+      };
+      response.once("close", close);
+    });
+  };
+  return Object.freeze({
+    async handle(request, response, route, writeSuccess) {
+      if (request.method !== "POST" || disposed) {
+        throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+      }
+      if (route === "events") {
+        await handleEvents(request, response);
+        return;
+      }
+      if (route === "status") {
+        const parsed2 = externalAgentControlStatusRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+        writeSuccess(
+          response,
+          200,
+          externalAgentControlStatusSchema.parse(port.getStatus())
+        );
+        return;
+      }
+      if (route === "connect") {
+        const parsed2 = externalAgentControlConnectRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+        const controller = new AbortController();
+        response.once("close", () => {
+          if (!response.writableEnded) controller.abort("browser-disconnected");
+        });
+        writeSuccess(
+          response,
+          200,
+          externalAgentControlStatusSchema.parse(
+            await port.connect(parsed2.data, controller.signal)
+          )
+        );
+        return;
+      }
+      if (route === "disconnect") {
+        const parsed2 = externalAgentControlDisconnectRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+        writeSuccess(
+          response,
+          200,
+          externalAgentControlStatusSchema.parse(await port.disconnect(parsed2.data))
+        );
+        return;
+      }
+      if (route === "cancel") {
+        const parsed2 = externalAgentControlCancelRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+        writeSuccess(
+          response,
+          200,
+          externalAgentControlStatusSchema.parse(await port.cancel(parsed2.data))
+        );
+        return;
+      }
+      const parsed = externalAgentResultRequestSchema.safeParse(
+        await readJsonRequestBody(request)
+      );
+      if (!parsed.success) throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+      const result = port.getResult(parsed.data.revision);
+      if (result === void 0) {
+        throw new SpotPatchError11(ERROR_CODES11.HANDOFF_NOT_FOUND);
+      }
+      writeSuccess(response, 200, externalAgentManagedResultSchema.parse(result));
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const response of streams) response.end();
+      streams.clear();
+    }
+  });
+}
+
+// src/server/agent-http.ts
+import {
+  ERROR_CODES as ERROR_CODES12,
+  SPOTPATCH_ENDPOINTS as SPOTPATCH_ENDPOINTS3,
+  SpotPatchError as SpotPatchError12,
   agentCapabilityRequestSchema,
   agentJobActionRequestSchema,
   agentJobCreateRequestSchema,
@@ -3110,16 +3287,16 @@ var EVENT_STREAM_END_STATUSES = /* @__PURE__ */ new Set([
   "failed"
 ]);
 function matchAgentRequestPath(path9) {
-  if (path9 === SPOTPATCH_ENDPOINTS2.agentCapability) {
+  if (path9 === SPOTPATCH_ENDPOINTS3.agentCapability) {
     return Object.freeze({ kind: "capability" });
   }
-  if (path9 === SPOTPATCH_ENDPOINTS2.agentWorkspaceHealth) {
+  if (path9 === SPOTPATCH_ENDPOINTS3.agentWorkspaceHealth) {
     return Object.freeze({ kind: "workspace-health" });
   }
-  if (path9 === SPOTPATCH_ENDPOINTS2.agentJobs) {
+  if (path9 === SPOTPATCH_ENDPOINTS3.agentJobs) {
     return Object.freeze({ kind: "create-job" });
   }
-  const prefix = `${SPOTPATCH_ENDPOINTS2.agentJobs}/`;
+  const prefix = `${SPOTPATCH_ENDPOINTS3.agentJobs}/`;
   if (!path9.startsWith(prefix)) {
     return void 0;
   }
@@ -3137,7 +3314,7 @@ function matchAgentRequestPath(path9) {
 }
 function requireAgentManager(options) {
   if (options.agentManager === void 0 || options.options.ai === false) {
-    throw new SpotPatchError11(ERROR_CODES11.AI_DISABLED);
+    throw new SpotPatchError12(ERROR_CODES12.AI_DISABLED);
   }
   return options.agentManager;
 }
@@ -3190,13 +3367,13 @@ function streamAgentJobEvents(response, manager, jobId) {
 }
 async function handleCapability(request, response, options, writeSuccess) {
   if (request.method !== "POST") {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   const parsed = agentCapabilityRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   const controller = new AbortController();
   const abort = () => {
@@ -3215,13 +3392,13 @@ async function handleCapability(request, response, options, writeSuccess) {
 }
 async function handleCreateJob(request, response, options, writeSuccess) {
   if (request.method !== "POST") {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   const parsed = agentJobCreateRequestSchema.safeParse(
     await readJsonRequestBody(request, MAX_AGENT_REQUEST_BODY_BYTES)
   );
   if (!parsed.success) {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   const authorizedRequest = await authorizeAgentJobRequest({
     request: parsed.data,
@@ -3234,13 +3411,13 @@ async function handleCreateJob(request, response, options, writeSuccess) {
 }
 async function handleWorkspaceHealth(request, response, options, writeSuccess) {
   if (request.method !== "POST") {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   const parsed = agentWorkspaceHealthRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   const controller = new AbortController();
   const abort = () => {
@@ -3257,13 +3434,13 @@ async function handleWorkspaceHealth(request, response, options, writeSuccess) {
 async function handleJobAction(request, response, options, route, writeSuccess) {
   const manager = requireAgentManager(options);
   if (request.method !== "POST") {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   const parsed = agentJobActionRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
   }
   if (route.action === "events") {
     streamAgentJobEvents(response, manager, route.jobId);
@@ -3384,8 +3561,8 @@ import {
 } from "@spotpatch/analyzer";
 import {
   DATA_FLOW_SCHEMA_VERSION,
-  ERROR_CODES as ERROR_CODES12,
-  SpotPatchError as SpotPatchError12,
+  ERROR_CODES as ERROR_CODES13,
+  SpotPatchError as SpotPatchError13,
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
   limitDataFlowReportCollections
@@ -3404,7 +3581,7 @@ function limitDataFlowReportToBytes(report, maximumBytes) {
     truncatedBy: "bytes"
   });
   if (envelopeBytes(limited) > maximumBytes) {
-    throw new SpotPatchError12(ERROR_CODES12.INTERNAL_ERROR);
+    throw new SpotPatchError13(ERROR_CODES13.INTERNAL_ERROR);
   }
   for (let maximumDependencies = 1; maximumDependencies <= structurallyLimited.dependencies.length; maximumDependencies += 1) {
     const candidate = limitDataFlowReportCollections(structurallyLimited, {
@@ -3433,7 +3610,7 @@ async function analyzeTarget(request, analyzer, options) {
         request.componentSourceId
       );
       if (anchor?.sourceVersion !== request.sourceVersion) {
-        throw new SpotPatchError12(ERROR_CODES12.DATA_FLOW_SOURCE_STALE);
+        throw new SpotPatchError13(ERROR_CODES13.DATA_FLOW_SOURCE_STALE);
       }
       return anchor;
     }
@@ -3450,7 +3627,7 @@ async function analyzeTarget(request, analyzer, options) {
     column: resolvedRequest.column
   });
   if (resolvedRequest.sourceVersion !== void 0 && resolvedRequest.sourceVersion !== report.component.source.sourceVersion) {
-    throw new SpotPatchError12(ERROR_CODES12.DATA_FLOW_SOURCE_STALE);
+    throw new SpotPatchError13(ERROR_CODES13.DATA_FLOW_SOURCE_STALE);
   }
   return limitDataFlowReportToBytes(
     report,
@@ -3459,7 +3636,7 @@ async function analyzeTarget(request, analyzer, options) {
 }
 function requireAnalyzer(analyzer) {
   if (analyzer === void 0) {
-    throw new SpotPatchError12(ERROR_CODES12.DATA_FLOW_DISABLED);
+    throw new SpotPatchError13(ERROR_CODES13.DATA_FLOW_DISABLED);
   }
   return analyzer;
 }
@@ -3471,7 +3648,7 @@ async function handleComponentDataFlowReport(request, analyzer, options) {
     )
   );
   if (!parsed.success) {
-    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
+    throw new SpotPatchError13(ERROR_CODES13.INVALID_REQUEST);
   }
   return analyzeTarget(parsed.data, requireAnalyzer(analyzer), options);
 }
@@ -3483,7 +3660,7 @@ async function handlePageDataFlowReport(request, analyzer, options) {
     )
   );
   if (!parsed.success) {
-    throw new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST);
+    throw new SpotPatchError13(ERROR_CODES13.INVALID_REQUEST);
   }
   const activeAnalyzer = requireAnalyzer(analyzer);
   const componentReports = await Promise.all(
@@ -3556,7 +3733,7 @@ async function handlePageDataFlowReport(request, analyzer, options) {
 // src/server/request-security.ts
 import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { isIP } from "net";
-import { ERROR_CODES as ERROR_CODES13, SPOTPATCH_TOKEN_HEADER, SpotPatchError as SpotPatchError13 } from "@spotpatch/shared";
+import { ERROR_CODES as ERROR_CODES14, SPOTPATCH_TOKEN_HEADER, SpotPatchError as SpotPatchError14 } from "@spotpatch/shared";
 function getSingleHeader(request, name) {
   const value = request.headers[name.toLowerCase()];
   return Array.isArray(value) ? value[0] : value;
@@ -3603,32 +3780,32 @@ function parseOrigin(value) {
 function assertRequestAuthorized(request, options) {
   const actualToken = getSingleHeader(request, SPOTPATCH_TOKEN_HEADER);
   if (!tokensMatch2(actualToken, options.sessionToken)) {
-    throw new SpotPatchError13(ERROR_CODES13.INVALID_TOKEN);
+    throw new SpotPatchError14(ERROR_CODES14.INVALID_TOKEN);
   }
   const hostHeader = getSingleHeader(request, "host");
   const originHeader = getSingleHeader(request, "origin");
   const host = hostHeader === void 0 ? void 0 : parseHost(hostHeader);
   const origin = originHeader === void 0 ? void 0 : parseOrigin(originHeader);
   if (host === void 0 || origin === void 0) {
-    throw new SpotPatchError13(ERROR_CODES13.ORIGIN_NOT_ALLOWED);
+    throw new SpotPatchError14(ERROR_CODES14.ORIGIN_NOT_ALLOWED);
   }
   const hostIsLoopback = isLoopbackHostname(host.hostname);
   const originIsLoopback = isLoopbackHostname(origin.hostname);
   if (!options.allowLan) {
     if (!hostIsLoopback || !originIsLoopback) {
-      throw new SpotPatchError13(ERROR_CODES13.ORIGIN_NOT_ALLOWED);
+      throw new SpotPatchError14(ERROR_CODES14.ORIGIN_NOT_ALLOWED);
     }
     return;
   }
   if (!originIsLoopback && origin.host.toLowerCase() !== host.host.toLowerCase()) {
-    throw new SpotPatchError13(ERROR_CODES13.ORIGIN_NOT_ALLOWED);
+    throw new SpotPatchError14(ERROR_CODES14.ORIGIN_NOT_ALLOWED);
   }
 }
 
 // src/server/runtime-bootstrap.ts
 import {
-  ERROR_CODES as ERROR_CODES14,
-  SpotPatchError as SpotPatchError14,
+  ERROR_CODES as ERROR_CODES15,
+  SpotPatchError as SpotPatchError15,
   runtimeBootstrapRequestSchema,
   runtimeConfigSchema
 } from "@spotpatch/shared";
@@ -3658,7 +3835,7 @@ function resolveRuntimeBootstrapOptions(options) {
 function assertRuntimeBootstrapRequest(request, expectedOrigin) {
   const contentType = getSingleHeader2(request, "content-type")?.split(";", 1)[0]?.trim().toLowerCase();
   if (request.method !== "POST" || contentType !== "application/json") {
-    throw new SpotPatchError14(ERROR_CODES14.INVALID_REQUEST);
+    throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
   }
   const host = getSingleHeader2(request, "host");
   let hostIsLoopback = false;
@@ -3670,7 +3847,7 @@ function assertRuntimeBootstrapRequest(request, expectedOrigin) {
     }
   }
   if (!hostIsLoopback || getSingleHeader2(request, "origin") !== expectedOrigin || getSingleHeader2(request, "sec-fetch-site") !== "same-origin") {
-    throw new SpotPatchError14(ERROR_CODES14.ORIGIN_NOT_ALLOWED);
+    throw new SpotPatchError15(ERROR_CODES15.ORIGIN_NOT_ALLOWED);
   }
 }
 async function readRuntimeBootstrap(request, options) {
@@ -3679,123 +3856,123 @@ async function readRuntimeBootstrap(request, options) {
     await readJsonRequestBody(request)
   );
   if (!parsedBody.success) {
-    throw new SpotPatchError14(ERROR_CODES14.INVALID_REQUEST);
+    throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
   }
   return options.runtimeConfig;
 }
 
 // src/server/middleware.ts
 var STATUS_BY_ERROR = Object.freeze({
-  [ERROR_CODES15.INVALID_REQUEST]: 400,
-  [ERROR_CODES15.INVALID_TOKEN]: 401,
-  [ERROR_CODES15.ORIGIN_NOT_ALLOWED]: 403,
-  [ERROR_CODES15.SOURCE_NOT_FOUND]: 404,
-  [ERROR_CODES15.SOURCE_OUTSIDE_ROOT]: 403,
-  [ERROR_CODES15.SOURCE_TOO_LARGE]: 413,
-  [ERROR_CODES15.EDITOR_OPEN_FAILED]: 500,
-  [ERROR_CODES15.DATA_FLOW_DISABLED]: 404,
-  [ERROR_CODES15.DATA_FLOW_SOURCE_STALE]: 409,
-  [ERROR_CODES15.DATA_FLOW_ANALYSIS_CANCELLED]: 409,
-  [ERROR_CODES15.AI_DISABLED]: 404,
-  [ERROR_CODES15.PROVIDER_NOT_CONFIGURED]: 503,
-  [ERROR_CODES15.PROVIDER_AUTH_FAILED]: 502,
-  [ERROR_CODES15.PROVIDER_PROTOCOL_UNSUPPORTED]: 502,
-  [ERROR_CODES15.MODEL_NOT_ALLOWED]: 400,
-  [ERROR_CODES15.MODEL_TOOL_CALL_UNSUPPORTED]: 422,
-  [ERROR_CODES15.PROVIDER_RATE_LIMITED]: 429,
-  [ERROR_CODES15.AGENT_BUSY]: 409,
-  [ERROR_CODES15.AGENT_LIMIT_EXCEEDED]: 413,
-  [ERROR_CODES15.AGENT_CANCELLED]: 409,
-  [ERROR_CODES15.EXTERNAL_HANDOFF_DISABLED]: 404,
-  [ERROR_CODES15.EXTERNAL_HANDOFF_UNAVAILABLE]: 503,
-  [ERROR_CODES15.HANDOFF_VALIDATION_FAILED]: 422,
-  [ERROR_CODES15.HANDOFF_SOURCE_STALE]: 409,
-  [ERROR_CODES15.HANDOFF_NOT_FOUND]: 404,
-  [ERROR_CODES15.HANDOFF_EXPIRED]: 410,
-  [ERROR_CODES15.HANDOFF_CURSOR_INVALID]: 409,
-  [ERROR_CODES15.HANDOFF_RESPONSE_TOO_LARGE]: 413,
-  [ERROR_CODES15.BRIDGE_UNAUTHORIZED]: 401,
-  [ERROR_CODES15.BRIDGE_PROTOCOL_MISMATCH]: 409,
-  [ERROR_CODES15.BRIDGE_BUSY]: 429,
-  [ERROR_CODES15.EXTERNAL_AGENT_BUSY]: 409,
-  [ERROR_CODES15.ACTIVE_ADAPTER_CONFLICT]: 409,
-  [ERROR_CODES15.ACTIVE_ADAPTER_LEASE_INVALID]: 409,
-  [ERROR_CODES15.ACTIVE_DISPATCH_INVALID]: 409,
-  [ERROR_CODES15.SESSION_NOT_FOUND]: 404,
-  [ERROR_CODES15.SESSION_AMBIGUOUS]: 409,
-  [ERROR_CODES15.SESSION_CLOSED]: 410,
-  [ERROR_CODES15.WORKTREE_DIRTY]: 409,
-  [ERROR_CODES15.WORKTREE_NOT_REPOSITORY]: 409,
-  [ERROR_CODES15.WORKTREE_OPERATION_IN_PROGRESS]: 409,
-  [ERROR_CODES15.WORKTREE_CONFLICTED]: 409,
-  [ERROR_CODES15.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: 413,
-  [ERROR_CODES15.WORKTREE_UNTRACKED_UNSUPPORTED]: 409,
-  [ERROR_CODES15.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: 409,
-  [ERROR_CODES15.TOOL_DENIED]: 403,
-  [ERROR_CODES15.TOOL_INPUT_INVALID]: 422,
-  [ERROR_CODES15.TOOL_ARGUMENTS_INVALID]: 422,
-  [ERROR_CODES15.TOOL_CALL_ID_CONFLICT]: 422,
-  [ERROR_CODES15.TOOL_PATH_DENIED]: 403,
-  [ERROR_CODES15.PATCH_REJECTED]: 422,
-  [ERROR_CODES15.VALIDATION_FAILED]: 422,
-  [ERROR_CODES15.APPLY_CONFLICT]: 409,
-  [ERROR_CODES15.INTERNAL_ERROR]: 500
+  [ERROR_CODES16.INVALID_REQUEST]: 400,
+  [ERROR_CODES16.INVALID_TOKEN]: 401,
+  [ERROR_CODES16.ORIGIN_NOT_ALLOWED]: 403,
+  [ERROR_CODES16.SOURCE_NOT_FOUND]: 404,
+  [ERROR_CODES16.SOURCE_OUTSIDE_ROOT]: 403,
+  [ERROR_CODES16.SOURCE_TOO_LARGE]: 413,
+  [ERROR_CODES16.EDITOR_OPEN_FAILED]: 500,
+  [ERROR_CODES16.DATA_FLOW_DISABLED]: 404,
+  [ERROR_CODES16.DATA_FLOW_SOURCE_STALE]: 409,
+  [ERROR_CODES16.DATA_FLOW_ANALYSIS_CANCELLED]: 409,
+  [ERROR_CODES16.AI_DISABLED]: 404,
+  [ERROR_CODES16.PROVIDER_NOT_CONFIGURED]: 503,
+  [ERROR_CODES16.PROVIDER_AUTH_FAILED]: 502,
+  [ERROR_CODES16.PROVIDER_PROTOCOL_UNSUPPORTED]: 502,
+  [ERROR_CODES16.MODEL_NOT_ALLOWED]: 400,
+  [ERROR_CODES16.MODEL_TOOL_CALL_UNSUPPORTED]: 422,
+  [ERROR_CODES16.PROVIDER_RATE_LIMITED]: 429,
+  [ERROR_CODES16.AGENT_BUSY]: 409,
+  [ERROR_CODES16.AGENT_LIMIT_EXCEEDED]: 413,
+  [ERROR_CODES16.AGENT_CANCELLED]: 409,
+  [ERROR_CODES16.EXTERNAL_HANDOFF_DISABLED]: 404,
+  [ERROR_CODES16.EXTERNAL_HANDOFF_UNAVAILABLE]: 503,
+  [ERROR_CODES16.HANDOFF_VALIDATION_FAILED]: 422,
+  [ERROR_CODES16.HANDOFF_SOURCE_STALE]: 409,
+  [ERROR_CODES16.HANDOFF_NOT_FOUND]: 404,
+  [ERROR_CODES16.HANDOFF_EXPIRED]: 410,
+  [ERROR_CODES16.HANDOFF_CURSOR_INVALID]: 409,
+  [ERROR_CODES16.HANDOFF_RESPONSE_TOO_LARGE]: 413,
+  [ERROR_CODES16.BRIDGE_UNAUTHORIZED]: 401,
+  [ERROR_CODES16.BRIDGE_PROTOCOL_MISMATCH]: 409,
+  [ERROR_CODES16.BRIDGE_BUSY]: 429,
+  [ERROR_CODES16.EXTERNAL_AGENT_BUSY]: 409,
+  [ERROR_CODES16.ACTIVE_ADAPTER_CONFLICT]: 409,
+  [ERROR_CODES16.ACTIVE_ADAPTER_LEASE_INVALID]: 409,
+  [ERROR_CODES16.ACTIVE_DISPATCH_INVALID]: 409,
+  [ERROR_CODES16.SESSION_NOT_FOUND]: 404,
+  [ERROR_CODES16.SESSION_AMBIGUOUS]: 409,
+  [ERROR_CODES16.SESSION_CLOSED]: 410,
+  [ERROR_CODES16.WORKTREE_DIRTY]: 409,
+  [ERROR_CODES16.WORKTREE_NOT_REPOSITORY]: 409,
+  [ERROR_CODES16.WORKTREE_OPERATION_IN_PROGRESS]: 409,
+  [ERROR_CODES16.WORKTREE_CONFLICTED]: 409,
+  [ERROR_CODES16.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: 413,
+  [ERROR_CODES16.WORKTREE_UNTRACKED_UNSUPPORTED]: 409,
+  [ERROR_CODES16.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: 409,
+  [ERROR_CODES16.TOOL_DENIED]: 403,
+  [ERROR_CODES16.TOOL_INPUT_INVALID]: 422,
+  [ERROR_CODES16.TOOL_ARGUMENTS_INVALID]: 422,
+  [ERROR_CODES16.TOOL_CALL_ID_CONFLICT]: 422,
+  [ERROR_CODES16.TOOL_PATH_DENIED]: 403,
+  [ERROR_CODES16.PATCH_REJECTED]: 422,
+  [ERROR_CODES16.VALIDATION_FAILED]: 422,
+  [ERROR_CODES16.APPLY_CONFLICT]: 409,
+  [ERROR_CODES16.INTERNAL_ERROR]: 500
 });
 var PUBLIC_MESSAGES = Object.freeze({
-  [ERROR_CODES15.INVALID_REQUEST]: "The request is invalid.",
-  [ERROR_CODES15.INVALID_TOKEN]: "The session token is invalid.",
-  [ERROR_CODES15.ORIGIN_NOT_ALLOWED]: "The request origin is not allowed.",
-  [ERROR_CODES15.SOURCE_NOT_FOUND]: "The source file is unavailable.",
-  [ERROR_CODES15.SOURCE_OUTSIDE_ROOT]: "The source file is outside the project root.",
-  [ERROR_CODES15.SOURCE_TOO_LARGE]: "The source file exceeds the size limit.",
-  [ERROR_CODES15.EDITOR_OPEN_FAILED]: "The editor request could not be started.",
-  [ERROR_CODES15.DATA_FLOW_DISABLED]: "Component data-flow analysis is not enabled.",
-  [ERROR_CODES15.DATA_FLOW_SOURCE_STALE]: "The selected source version is stale.",
-  [ERROR_CODES15.DATA_FLOW_ANALYSIS_CANCELLED]: "The data-flow analysis was cancelled.",
-  [ERROR_CODES15.AI_DISABLED]: "AI execution is not enabled.",
-  [ERROR_CODES15.PROVIDER_NOT_CONFIGURED]: "The AI provider is unavailable.",
-  [ERROR_CODES15.PROVIDER_AUTH_FAILED]: "The AI provider rejected authentication.",
-  [ERROR_CODES15.PROVIDER_PROTOCOL_UNSUPPORTED]: "The AI provider protocol is unsupported.",
-  [ERROR_CODES15.MODEL_NOT_ALLOWED]: "The selected model is not allowed.",
-  [ERROR_CODES15.MODEL_TOOL_CALL_UNSUPPORTED]: "The selected model cannot run SpotPatch tools.",
-  [ERROR_CODES15.PROVIDER_RATE_LIMITED]: "The AI provider is rate limited.",
-  [ERROR_CODES15.AGENT_BUSY]: "Another Agent job is already running.",
-  [ERROR_CODES15.AGENT_LIMIT_EXCEEDED]: "The Agent job exceeded a safety limit.",
-  [ERROR_CODES15.AGENT_CANCELLED]: "The Agent job was cancelled.",
-  [ERROR_CODES15.EXTERNAL_HANDOFF_DISABLED]: "External Agent handoff is not enabled.",
-  [ERROR_CODES15.EXTERNAL_HANDOFF_UNAVAILABLE]: "External Agent handoff is temporarily unavailable.",
-  [ERROR_CODES15.HANDOFF_VALIDATION_FAILED]: "The handoff content is invalid.",
-  [ERROR_CODES15.HANDOFF_SOURCE_STALE]: "The selected source is stale.",
-  [ERROR_CODES15.HANDOFF_NOT_FOUND]: "No current handoff is available.",
-  [ERROR_CODES15.HANDOFF_EXPIRED]: "The handoff has expired.",
-  [ERROR_CODES15.HANDOFF_CURSOR_INVALID]: "The handoff cursor is invalid.",
-  [ERROR_CODES15.HANDOFF_RESPONSE_TOO_LARGE]: "The handoff exceeds the size limit.",
-  [ERROR_CODES15.BRIDGE_UNAUTHORIZED]: "The local bridge request is unauthorized.",
-  [ERROR_CODES15.BRIDGE_PROTOCOL_MISMATCH]: "The local bridge protocol is incompatible.",
-  [ERROR_CODES15.BRIDGE_BUSY]: "The local bridge is busy.",
-  [ERROR_CODES15.EXTERNAL_AGENT_BUSY]: "The connected external Agent is busy.",
-  [ERROR_CODES15.ACTIVE_ADAPTER_CONFLICT]: "Another active Agent adapter is connected.",
-  [ERROR_CODES15.ACTIVE_ADAPTER_LEASE_INVALID]: "The active Agent adapter lease is invalid.",
-  [ERROR_CODES15.ACTIVE_DISPATCH_INVALID]: "The active Agent dispatch transition is invalid.",
-  [ERROR_CODES15.SESSION_NOT_FOUND]: "No active SpotPatch session was found.",
-  [ERROR_CODES15.SESSION_AMBIGUOUS]: "More than one SpotPatch session matches.",
-  [ERROR_CODES15.SESSION_CLOSED]: "The SpotPatch session has closed.",
-  [ERROR_CODES15.WORKTREE_DIRTY]: "Local changes require explicit inclusion consent.",
-  [ERROR_CODES15.WORKTREE_NOT_REPOSITORY]: "The project root is not a Git repository.",
-  [ERROR_CODES15.WORKTREE_OPERATION_IN_PROGRESS]: "A Git operation is currently in progress.",
-  [ERROR_CODES15.WORKTREE_CONFLICTED]: "The local workspace contains unresolved merge conflicts.",
-  [ERROR_CODES15.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: "The local workspace exceeds the safe isolation size limit.",
-  [ERROR_CODES15.WORKTREE_UNTRACKED_UNSUPPORTED]: "An untracked path cannot be isolated safely.",
-  [ERROR_CODES15.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: "The local workspace state cannot be isolated safely.",
-  [ERROR_CODES15.TOOL_DENIED]: "The Agent tool request was denied.",
-  [ERROR_CODES15.TOOL_INPUT_INVALID]: "The Agent tool input was invalid.",
-  [ERROR_CODES15.TOOL_ARGUMENTS_INVALID]: "The Agent tool arguments are invalid.",
-  [ERROR_CODES15.TOOL_CALL_ID_CONFLICT]: "A tool call ID conflicts within one Agent turn.",
-  [ERROR_CODES15.TOOL_PATH_DENIED]: "The Agent tool path was denied.",
-  [ERROR_CODES15.PATCH_REJECTED]: "The proposed patch was rejected.",
-  [ERROR_CODES15.VALIDATION_FAILED]: "The proposed change failed validation.",
-  [ERROR_CODES15.APPLY_CONFLICT]: "The change conflicts with the current worktree.",
-  [ERROR_CODES15.INTERNAL_ERROR]: "The request could not be completed."
+  [ERROR_CODES16.INVALID_REQUEST]: "The request is invalid.",
+  [ERROR_CODES16.INVALID_TOKEN]: "The session token is invalid.",
+  [ERROR_CODES16.ORIGIN_NOT_ALLOWED]: "The request origin is not allowed.",
+  [ERROR_CODES16.SOURCE_NOT_FOUND]: "The source file is unavailable.",
+  [ERROR_CODES16.SOURCE_OUTSIDE_ROOT]: "The source file is outside the project root.",
+  [ERROR_CODES16.SOURCE_TOO_LARGE]: "The source file exceeds the size limit.",
+  [ERROR_CODES16.EDITOR_OPEN_FAILED]: "The editor request could not be started.",
+  [ERROR_CODES16.DATA_FLOW_DISABLED]: "Component data-flow analysis is not enabled.",
+  [ERROR_CODES16.DATA_FLOW_SOURCE_STALE]: "The selected source version is stale.",
+  [ERROR_CODES16.DATA_FLOW_ANALYSIS_CANCELLED]: "The data-flow analysis was cancelled.",
+  [ERROR_CODES16.AI_DISABLED]: "AI execution is not enabled.",
+  [ERROR_CODES16.PROVIDER_NOT_CONFIGURED]: "The AI provider is unavailable.",
+  [ERROR_CODES16.PROVIDER_AUTH_FAILED]: "The AI provider rejected authentication.",
+  [ERROR_CODES16.PROVIDER_PROTOCOL_UNSUPPORTED]: "The AI provider protocol is unsupported.",
+  [ERROR_CODES16.MODEL_NOT_ALLOWED]: "The selected model is not allowed.",
+  [ERROR_CODES16.MODEL_TOOL_CALL_UNSUPPORTED]: "The selected model cannot run SpotPatch tools.",
+  [ERROR_CODES16.PROVIDER_RATE_LIMITED]: "The AI provider is rate limited.",
+  [ERROR_CODES16.AGENT_BUSY]: "Another Agent job is already running.",
+  [ERROR_CODES16.AGENT_LIMIT_EXCEEDED]: "The Agent job exceeded a safety limit.",
+  [ERROR_CODES16.AGENT_CANCELLED]: "The Agent job was cancelled.",
+  [ERROR_CODES16.EXTERNAL_HANDOFF_DISABLED]: "External Agent handoff is not enabled.",
+  [ERROR_CODES16.EXTERNAL_HANDOFF_UNAVAILABLE]: "External Agent handoff is temporarily unavailable.",
+  [ERROR_CODES16.HANDOFF_VALIDATION_FAILED]: "The handoff content is invalid.",
+  [ERROR_CODES16.HANDOFF_SOURCE_STALE]: "The selected source is stale.",
+  [ERROR_CODES16.HANDOFF_NOT_FOUND]: "No current handoff is available.",
+  [ERROR_CODES16.HANDOFF_EXPIRED]: "The handoff has expired.",
+  [ERROR_CODES16.HANDOFF_CURSOR_INVALID]: "The handoff cursor is invalid.",
+  [ERROR_CODES16.HANDOFF_RESPONSE_TOO_LARGE]: "The handoff exceeds the size limit.",
+  [ERROR_CODES16.BRIDGE_UNAUTHORIZED]: "The local bridge request is unauthorized.",
+  [ERROR_CODES16.BRIDGE_PROTOCOL_MISMATCH]: "The local bridge protocol is incompatible.",
+  [ERROR_CODES16.BRIDGE_BUSY]: "The local bridge is busy.",
+  [ERROR_CODES16.EXTERNAL_AGENT_BUSY]: "The connected external Agent is busy.",
+  [ERROR_CODES16.ACTIVE_ADAPTER_CONFLICT]: "Another active Agent adapter is connected.",
+  [ERROR_CODES16.ACTIVE_ADAPTER_LEASE_INVALID]: "The active Agent adapter lease is invalid.",
+  [ERROR_CODES16.ACTIVE_DISPATCH_INVALID]: "The active Agent dispatch transition is invalid.",
+  [ERROR_CODES16.SESSION_NOT_FOUND]: "No active SpotPatch session was found.",
+  [ERROR_CODES16.SESSION_AMBIGUOUS]: "More than one SpotPatch session matches.",
+  [ERROR_CODES16.SESSION_CLOSED]: "The SpotPatch session has closed.",
+  [ERROR_CODES16.WORKTREE_DIRTY]: "Local changes require explicit inclusion consent.",
+  [ERROR_CODES16.WORKTREE_NOT_REPOSITORY]: "The project root is not a Git repository.",
+  [ERROR_CODES16.WORKTREE_OPERATION_IN_PROGRESS]: "A Git operation is currently in progress.",
+  [ERROR_CODES16.WORKTREE_CONFLICTED]: "The local workspace contains unresolved merge conflicts.",
+  [ERROR_CODES16.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: "The local workspace exceeds the safe isolation size limit.",
+  [ERROR_CODES16.WORKTREE_UNTRACKED_UNSUPPORTED]: "An untracked path cannot be isolated safely.",
+  [ERROR_CODES16.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: "The local workspace state cannot be isolated safely.",
+  [ERROR_CODES16.TOOL_DENIED]: "The Agent tool request was denied.",
+  [ERROR_CODES16.TOOL_INPUT_INVALID]: "The Agent tool input was invalid.",
+  [ERROR_CODES16.TOOL_ARGUMENTS_INVALID]: "The Agent tool arguments are invalid.",
+  [ERROR_CODES16.TOOL_CALL_ID_CONFLICT]: "A tool call ID conflicts within one Agent turn.",
+  [ERROR_CODES16.TOOL_PATH_DENIED]: "The Agent tool path was denied.",
+  [ERROR_CODES16.PATCH_REJECTED]: "The proposed patch was rejected.",
+  [ERROR_CODES16.VALIDATION_FAILED]: "The proposed change failed validation.",
+  [ERROR_CODES16.APPLY_CONFLICT]: "The change conflicts with the current worktree.",
+  [ERROR_CODES16.INTERNAL_ERROR]: "The request could not be completed."
 });
 function writeJson2(response, status, payload) {
   response.statusCode = status;
@@ -3804,11 +3981,11 @@ function writeJson2(response, status, payload) {
   response.end(JSON.stringify(payload));
 }
 function asSpotPatchError(error) {
-  return error instanceof SpotPatchError15 ? error : new SpotPatchError15(ERROR_CODES15.INTERNAL_ERROR, void 0, { cause: error });
+  return error instanceof SpotPatchError16 ? error : new SpotPatchError16(ERROR_CODES16.INTERNAL_ERROR, void 0, { cause: error });
 }
 function writeError(response, error, logger) {
   const normalized = asSpotPatchError(error);
-  if (normalized.code === ERROR_CODES15.INTERNAL_ERROR) {
+  if (normalized.code === ERROR_CODES16.INTERNAL_ERROR) {
     logger?.warn("[spotpatch:server] Internal request failure.");
   }
   writeJson2(response, STATUS_BY_ERROR[normalized.code], {
@@ -3831,7 +4008,7 @@ async function handleSourceContext(request, options) {
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
+    throw new SpotPatchError16(ERROR_CODES16.INVALID_REQUEST);
   }
   return readSourceContext({
     request: parsed.data,
@@ -3844,7 +4021,7 @@ async function handleSourceContext(request, options) {
 async function handleOpenEditor(request, options) {
   const parsed = openEditorRequestSchema.safeParse(await readJsonRequestBody(request));
   if (!parsed.success) {
-    throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
+    throw new SpotPatchError16(ERROR_CODES16.INVALID_REQUEST);
   }
   const body = parsed.data;
   const sourcePath = await resolveSourceFile({
@@ -3861,7 +4038,7 @@ async function handleOpenEditor(request, options) {
     options.logger?.warn(
       `[spotpatch:server] ${options.options.editor === "auto" ? "The detected editor" : options.options.editor} rejected an editor request.`
     );
-    throw new SpotPatchError15(ERROR_CODES15.EDITOR_OPEN_FAILED, void 0, {
+    throw new SpotPatchError16(ERROR_CODES16.EDITOR_OPEN_FAILED, void 0, {
       cause: error
     });
   }
@@ -3869,16 +4046,18 @@ async function handleOpenEditor(request, options) {
 function createSpotPatchMiddleware(options) {
   const bootstrap = options.bootstrap === void 0 ? void 0 : resolveRuntimeBootstrapOptions(options.bootstrap);
   const dataFlowAnalyzer = createDataFlowAnalyzer(options);
-  return (request, response, next) => {
+  const externalAgentController = options.externalAgentControl === void 0 ? void 0 : createExternalAgentBrowserController(options.externalAgentControl);
+  const middleware = (request, response, next) => {
     const path9 = requestPath(request);
     const agentRoute = matchAgentRequestPath(path9);
+    const externalAgentRoute = matchExternalAgentBrowserPath(path9);
     const externalHandoffRoute = matchExternalHandoffBrowserPath(path9);
-    if (path9 !== SPOTPATCH_ENDPOINTS3.sourceContext && path9 !== SPOTPATCH_ENDPOINTS3.openEditor && path9 !== SPOTPATCH_ENDPOINTS3.dataFlowComponentReport && path9 !== SPOTPATCH_ENDPOINTS3.dataFlowPageReport && agentRoute === void 0 && externalHandoffRoute === void 0 && !path9.startsWith(`${SPOTPATCH_API_BASE}/`)) {
+    if (path9 !== SPOTPATCH_ENDPOINTS4.sourceContext && path9 !== SPOTPATCH_ENDPOINTS4.openEditor && path9 !== SPOTPATCH_ENDPOINTS4.dataFlowComponentReport && path9 !== SPOTPATCH_ENDPOINTS4.dataFlowPageReport && agentRoute === void 0 && externalAgentRoute === void 0 && externalHandoffRoute === void 0 && !path9.startsWith(`${SPOTPATCH_API_BASE}/`)) {
       next();
       return;
     }
     const handle = async () => {
-      if (path9 === SPOTPATCH_ENDPOINTS3.bootstrap && bootstrap !== void 0) {
+      if (path9 === SPOTPATCH_ENDPOINTS4.bootstrap && bootstrap !== void 0) {
         const data = await readRuntimeBootstrap(
           request,
           bootstrap
@@ -3890,25 +4069,25 @@ function createSpotPatchMiddleware(options) {
         allowLan: options.options.allowLan,
         sessionToken: options.session.token
       });
-      if (path9 === SPOTPATCH_ENDPOINTS3.sourceContext) {
+      if (path9 === SPOTPATCH_ENDPOINTS4.sourceContext) {
         if (request.method !== "POST") {
-          throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
+          throw new SpotPatchError16(ERROR_CODES16.INVALID_REQUEST);
         }
         const data = await handleSourceContext(request, options);
         writeJson2(response, 200, { ok: true, data });
         return;
       }
-      if (path9 === SPOTPATCH_ENDPOINTS3.openEditor) {
+      if (path9 === SPOTPATCH_ENDPOINTS4.openEditor) {
         if (request.method !== "POST") {
-          throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
+          throw new SpotPatchError16(ERROR_CODES16.INVALID_REQUEST);
         }
         const data = await handleOpenEditor(request, options);
         writeJson2(response, 200, { ok: true, data });
         return;
       }
-      if (path9 === SPOTPATCH_ENDPOINTS3.dataFlowComponentReport) {
+      if (path9 === SPOTPATCH_ENDPOINTS4.dataFlowComponentReport) {
         if (request.method !== "POST") {
-          throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
+          throw new SpotPatchError16(ERROR_CODES16.INVALID_REQUEST);
         }
         const data = await handleComponentDataFlowReport(
           request,
@@ -3918,14 +4097,28 @@ function createSpotPatchMiddleware(options) {
         writeJson2(response, 200, { ok: true, data });
         return;
       }
-      if (path9 === SPOTPATCH_ENDPOINTS3.dataFlowPageReport) {
+      if (path9 === SPOTPATCH_ENDPOINTS4.dataFlowPageReport) {
         if (request.method !== "POST") {
-          throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
+          throw new SpotPatchError16(ERROR_CODES16.INVALID_REQUEST);
         }
         const data = await handlePageDataFlowReport(request, dataFlowAnalyzer, options);
         writeJson2(response, 200, { ok: true, data });
         return;
       }
+      if (externalAgentRoute !== void 0) {
+        if (!options.options.externalAgent.enabled || externalAgentController === void 0) {
+          throw new SpotPatchError16(ERROR_CODES16.EXTERNAL_HANDOFF_DISABLED);
+        }
+        await externalAgentController.handle(
+          request,
+          response,
+          externalAgentRoute,
+          (target, status, data) => {
+            writeJson2(target, status, { ok: true, data });
+          }
+        );
+        return;
+      }
       if (externalHandoffRoute !== void 0) {
         await handleExternalHandoffBrowserRequest(
           request,
@@ -3944,7 +4137,7 @@ function createSpotPatchMiddleware(options) {
         return;
       }
       if (agentRoute === void 0) {
-        throw new SpotPatchError15(ERROR_CODES15.INVALID_REQUEST);
+        throw new SpotPatchError16(ERROR_CODES16.INVALID_REQUEST);
       }
       await handleAgentRequest(
         request,
@@ -3960,21 +4153,42 @@ function createSpotPatchMiddleware(options) {
       writeError(response, error, options.logger);
     });
   };
+  return Object.assign(middleware, {
+    dispose() {
+      externalAgentController?.dispose();
+    }
+  });
 }
 
 // src/server/source-registration.ts
 import { timingSafeEqual as timingSafeEqual3 } from "crypto";
-import { lstat as lstat4, realpath as realpath6 } from "fs/promises";
+import { lstat as lstat4, readFile as readFile4, realpath as realpath6 } from "fs/promises";
 import path8 from "path";
-import { createSourceFilter } from "@spotpatch/compiler";
+import {
+  createDataFlowSourceFilter,
+  createDataFlowSourceVersion,
+  createSourceFilter
+} from "@spotpatch/compiler";
+import { DEFAULT_DATA_FLOW_LIMITS as DEFAULT_DATA_FLOW_LIMITS2 } from "@spotpatch/shared";
 import { z as z2 } from "zod";
-var REGISTRATION_BODY_LIMIT_BYTES = 4096;
+var REGISTRATION_BODY_LIMIT_BYTES = DEFAULT_DATA_FLOW_LIMITS2.protocolRequestMaxBytes;
 var REGISTRATION_IDENTITY_PATTERN = /^[A-Za-z0-9_-]{16,128}$/u;
+var DATA_FLOW_IDENTITY_PATTERN = /^[A-Za-z0-9_-]{1,128}$/u;
 var INTERNAL_SECRET_HEADER = "x-spotpatch-internal";
 var FORBIDDEN_SOURCE_SEGMENTS = /* @__PURE__ */ new Set([".next", "node_modules"]);
 var registrationRequestSchema = z2.strictObject({
   epoch: z2.string().regex(REGISTRATION_IDENTITY_PATTERN),
-  resourcePath: z2.string().min(1).max(3072)
+  resourcePath: z2.string().min(1).max(3072),
+  dataFlow: z2.strictObject({
+    sourceVersion: z2.string().regex(DATA_FLOW_IDENTITY_PATTERN),
+    components: z2.array(
+      z2.strictObject({
+        componentSourceId: z2.string().regex(DATA_FLOW_IDENTITY_PATTERN),
+        line: z2.number().int().positive().max(1e7),
+        column: z2.number().int().positive().max(1e7)
+      })
+    ).max(DEFAULT_DATA_FLOW_LIMITS2.sourceMaxComponents)
+  }).optional()
 });
 function getSingleHeader3(request, name) {
   const value = request.headers[name.toLowerCase()];
@@ -4038,6 +4252,33 @@ async function createSourceRegistrationService(input) {
   }
   const root = await realpath6(input.root);
   const sourceFilter = createSourceFilter(root, input.options);
+  const dataFlowFilter = createDataFlowSourceFilter(root, input.options);
+  const registrationQueues = /* @__PURE__ */ new Map();
+  async function registerCurrentSource(sourcePath, dataFlow) {
+    if (dataFlow === void 0) {
+      return input.registry.register(sourcePath);
+    }
+    let fileId;
+    const previous = registrationQueues.get(sourcePath) ?? Promise.resolve();
+    const current = previous.catch(() => void 0).then(async () => {
+      const currentSource = await readFile4(sourcePath, "utf8");
+      if (createDataFlowSourceVersion(currentSource) !== dataFlow.sourceVersion) {
+        return;
+      }
+      fileId = input.registry.registerDataFlowComponents(
+        sourcePath,
+        dataFlow.sourceVersion,
+        dataFlow.components
+      );
+    });
+    registrationQueues.set(sourcePath, current);
+    await current.finally(() => {
+      if (registrationQueues.get(sourcePath) === current) {
+        registrationQueues.delete(sourcePath);
+      }
+    });
+    return fileId;
+  }
   const handler = (request, response) => {
     const handle = async () => {
       const contentType = getSingleHeader3(request, "content-type")?.split(";", 1)[0]?.trim().toLowerCase();
@@ -4058,16 +4299,18 @@ async function createSourceRegistrationService(input) {
       const sourcePath = await resolveAuthorizedSource(
         root,
         parsed.data.resourcePath,
-        (absolutePath) => sourceFilter.shouldTransform(absolutePath, "<")
+        (absolutePath) => parsed.data.dataFlow === void 0 ? sourceFilter.shouldTransform(absolutePath, "<") : dataFlowFilter.shouldTransform(absolutePath, "")
       );
       if (sourcePath === void 0) {
         writeJson3(response, 403, { ok: false });
         return;
       }
-      writeJson3(response, 200, {
-        epoch: input.registryEpoch,
-        fileId: input.registry.register(sourcePath)
-      });
+      const fileId = await registerCurrentSource(sourcePath, parsed.data.dataFlow);
+      if (fileId === void 0) {
+        writeJson3(response, 409, { ok: false });
+        return;
+      }
+      writeJson3(response, 200, { epoch: input.registryEpoch, fileId });
     };
     void handle().catch(() => {
       if (!response.headersSent) {
@@ -4291,8 +4534,10 @@ export {
   readRuntimeBootstrap,
   resolveCredentialEnvironment,
   resolveEnvironmentAiConfiguration,
+  resolveManagedExecutionValidation,
   resolveOptions,
   resolveProjectOptions,
+  resolveProjectValidationChecks,
   resolveRuntimeBootstrapOptions,
   serializeResolvedSpotPatchOptions
 };