@spotpatch/dev-server 0.6.0 → 0.8.0

package/dist/index.cjs

@@ -51,8 +51,10 @@ __export(index_exports, {
   readRuntimeBootstrap: () => readRuntimeBootstrap,
   resolveCredentialEnvironment: () => resolveCredentialEnvironment,
   resolveEnvironmentAiConfiguration: () => resolveEnvironmentAiConfiguration,
+  resolveManagedExecutionValidation: () => resolveManagedExecutionValidation,
   resolveOptions: () => resolveOptions,
   resolveProjectOptions: () => resolveProjectOptions,
+  resolveProjectValidationChecks: () => resolveProjectValidationChecks,
   resolveRuntimeBootstrapOptions: () => resolveRuntimeBootstrapOptions,
   serializeResolvedSpotPatchOptions: () => serializeResolvedSpotPatchOptions
 });
@@ -2250,6 +2252,7 @@ var import_promises3 = require("fs/promises");
 var import_node_module = require("module");
 var import_node_path3 = __toESM(require("path"), 1);
 var import_node_util = require("util");
+var import_shared9 = require("@spotpatch/shared");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var TYPESCRIPT_CHECK_ID = "spotpatch-typecheck";
 var TYPESCRIPT_CHECK_LABEL = "TypeScript";
@@ -2317,6 +2320,15 @@ async function resolveTypeScriptCli(appRoot) {
 function portableRelativePath(from, to) {
   return import_node_path3.default.relative(from, to).split(import_node_path3.default.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 (0, import_promises3.realpath)(options.appRoot);
   const tsconfigPath = import_node_path3.default.join(appRoot, "tsconfig.json");
@@ -2345,6 +2357,8 @@ async function discoverProjectValidationCheck(options) {
       "--noEmit",
       "--pretty",
       "false",
+      "--incremental",
+      "false",
       "--project",
       projectPath
     ]),
@@ -2352,21 +2366,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 ? import_shared9.DEFAULT_AGENT_LIMITS : 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);
@@ -2378,22 +2401,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,
@@ -2456,6 +2472,7 @@ function createSourceRegistry(options = {}) {
         );
       }
       componentIdsByPath.set(normalizedPath, currentIds);
+      return fileId;
     },
     resolve(fileId) {
       return idToPath.get(fileId);
@@ -2473,20 +2490,20 @@ function createSourceRegistry(options = {}) {
 }
 
 // src/server/middleware.ts
-var import_shared18 = require("@spotpatch/shared");
+var import_shared20 = require("@spotpatch/shared");
 
 // src/external-handoff/browser-http.ts
-var import_shared12 = require("@spotpatch/shared");
+var import_shared13 = require("@spotpatch/shared");
 
 // src/server/annotation-authorizer.ts
 var import_promises6 = require("fs/promises");
 var import_node_path7 = __toESM(require("path"), 1);
-var import_shared11 = require("@spotpatch/shared");
+var import_shared12 = require("@spotpatch/shared");
 
 // src/server/source-context.ts
 var import_promises5 = require("fs/promises");
 var import_node_path6 = __toESM(require("path"), 1);
-var import_shared10 = require("@spotpatch/shared");
+var import_shared11 = require("@spotpatch/shared");
 
 // src/server/extract-code-context.ts
 var import_oxc_parser = require("oxc-parser");
@@ -2717,7 +2734,7 @@ function extractCodeContext(options) {
 // src/server/source-file.ts
 var import_promises4 = require("fs/promises");
 var import_node_path5 = __toESM(require("path"), 1);
-var import_shared9 = require("@spotpatch/shared");
+var import_shared10 = require("@spotpatch/shared");
 var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([".jsx", ".tsx"]);
 function isMissingFileError(error) {
   return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
@@ -2732,7 +2749,7 @@ async function assertInsideRoot(root, candidate) {
     ]);
   } catch (error) {
     if (isMissingFileError(error)) {
-      throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.SOURCE_NOT_FOUND, void 0, {
+      throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_NOT_FOUND, void 0, {
         cause: error
       });
     }
@@ -2741,35 +2758,35 @@ async function assertInsideRoot(root, candidate) {
   const relative = import_node_path5.default.relative(realRoot, realCandidate);
   const outside = relative.startsWith(`..${import_node_path5.default.sep}`) || relative === ".." || import_node_path5.default.isAbsolute(relative);
   if (outside) {
-    throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.SOURCE_OUTSIDE_ROOT);
+    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_OUTSIDE_ROOT);
   }
   return realCandidate;
 }
 async function resolveSourceFile(options) {
   const registeredPath = options.registry.resolve(options.fileId);
   if (registeredPath === void 0) {
-    throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.SOURCE_NOT_FOUND);
+    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_NOT_FOUND);
   }
   const sourcePath = await assertInsideRoot(options.root, registeredPath);
   if (!ALLOWED_EXTENSIONS.has(import_node_path5.default.extname(sourcePath).toLowerCase())) {
-    throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.SOURCE_NOT_FOUND);
+    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_NOT_FOUND);
   }
   let sourceStat;
   try {
     sourceStat = await (0, import_promises4.stat)(sourcePath);
   } catch (error) {
     if (isMissingFileError(error)) {
-      throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.SOURCE_NOT_FOUND, void 0, {
+      throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_NOT_FOUND, void 0, {
         cause: error
       });
     }
     throw error;
   }
   if (!sourceStat.isFile()) {
-    throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.SOURCE_NOT_FOUND);
+    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_NOT_FOUND);
   }
   if (sourceStat.size > MAX_SOURCE_FILE_BYTES) {
-    throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.SOURCE_TOO_LARGE);
+    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_TOO_LARGE);
   }
   return sourcePath;
 }
@@ -2789,7 +2806,7 @@ async function readSourceContext(options) {
     source = await (0, import_promises5.readFile)(sourcePath, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
-      throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.SOURCE_NOT_FOUND, void 0, {
+      throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.SOURCE_NOT_FOUND, void 0, {
         cause: error
       });
     }
@@ -2797,7 +2814,7 @@ async function readSourceContext(options) {
   }
   const lines = source.split(/\r?\n/);
   if (options.request.line > lines.length) {
-    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
   }
   const extension = import_node_path6.default.extname(sourcePath).toLowerCase();
   return extractCodeContext({
@@ -2815,9 +2832,9 @@ async function readSourceContext(options) {
 // src/server/annotation-authorizer.ts
 function sanitizePageContext(page) {
   return Object.freeze({
-    url: (0, import_shared11.sanitizeUrl)(page.url, page.url),
-    pathname: (0, import_shared11.redactSensitiveText)(page.pathname),
-    title: (0, import_shared11.redactSensitiveText)(page.title),
+    url: (0, import_shared12.sanitizeUrl)(page.url, page.url),
+    pathname: (0, import_shared12.redactSensitiveText)(page.pathname),
+    title: (0, import_shared12.redactSensitiveText)(page.title),
     viewportWidth: page.viewportWidth,
     viewportHeight: page.viewportHeight,
     devicePixelRatio: page.devicePixelRatio
@@ -2836,18 +2853,18 @@ function compactSourceRef(source) {
 async function authorizeSourceRef(source, registry, root) {
   const markerOrigin = source.origin === "jsx-host" || source.origin === "dom-ancestor";
   if (markerOrigin && (source.fileId === void 0 || source.line === void 0 || source.column === void 0)) {
-    throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
   }
   if (source.fileId === void 0) {
     if (source.origin === "none" && source.relativePath !== void 0) {
-      throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
+      throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
     }
     return compactSourceRef(source);
   }
   const sourcePath = await resolveSourceFile({ fileId: source.fileId, registry, root });
   const relativePath = import_node_path7.default.relative(await (0, import_promises6.realpath)(root), sourcePath).split(import_node_path7.default.sep).join("/");
   if (source.relativePath !== void 0 && source.relativePath !== relativePath) {
-    throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
   }
   return Object.freeze({ ...compactSourceRef(source), relativePath });
 }
@@ -2883,7 +2900,7 @@ async function authorizeTarget(target, input) {
     maxLines: input.options.budget.maxCodeLines
   });
   if (marker === void 0 && target.code !== void 0) {
-    throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
   }
   const code = marker === void 0 ? void 0 : await readSourceContext({
     request: marker,
@@ -2893,7 +2910,7 @@ async function authorizeTarget(target, input) {
     maxLines: input.options.budget.maxCodeLines
   });
   if (target.code !== void 0 && target.code.relativePath !== code?.relativePath) {
-    throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
   }
   return Object.freeze({
     instruction: target.instruction,
@@ -2928,11 +2945,11 @@ async function authorizeTarget(target, input) {
 async function authorizeAnnotation(input) {
   const requestedTargets = input.annotation.targets;
   if (requestedTargets.length > input.options.maxTargets) {
-    throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
   }
   const identities = requestedTargets.map(targetIdentity);
   if (new Set(identities).size !== identities.length) {
-    throw new import_shared11.SpotPatchError(import_shared11.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
   }
   const targets = Object.freeze(
     await Promise.all(requestedTargets.map((target) => authorizeTarget(target, input)))
@@ -2949,29 +2966,29 @@ async function authorizeAnnotation(input) {
 
 // src/external-handoff/browser-http.ts
 function matchExternalHandoffBrowserPath(path9) {
-  if (path9 === import_shared12.SPOTPATCH_ENDPOINTS.externalHandoffCapability) return "capability";
-  if (path9 === import_shared12.SPOTPATCH_ENDPOINTS.externalHandoffPublish) return "publish";
-  if (path9 === import_shared12.SPOTPATCH_ENDPOINTS.externalHandoffStatus) return "status";
-  if (path9 === import_shared12.SPOTPATCH_ENDPOINTS.externalHandoffResolveDelivery) {
+  if (path9 === import_shared13.SPOTPATCH_ENDPOINTS.externalHandoffCapability) return "capability";
+  if (path9 === import_shared13.SPOTPATCH_ENDPOINTS.externalHandoffPublish) return "publish";
+  if (path9 === import_shared13.SPOTPATCH_ENDPOINTS.externalHandoffStatus) return "status";
+  if (path9 === import_shared13.SPOTPATCH_ENDPOINTS.externalHandoffResolveDelivery) {
     return "resolve-delivery";
   }
   return void 0;
 }
 function requireService(options) {
   if (!options.options.externalAgent.enabled || options.service === void 0) {
-    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.EXTERNAL_HANDOFF_DISABLED);
+    throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.EXTERNAL_HANDOFF_DISABLED);
   }
   return options.service;
 }
 function remapAuthorizationError(error) {
-  if (error instanceof import_shared12.SpotPatchError) {
-    if (error.code === import_shared12.ERROR_CODES.SOURCE_NOT_FOUND || error.code === import_shared12.ERROR_CODES.SOURCE_OUTSIDE_ROOT || error.code === import_shared12.ERROR_CODES.SOURCE_TOO_LARGE) {
-      throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.HANDOFF_SOURCE_STALE, void 0, {
+  if (error instanceof import_shared13.SpotPatchError) {
+    if (error.code === import_shared13.ERROR_CODES.SOURCE_NOT_FOUND || error.code === import_shared13.ERROR_CODES.SOURCE_OUTSIDE_ROOT || error.code === import_shared13.ERROR_CODES.SOURCE_TOO_LARGE) {
+      throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.HANDOFF_SOURCE_STALE, void 0, {
         cause: error
       });
     }
-    if (error.code === import_shared12.ERROR_CODES.INVALID_REQUEST) {
-      throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.HANDOFF_VALIDATION_FAILED, void 0, {
+    if (error.code === import_shared13.ERROR_CODES.INVALID_REQUEST) {
+      throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.HANDOFF_VALIDATION_FAILED, void 0, {
         cause: error
       });
     }
@@ -2980,38 +2997,38 @@ function remapAuthorizationError(error) {
 }
 async function handleExternalHandoffBrowserRequest(request, response, route, options, writeSuccess) {
   if (request.method !== "POST") {
-    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.INVALID_REQUEST);
   }
   const service = requireService(options);
   if (route === "capability") {
-    const parsed2 = import_shared12.externalHandoffCapabilityRequestSchema.safeParse(
+    const parsed2 = import_shared13.externalHandoffCapabilityRequestSchema.safeParse(
       await readJsonRequestBody(request)
     );
-    if (!parsed2.success) throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
+    if (!parsed2.success) throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.INVALID_REQUEST);
     writeSuccess(response, 200, service.capability());
     return;
   }
   if (route === "status") {
-    const parsed2 = import_shared12.externalHandoffStatusRequestSchema.safeParse(
+    const parsed2 = import_shared13.externalHandoffStatusRequestSchema.safeParse(
       await readJsonRequestBody(request)
     );
-    if (!parsed2.success) throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
+    if (!parsed2.success) throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.INVALID_REQUEST);
     writeSuccess(response, 200, service.status(parsed2.data.cursor));
     return;
   }
   if (route === "resolve-delivery") {
-    const parsed2 = import_shared12.externalHandoffResolveDeliveryRequestSchema.safeParse(
+    const parsed2 = import_shared13.externalHandoffResolveDeliveryRequestSchema.safeParse(
       await readJsonRequestBody(request)
     );
-    if (!parsed2.success) throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.INVALID_REQUEST);
+    if (!parsed2.success) throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.INVALID_REQUEST);
     writeSuccess(response, 200, service.resolveDelivery(parsed2.data.cursor));
     return;
   }
-  const parsed = import_shared12.externalHandoffPublishRequestSchema.safeParse(
-    await readJsonRequestBody(request, import_shared12.EXTERNAL_HANDOFF_LIMITS.maximumPublishBodyBytes)
+  const parsed = import_shared13.externalHandoffPublishRequestSchema.safeParse(
+    await readJsonRequestBody(request, import_shared13.EXTERNAL_HANDOFF_LIMITS.maximumPublishBodyBytes)
   );
   if (!parsed.success) {
-    throw new import_shared12.SpotPatchError(import_shared12.ERROR_CODES.HANDOFF_VALIDATION_FAILED);
+    throw new import_shared13.SpotPatchError(import_shared13.ERROR_CODES.HANDOFF_VALIDATION_FAILED);
   }
   const result = await service.publish(parsed.data, async (annotation) => {
     try {
@@ -3028,11 +3045,157 @@ 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
 var import_shared14 = require("@spotpatch/shared");
+function matchExternalAgentBrowserPath(path9) {
+  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.externalAgentControlStatus) return "status";
+  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.externalAgentControlConnect) return "connect";
+  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.externalAgentControlDisconnect) {
+    return "disconnect";
+  }
+  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.externalAgentControlCancel) return "cancel";
+  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.externalAgentEvents) return "events";
+  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.externalAgentResult) return "result";
+  return void 0;
+}
+function writeEvent(response, event) {
+  response.write(`${JSON.stringify(import_shared14.externalAgentEventSchema.parse(event))}
+`);
+}
+function createExternalAgentBrowserController(port) {
+  const streams = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const handleEvents = async (request, response) => {
+    const parsed = import_shared14.externalAgentEventsRequestSchema.safeParse(
+      await readJsonRequestBody(request)
+    );
+    if (!parsed.success) {
+      throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    }
+    if (disposed || streams.size >= import_shared14.EXTERNAL_AGENT_CONTROL_LIMITS.maximumEventSubscribers) {
+      throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.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 = import_shared14.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()
+        });
+      }
+    }, import_shared14.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 import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+      }
+      if (route === "events") {
+        await handleEvents(request, response);
+        return;
+      }
+      if (route === "status") {
+        const parsed2 = import_shared14.externalAgentControlStatusRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+        writeSuccess(
+          response,
+          200,
+          import_shared14.externalAgentControlStatusSchema.parse(port.getStatus())
+        );
+        return;
+      }
+      if (route === "connect") {
+        const parsed2 = import_shared14.externalAgentControlConnectRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+        const controller = new AbortController();
+        response.once("close", () => {
+          if (!response.writableEnded) controller.abort("browser-disconnected");
+        });
+        writeSuccess(
+          response,
+          200,
+          import_shared14.externalAgentControlStatusSchema.parse(
+            await port.connect(parsed2.data, controller.signal)
+          )
+        );
+        return;
+      }
+      if (route === "disconnect") {
+        const parsed2 = import_shared14.externalAgentControlDisconnectRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+        writeSuccess(
+          response,
+          200,
+          import_shared14.externalAgentControlStatusSchema.parse(await port.disconnect(parsed2.data))
+        );
+        return;
+      }
+      if (route === "cancel") {
+        const parsed2 = import_shared14.externalAgentControlCancelRequestSchema.safeParse(
+          await readJsonRequestBody(request)
+        );
+        if (!parsed2.success) throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+        writeSuccess(
+          response,
+          200,
+          import_shared14.externalAgentControlStatusSchema.parse(await port.cancel(parsed2.data))
+        );
+        return;
+      }
+      const parsed = import_shared14.externalAgentResultRequestSchema.safeParse(
+        await readJsonRequestBody(request)
+      );
+      if (!parsed.success) throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+      const result = port.getResult(parsed.data.revision);
+      if (result === void 0) {
+        throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.HANDOFF_NOT_FOUND);
+      }
+      writeSuccess(response, 200, import_shared14.externalAgentManagedResultSchema.parse(result));
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const response of streams) response.end();
+      streams.clear();
+    }
+  });
+}
+
+// src/server/agent-http.ts
+var import_shared16 = require("@spotpatch/shared");
 
 // src/server/agent-request.ts
-var import_shared13 = require("@spotpatch/shared");
+var import_shared15 = require("@spotpatch/shared");
 async function authorizeAgentJobRequest(input) {
   const annotation = await authorizeAnnotation({
     annotation: input.request.annotation,
@@ -3069,16 +3232,16 @@ var EVENT_STREAM_END_STATUSES = /* @__PURE__ */ new Set([
   "failed"
 ]);
 function matchAgentRequestPath(path9) {
-  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.agentCapability) {
+  if (path9 === import_shared16.SPOTPATCH_ENDPOINTS.agentCapability) {
     return Object.freeze({ kind: "capability" });
   }
-  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.agentWorkspaceHealth) {
+  if (path9 === import_shared16.SPOTPATCH_ENDPOINTS.agentWorkspaceHealth) {
     return Object.freeze({ kind: "workspace-health" });
   }
-  if (path9 === import_shared14.SPOTPATCH_ENDPOINTS.agentJobs) {
+  if (path9 === import_shared16.SPOTPATCH_ENDPOINTS.agentJobs) {
     return Object.freeze({ kind: "create-job" });
   }
-  const prefix = `${import_shared14.SPOTPATCH_ENDPOINTS.agentJobs}/`;
+  const prefix = `${import_shared16.SPOTPATCH_ENDPOINTS.agentJobs}/`;
   if (!path9.startsWith(prefix)) {
     return void 0;
   }
@@ -3096,7 +3259,7 @@ function matchAgentRequestPath(path9) {
 }
 function requireAgentManager(options) {
   if (options.agentManager === void 0 || options.options.ai === false) {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.AI_DISABLED);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.AI_DISABLED);
   }
   return options.agentManager;
 }
@@ -3149,13 +3312,13 @@ function streamAgentJobEvents(response, manager, jobId) {
 }
 async function handleCapability(request, response, options, writeSuccess) {
   if (request.method !== "POST") {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
-  const parsed = import_shared14.agentCapabilityRequestSchema.safeParse(
+  const parsed = import_shared16.agentCapabilityRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
   const controller = new AbortController();
   const abort = () => {
@@ -3174,13 +3337,13 @@ async function handleCapability(request, response, options, writeSuccess) {
 }
 async function handleCreateJob(request, response, options, writeSuccess) {
   if (request.method !== "POST") {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
-  const parsed = import_shared14.agentJobCreateRequestSchema.safeParse(
+  const parsed = import_shared16.agentJobCreateRequestSchema.safeParse(
     await readJsonRequestBody(request, MAX_AGENT_REQUEST_BODY_BYTES)
   );
   if (!parsed.success) {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
   const authorizedRequest = await authorizeAgentJobRequest({
     request: parsed.data,
@@ -3193,13 +3356,13 @@ async function handleCreateJob(request, response, options, writeSuccess) {
 }
 async function handleWorkspaceHealth(request, response, options, writeSuccess) {
   if (request.method !== "POST") {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
-  const parsed = import_shared14.agentWorkspaceHealthRequestSchema.safeParse(
+  const parsed = import_shared16.agentWorkspaceHealthRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
   const controller = new AbortController();
   const abort = () => {
@@ -3216,13 +3379,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 import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
-  const parsed = import_shared14.agentJobActionRequestSchema.safeParse(
+  const parsed = import_shared16.agentJobActionRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_REQUEST);
   }
   if (route.action === "events") {
     streamAgentJobEvents(response, manager, route.jobId);
@@ -3339,25 +3502,25 @@ var launchConfiguredEditor = createEditorLauncher();
 // src/server/data-flow-http.ts
 var import_node_crypto9 = require("crypto");
 var import_analyzer = require("@spotpatch/analyzer");
-var import_shared15 = require("@spotpatch/shared");
+var import_shared17 = require("@spotpatch/shared");
 function envelopeBytes(report) {
   return Buffer.byteLength(JSON.stringify({ ok: true, data: report }), "utf8");
 }
 function limitDataFlowReportToBytes(report, maximumBytes) {
-  const structurallyLimited = (0, import_shared15.limitDataFlowReportCollections)(report);
+  const structurallyLimited = (0, import_shared17.limitDataFlowReportCollections)(report);
   if (envelopeBytes(structurallyLimited) <= maximumBytes) {
     return structurallyLimited;
   }
-  let limited = (0, import_shared15.limitDataFlowReportCollections)(structurallyLimited, {
+  let limited = (0, import_shared17.limitDataFlowReportCollections)(structurallyLimited, {
     forceTruncation: true,
     maximumDependencies: 0,
     truncatedBy: "bytes"
   });
   if (envelopeBytes(limited) > maximumBytes) {
-    throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.INTERNAL_ERROR);
+    throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.INTERNAL_ERROR);
   }
   for (let maximumDependencies = 1; maximumDependencies <= structurallyLimited.dependencies.length; maximumDependencies += 1) {
-    const candidate = (0, import_shared15.limitDataFlowReportCollections)(structurallyLimited, {
+    const candidate = (0, import_shared17.limitDataFlowReportCollections)(structurallyLimited, {
       forceTruncation: true,
       maximumDependencies,
       truncatedBy: "bytes"
@@ -3383,7 +3546,7 @@ async function analyzeTarget(request, analyzer, options) {
         request.componentSourceId
       );
       if (anchor?.sourceVersion !== request.sourceVersion) {
-        throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.DATA_FLOW_SOURCE_STALE);
+        throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.DATA_FLOW_SOURCE_STALE);
       }
       return anchor;
     }
@@ -3400,7 +3563,7 @@ async function analyzeTarget(request, analyzer, options) {
     column: resolvedRequest.column
   });
   if (resolvedRequest.sourceVersion !== void 0 && resolvedRequest.sourceVersion !== report.component.source.sourceVersion) {
-    throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.DATA_FLOW_SOURCE_STALE);
+    throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.DATA_FLOW_SOURCE_STALE);
   }
   return limitDataFlowReportToBytes(
     report,
@@ -3409,31 +3572,31 @@ async function analyzeTarget(request, analyzer, options) {
 }
 function requireAnalyzer(analyzer) {
   if (analyzer === void 0) {
-    throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.DATA_FLOW_DISABLED);
+    throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.DATA_FLOW_DISABLED);
   }
   return analyzer;
 }
 async function handleComponentDataFlowReport(request, analyzer, options) {
-  const parsed = import_shared15.dataFlowComponentReportRequestSchema.safeParse(
+  const parsed = import_shared17.dataFlowComponentReportRequestSchema.safeParse(
     await readJsonRequestBody(
       request,
       options.options.dataFlow.limits.protocolRequestMaxBytes
     )
   );
   if (!parsed.success) {
-    throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.INVALID_REQUEST);
   }
   return analyzeTarget(parsed.data, requireAnalyzer(analyzer), options);
 }
 async function handlePageDataFlowReport(request, analyzer, options) {
-  const parsed = import_shared15.dataFlowPageReportRequestSchema.safeParse(
+  const parsed = import_shared17.dataFlowPageReportRequestSchema.safeParse(
     await readJsonRequestBody(
       request,
       options.options.dataFlow.limits.protocolRequestMaxBytes
     )
   );
   if (!parsed.success) {
-    throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.INVALID_REQUEST);
   }
   const activeAnalyzer = requireAnalyzer(analyzer);
   const componentReports = await Promise.all(
@@ -3460,7 +3623,7 @@ async function handlePageDataFlowReport(request, analyzer, options) {
   const reportId = `page_${(0, import_node_crypto9.createHash)("sha256").update(componentReports.map((report2) => report2.reportId).join("\0")).digest("base64url").slice(0, 22)}`;
   const complete = componentReports.every((report2) => report2.completeness.complete);
   const report = Object.freeze({
-    schemaVersion: import_shared15.DATA_FLOW_SCHEMA_VERSION,
+    schemaVersion: import_shared17.DATA_FLOW_SCHEMA_VERSION,
     reportId,
     baseline: Object.freeze({
       registryEpoch: options.session.id,
@@ -3506,7 +3669,7 @@ async function handlePageDataFlowReport(request, analyzer, options) {
 // src/server/request-security.ts
 var import_node_crypto10 = require("crypto");
 var import_node_net = require("net");
-var import_shared16 = require("@spotpatch/shared");
+var import_shared18 = require("@spotpatch/shared");
 function getSingleHeader(request, name) {
   const value = request.headers[name.toLowerCase()];
   return Array.isArray(value) ? value[0] : value;
@@ -3551,32 +3714,32 @@ function parseOrigin(value) {
   }
 }
 function assertRequestAuthorized(request, options) {
-  const actualToken = getSingleHeader(request, import_shared16.SPOTPATCH_TOKEN_HEADER);
+  const actualToken = getSingleHeader(request, import_shared18.SPOTPATCH_TOKEN_HEADER);
   if (!tokensMatch2(actualToken, options.sessionToken)) {
-    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.INVALID_TOKEN);
+    throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.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 import_shared16.SpotPatchError(import_shared16.ERROR_CODES.ORIGIN_NOT_ALLOWED);
+    throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.ORIGIN_NOT_ALLOWED);
   }
   const hostIsLoopback = isLoopbackHostname(host.hostname);
   const originIsLoopback = isLoopbackHostname(origin.hostname);
   if (!options.allowLan) {
     if (!hostIsLoopback || !originIsLoopback) {
-      throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.ORIGIN_NOT_ALLOWED);
+      throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.ORIGIN_NOT_ALLOWED);
     }
     return;
   }
   if (!originIsLoopback && origin.host.toLowerCase() !== host.host.toLowerCase()) {
-    throw new import_shared16.SpotPatchError(import_shared16.ERROR_CODES.ORIGIN_NOT_ALLOWED);
+    throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.ORIGIN_NOT_ALLOWED);
   }
 }
 
 // src/server/runtime-bootstrap.ts
-var import_shared17 = require("@spotpatch/shared");
+var import_shared19 = require("@spotpatch/shared");
 function getSingleHeader2(request, name) {
   const value = request.headers[name.toLowerCase()];
   return Array.isArray(value) ? value[0] : value;
@@ -3591,7 +3754,7 @@ function resolveRuntimeBootstrapOptions(options) {
   if (expectedOrigin.origin !== options.expectedOrigin || expectedOrigin.protocol !== "http:" || !isLoopbackHostname(expectedOrigin.hostname)) {
     throw new TypeError("The SpotPatch bootstrap origin must be a loopback origin.");
   }
-  const parsedConfig = import_shared17.runtimeConfigSchema.safeParse(options.runtimeConfig);
+  const parsedConfig = import_shared19.runtimeConfigSchema.safeParse(options.runtimeConfig);
   if (!parsedConfig.success) {
     throw new TypeError("The SpotPatch Runtime configuration is invalid.");
   }
@@ -3603,7 +3766,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 import_shared17.SpotPatchError(import_shared17.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared19.SpotPatchError(import_shared19.ERROR_CODES.INVALID_REQUEST);
   }
   const host = getSingleHeader2(request, "host");
   let hostIsLoopback = false;
@@ -3615,132 +3778,132 @@ function assertRuntimeBootstrapRequest(request, expectedOrigin) {
     }
   }
   if (!hostIsLoopback || getSingleHeader2(request, "origin") !== expectedOrigin || getSingleHeader2(request, "sec-fetch-site") !== "same-origin") {
-    throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.ORIGIN_NOT_ALLOWED);
+    throw new import_shared19.SpotPatchError(import_shared19.ERROR_CODES.ORIGIN_NOT_ALLOWED);
   }
 }
 async function readRuntimeBootstrap(request, options) {
   assertRuntimeBootstrapRequest(request, options.expectedOrigin);
-  const parsedBody = import_shared17.runtimeBootstrapRequestSchema.safeParse(
+  const parsedBody = import_shared19.runtimeBootstrapRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsedBody.success) {
-    throw new import_shared17.SpotPatchError(import_shared17.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared19.SpotPatchError(import_shared19.ERROR_CODES.INVALID_REQUEST);
   }
   return options.runtimeConfig;
 }
 
 // src/server/middleware.ts
 var STATUS_BY_ERROR = Object.freeze({
-  [import_shared18.ERROR_CODES.INVALID_REQUEST]: 400,
-  [import_shared18.ERROR_CODES.INVALID_TOKEN]: 401,
-  [import_shared18.ERROR_CODES.ORIGIN_NOT_ALLOWED]: 403,
-  [import_shared18.ERROR_CODES.SOURCE_NOT_FOUND]: 404,
-  [import_shared18.ERROR_CODES.SOURCE_OUTSIDE_ROOT]: 403,
-  [import_shared18.ERROR_CODES.SOURCE_TOO_LARGE]: 413,
-  [import_shared18.ERROR_CODES.EDITOR_OPEN_FAILED]: 500,
-  [import_shared18.ERROR_CODES.DATA_FLOW_DISABLED]: 404,
-  [import_shared18.ERROR_CODES.DATA_FLOW_SOURCE_STALE]: 409,
-  [import_shared18.ERROR_CODES.DATA_FLOW_ANALYSIS_CANCELLED]: 409,
-  [import_shared18.ERROR_CODES.AI_DISABLED]: 404,
-  [import_shared18.ERROR_CODES.PROVIDER_NOT_CONFIGURED]: 503,
-  [import_shared18.ERROR_CODES.PROVIDER_AUTH_FAILED]: 502,
-  [import_shared18.ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED]: 502,
-  [import_shared18.ERROR_CODES.MODEL_NOT_ALLOWED]: 400,
-  [import_shared18.ERROR_CODES.MODEL_TOOL_CALL_UNSUPPORTED]: 422,
-  [import_shared18.ERROR_CODES.PROVIDER_RATE_LIMITED]: 429,
-  [import_shared18.ERROR_CODES.AGENT_BUSY]: 409,
-  [import_shared18.ERROR_CODES.AGENT_LIMIT_EXCEEDED]: 413,
-  [import_shared18.ERROR_CODES.AGENT_CANCELLED]: 409,
-  [import_shared18.ERROR_CODES.EXTERNAL_HANDOFF_DISABLED]: 404,
-  [import_shared18.ERROR_CODES.EXTERNAL_HANDOFF_UNAVAILABLE]: 503,
-  [import_shared18.ERROR_CODES.HANDOFF_VALIDATION_FAILED]: 422,
-  [import_shared18.ERROR_CODES.HANDOFF_SOURCE_STALE]: 409,
-  [import_shared18.ERROR_CODES.HANDOFF_NOT_FOUND]: 404,
-  [import_shared18.ERROR_CODES.HANDOFF_EXPIRED]: 410,
-  [import_shared18.ERROR_CODES.HANDOFF_CURSOR_INVALID]: 409,
-  [import_shared18.ERROR_CODES.HANDOFF_RESPONSE_TOO_LARGE]: 413,
-  [import_shared18.ERROR_CODES.BRIDGE_UNAUTHORIZED]: 401,
-  [import_shared18.ERROR_CODES.BRIDGE_PROTOCOL_MISMATCH]: 409,
-  [import_shared18.ERROR_CODES.BRIDGE_BUSY]: 429,
-  [import_shared18.ERROR_CODES.EXTERNAL_AGENT_BUSY]: 409,
-  [import_shared18.ERROR_CODES.ACTIVE_ADAPTER_CONFLICT]: 409,
-  [import_shared18.ERROR_CODES.ACTIVE_ADAPTER_LEASE_INVALID]: 409,
-  [import_shared18.ERROR_CODES.ACTIVE_DISPATCH_INVALID]: 409,
-  [import_shared18.ERROR_CODES.SESSION_NOT_FOUND]: 404,
-  [import_shared18.ERROR_CODES.SESSION_AMBIGUOUS]: 409,
-  [import_shared18.ERROR_CODES.SESSION_CLOSED]: 410,
-  [import_shared18.ERROR_CODES.WORKTREE_DIRTY]: 409,
-  [import_shared18.ERROR_CODES.WORKTREE_NOT_REPOSITORY]: 409,
-  [import_shared18.ERROR_CODES.WORKTREE_OPERATION_IN_PROGRESS]: 409,
-  [import_shared18.ERROR_CODES.WORKTREE_CONFLICTED]: 409,
-  [import_shared18.ERROR_CODES.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: 413,
-  [import_shared18.ERROR_CODES.WORKTREE_UNTRACKED_UNSUPPORTED]: 409,
-  [import_shared18.ERROR_CODES.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: 409,
-  [import_shared18.ERROR_CODES.TOOL_DENIED]: 403,
-  [import_shared18.ERROR_CODES.TOOL_INPUT_INVALID]: 422,
-  [import_shared18.ERROR_CODES.TOOL_ARGUMENTS_INVALID]: 422,
-  [import_shared18.ERROR_CODES.TOOL_CALL_ID_CONFLICT]: 422,
-  [import_shared18.ERROR_CODES.TOOL_PATH_DENIED]: 403,
-  [import_shared18.ERROR_CODES.PATCH_REJECTED]: 422,
-  [import_shared18.ERROR_CODES.VALIDATION_FAILED]: 422,
-  [import_shared18.ERROR_CODES.APPLY_CONFLICT]: 409,
-  [import_shared18.ERROR_CODES.INTERNAL_ERROR]: 500
+  [import_shared20.ERROR_CODES.INVALID_REQUEST]: 400,
+  [import_shared20.ERROR_CODES.INVALID_TOKEN]: 401,
+  [import_shared20.ERROR_CODES.ORIGIN_NOT_ALLOWED]: 403,
+  [import_shared20.ERROR_CODES.SOURCE_NOT_FOUND]: 404,
+  [import_shared20.ERROR_CODES.SOURCE_OUTSIDE_ROOT]: 403,
+  [import_shared20.ERROR_CODES.SOURCE_TOO_LARGE]: 413,
+  [import_shared20.ERROR_CODES.EDITOR_OPEN_FAILED]: 500,
+  [import_shared20.ERROR_CODES.DATA_FLOW_DISABLED]: 404,
+  [import_shared20.ERROR_CODES.DATA_FLOW_SOURCE_STALE]: 409,
+  [import_shared20.ERROR_CODES.DATA_FLOW_ANALYSIS_CANCELLED]: 409,
+  [import_shared20.ERROR_CODES.AI_DISABLED]: 404,
+  [import_shared20.ERROR_CODES.PROVIDER_NOT_CONFIGURED]: 503,
+  [import_shared20.ERROR_CODES.PROVIDER_AUTH_FAILED]: 502,
+  [import_shared20.ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED]: 502,
+  [import_shared20.ERROR_CODES.MODEL_NOT_ALLOWED]: 400,
+  [import_shared20.ERROR_CODES.MODEL_TOOL_CALL_UNSUPPORTED]: 422,
+  [import_shared20.ERROR_CODES.PROVIDER_RATE_LIMITED]: 429,
+  [import_shared20.ERROR_CODES.AGENT_BUSY]: 409,
+  [import_shared20.ERROR_CODES.AGENT_LIMIT_EXCEEDED]: 413,
+  [import_shared20.ERROR_CODES.AGENT_CANCELLED]: 409,
+  [import_shared20.ERROR_CODES.EXTERNAL_HANDOFF_DISABLED]: 404,
+  [import_shared20.ERROR_CODES.EXTERNAL_HANDOFF_UNAVAILABLE]: 503,
+  [import_shared20.ERROR_CODES.HANDOFF_VALIDATION_FAILED]: 422,
+  [import_shared20.ERROR_CODES.HANDOFF_SOURCE_STALE]: 409,
+  [import_shared20.ERROR_CODES.HANDOFF_NOT_FOUND]: 404,
+  [import_shared20.ERROR_CODES.HANDOFF_EXPIRED]: 410,
+  [import_shared20.ERROR_CODES.HANDOFF_CURSOR_INVALID]: 409,
+  [import_shared20.ERROR_CODES.HANDOFF_RESPONSE_TOO_LARGE]: 413,
+  [import_shared20.ERROR_CODES.BRIDGE_UNAUTHORIZED]: 401,
+  [import_shared20.ERROR_CODES.BRIDGE_PROTOCOL_MISMATCH]: 409,
+  [import_shared20.ERROR_CODES.BRIDGE_BUSY]: 429,
+  [import_shared20.ERROR_CODES.EXTERNAL_AGENT_BUSY]: 409,
+  [import_shared20.ERROR_CODES.ACTIVE_ADAPTER_CONFLICT]: 409,
+  [import_shared20.ERROR_CODES.ACTIVE_ADAPTER_LEASE_INVALID]: 409,
+  [import_shared20.ERROR_CODES.ACTIVE_DISPATCH_INVALID]: 409,
+  [import_shared20.ERROR_CODES.SESSION_NOT_FOUND]: 404,
+  [import_shared20.ERROR_CODES.SESSION_AMBIGUOUS]: 409,
+  [import_shared20.ERROR_CODES.SESSION_CLOSED]: 410,
+  [import_shared20.ERROR_CODES.WORKTREE_DIRTY]: 409,
+  [import_shared20.ERROR_CODES.WORKTREE_NOT_REPOSITORY]: 409,
+  [import_shared20.ERROR_CODES.WORKTREE_OPERATION_IN_PROGRESS]: 409,
+  [import_shared20.ERROR_CODES.WORKTREE_CONFLICTED]: 409,
+  [import_shared20.ERROR_CODES.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: 413,
+  [import_shared20.ERROR_CODES.WORKTREE_UNTRACKED_UNSUPPORTED]: 409,
+  [import_shared20.ERROR_CODES.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: 409,
+  [import_shared20.ERROR_CODES.TOOL_DENIED]: 403,
+  [import_shared20.ERROR_CODES.TOOL_INPUT_INVALID]: 422,
+  [import_shared20.ERROR_CODES.TOOL_ARGUMENTS_INVALID]: 422,
+  [import_shared20.ERROR_CODES.TOOL_CALL_ID_CONFLICT]: 422,
+  [import_shared20.ERROR_CODES.TOOL_PATH_DENIED]: 403,
+  [import_shared20.ERROR_CODES.PATCH_REJECTED]: 422,
+  [import_shared20.ERROR_CODES.VALIDATION_FAILED]: 422,
+  [import_shared20.ERROR_CODES.APPLY_CONFLICT]: 409,
+  [import_shared20.ERROR_CODES.INTERNAL_ERROR]: 500
 });
 var PUBLIC_MESSAGES = Object.freeze({
-  [import_shared18.ERROR_CODES.INVALID_REQUEST]: "The request is invalid.",
-  [import_shared18.ERROR_CODES.INVALID_TOKEN]: "The session token is invalid.",
-  [import_shared18.ERROR_CODES.ORIGIN_NOT_ALLOWED]: "The request origin is not allowed.",
-  [import_shared18.ERROR_CODES.SOURCE_NOT_FOUND]: "The source file is unavailable.",
-  [import_shared18.ERROR_CODES.SOURCE_OUTSIDE_ROOT]: "The source file is outside the project root.",
-  [import_shared18.ERROR_CODES.SOURCE_TOO_LARGE]: "The source file exceeds the size limit.",
-  [import_shared18.ERROR_CODES.EDITOR_OPEN_FAILED]: "The editor request could not be started.",
-  [import_shared18.ERROR_CODES.DATA_FLOW_DISABLED]: "Component data-flow analysis is not enabled.",
-  [import_shared18.ERROR_CODES.DATA_FLOW_SOURCE_STALE]: "The selected source version is stale.",
-  [import_shared18.ERROR_CODES.DATA_FLOW_ANALYSIS_CANCELLED]: "The data-flow analysis was cancelled.",
-  [import_shared18.ERROR_CODES.AI_DISABLED]: "AI execution is not enabled.",
-  [import_shared18.ERROR_CODES.PROVIDER_NOT_CONFIGURED]: "The AI provider is unavailable.",
-  [import_shared18.ERROR_CODES.PROVIDER_AUTH_FAILED]: "The AI provider rejected authentication.",
-  [import_shared18.ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED]: "The AI provider protocol is unsupported.",
-  [import_shared18.ERROR_CODES.MODEL_NOT_ALLOWED]: "The selected model is not allowed.",
-  [import_shared18.ERROR_CODES.MODEL_TOOL_CALL_UNSUPPORTED]: "The selected model cannot run SpotPatch tools.",
-  [import_shared18.ERROR_CODES.PROVIDER_RATE_LIMITED]: "The AI provider is rate limited.",
-  [import_shared18.ERROR_CODES.AGENT_BUSY]: "Another Agent job is already running.",
-  [import_shared18.ERROR_CODES.AGENT_LIMIT_EXCEEDED]: "The Agent job exceeded a safety limit.",
-  [import_shared18.ERROR_CODES.AGENT_CANCELLED]: "The Agent job was cancelled.",
-  [import_shared18.ERROR_CODES.EXTERNAL_HANDOFF_DISABLED]: "External Agent handoff is not enabled.",
-  [import_shared18.ERROR_CODES.EXTERNAL_HANDOFF_UNAVAILABLE]: "External Agent handoff is temporarily unavailable.",
-  [import_shared18.ERROR_CODES.HANDOFF_VALIDATION_FAILED]: "The handoff content is invalid.",
-  [import_shared18.ERROR_CODES.HANDOFF_SOURCE_STALE]: "The selected source is stale.",
-  [import_shared18.ERROR_CODES.HANDOFF_NOT_FOUND]: "No current handoff is available.",
-  [import_shared18.ERROR_CODES.HANDOFF_EXPIRED]: "The handoff has expired.",
-  [import_shared18.ERROR_CODES.HANDOFF_CURSOR_INVALID]: "The handoff cursor is invalid.",
-  [import_shared18.ERROR_CODES.HANDOFF_RESPONSE_TOO_LARGE]: "The handoff exceeds the size limit.",
-  [import_shared18.ERROR_CODES.BRIDGE_UNAUTHORIZED]: "The local bridge request is unauthorized.",
-  [import_shared18.ERROR_CODES.BRIDGE_PROTOCOL_MISMATCH]: "The local bridge protocol is incompatible.",
-  [import_shared18.ERROR_CODES.BRIDGE_BUSY]: "The local bridge is busy.",
-  [import_shared18.ERROR_CODES.EXTERNAL_AGENT_BUSY]: "The connected external Agent is busy.",
-  [import_shared18.ERROR_CODES.ACTIVE_ADAPTER_CONFLICT]: "Another active Agent adapter is connected.",
-  [import_shared18.ERROR_CODES.ACTIVE_ADAPTER_LEASE_INVALID]: "The active Agent adapter lease is invalid.",
-  [import_shared18.ERROR_CODES.ACTIVE_DISPATCH_INVALID]: "The active Agent dispatch transition is invalid.",
-  [import_shared18.ERROR_CODES.SESSION_NOT_FOUND]: "No active SpotPatch session was found.",
-  [import_shared18.ERROR_CODES.SESSION_AMBIGUOUS]: "More than one SpotPatch session matches.",
-  [import_shared18.ERROR_CODES.SESSION_CLOSED]: "The SpotPatch session has closed.",
-  [import_shared18.ERROR_CODES.WORKTREE_DIRTY]: "Local changes require explicit inclusion consent.",
-  [import_shared18.ERROR_CODES.WORKTREE_NOT_REPOSITORY]: "The project root is not a Git repository.",
-  [import_shared18.ERROR_CODES.WORKTREE_OPERATION_IN_PROGRESS]: "A Git operation is currently in progress.",
-  [import_shared18.ERROR_CODES.WORKTREE_CONFLICTED]: "The local workspace contains unresolved merge conflicts.",
-  [import_shared18.ERROR_CODES.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: "The local workspace exceeds the safe isolation size limit.",
-  [import_shared18.ERROR_CODES.WORKTREE_UNTRACKED_UNSUPPORTED]: "An untracked path cannot be isolated safely.",
-  [import_shared18.ERROR_CODES.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: "The local workspace state cannot be isolated safely.",
-  [import_shared18.ERROR_CODES.TOOL_DENIED]: "The Agent tool request was denied.",
-  [import_shared18.ERROR_CODES.TOOL_INPUT_INVALID]: "The Agent tool input was invalid.",
-  [import_shared18.ERROR_CODES.TOOL_ARGUMENTS_INVALID]: "The Agent tool arguments are invalid.",
-  [import_shared18.ERROR_CODES.TOOL_CALL_ID_CONFLICT]: "A tool call ID conflicts within one Agent turn.",
-  [import_shared18.ERROR_CODES.TOOL_PATH_DENIED]: "The Agent tool path was denied.",
-  [import_shared18.ERROR_CODES.PATCH_REJECTED]: "The proposed patch was rejected.",
-  [import_shared18.ERROR_CODES.VALIDATION_FAILED]: "The proposed change failed validation.",
-  [import_shared18.ERROR_CODES.APPLY_CONFLICT]: "The change conflicts with the current worktree.",
-  [import_shared18.ERROR_CODES.INTERNAL_ERROR]: "The request could not be completed."
+  [import_shared20.ERROR_CODES.INVALID_REQUEST]: "The request is invalid.",
+  [import_shared20.ERROR_CODES.INVALID_TOKEN]: "The session token is invalid.",
+  [import_shared20.ERROR_CODES.ORIGIN_NOT_ALLOWED]: "The request origin is not allowed.",
+  [import_shared20.ERROR_CODES.SOURCE_NOT_FOUND]: "The source file is unavailable.",
+  [import_shared20.ERROR_CODES.SOURCE_OUTSIDE_ROOT]: "The source file is outside the project root.",
+  [import_shared20.ERROR_CODES.SOURCE_TOO_LARGE]: "The source file exceeds the size limit.",
+  [import_shared20.ERROR_CODES.EDITOR_OPEN_FAILED]: "The editor request could not be started.",
+  [import_shared20.ERROR_CODES.DATA_FLOW_DISABLED]: "Component data-flow analysis is not enabled.",
+  [import_shared20.ERROR_CODES.DATA_FLOW_SOURCE_STALE]: "The selected source version is stale.",
+  [import_shared20.ERROR_CODES.DATA_FLOW_ANALYSIS_CANCELLED]: "The data-flow analysis was cancelled.",
+  [import_shared20.ERROR_CODES.AI_DISABLED]: "AI execution is not enabled.",
+  [import_shared20.ERROR_CODES.PROVIDER_NOT_CONFIGURED]: "The AI provider is unavailable.",
+  [import_shared20.ERROR_CODES.PROVIDER_AUTH_FAILED]: "The AI provider rejected authentication.",
+  [import_shared20.ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED]: "The AI provider protocol is unsupported.",
+  [import_shared20.ERROR_CODES.MODEL_NOT_ALLOWED]: "The selected model is not allowed.",
+  [import_shared20.ERROR_CODES.MODEL_TOOL_CALL_UNSUPPORTED]: "The selected model cannot run SpotPatch tools.",
+  [import_shared20.ERROR_CODES.PROVIDER_RATE_LIMITED]: "The AI provider is rate limited.",
+  [import_shared20.ERROR_CODES.AGENT_BUSY]: "Another Agent job is already running.",
+  [import_shared20.ERROR_CODES.AGENT_LIMIT_EXCEEDED]: "The Agent job exceeded a safety limit.",
+  [import_shared20.ERROR_CODES.AGENT_CANCELLED]: "The Agent job was cancelled.",
+  [import_shared20.ERROR_CODES.EXTERNAL_HANDOFF_DISABLED]: "External Agent handoff is not enabled.",
+  [import_shared20.ERROR_CODES.EXTERNAL_HANDOFF_UNAVAILABLE]: "External Agent handoff is temporarily unavailable.",
+  [import_shared20.ERROR_CODES.HANDOFF_VALIDATION_FAILED]: "The handoff content is invalid.",
+  [import_shared20.ERROR_CODES.HANDOFF_SOURCE_STALE]: "The selected source is stale.",
+  [import_shared20.ERROR_CODES.HANDOFF_NOT_FOUND]: "No current handoff is available.",
+  [import_shared20.ERROR_CODES.HANDOFF_EXPIRED]: "The handoff has expired.",
+  [import_shared20.ERROR_CODES.HANDOFF_CURSOR_INVALID]: "The handoff cursor is invalid.",
+  [import_shared20.ERROR_CODES.HANDOFF_RESPONSE_TOO_LARGE]: "The handoff exceeds the size limit.",
+  [import_shared20.ERROR_CODES.BRIDGE_UNAUTHORIZED]: "The local bridge request is unauthorized.",
+  [import_shared20.ERROR_CODES.BRIDGE_PROTOCOL_MISMATCH]: "The local bridge protocol is incompatible.",
+  [import_shared20.ERROR_CODES.BRIDGE_BUSY]: "The local bridge is busy.",
+  [import_shared20.ERROR_CODES.EXTERNAL_AGENT_BUSY]: "The connected external Agent is busy.",
+  [import_shared20.ERROR_CODES.ACTIVE_ADAPTER_CONFLICT]: "Another active Agent adapter is connected.",
+  [import_shared20.ERROR_CODES.ACTIVE_ADAPTER_LEASE_INVALID]: "The active Agent adapter lease is invalid.",
+  [import_shared20.ERROR_CODES.ACTIVE_DISPATCH_INVALID]: "The active Agent dispatch transition is invalid.",
+  [import_shared20.ERROR_CODES.SESSION_NOT_FOUND]: "No active SpotPatch session was found.",
+  [import_shared20.ERROR_CODES.SESSION_AMBIGUOUS]: "More than one SpotPatch session matches.",
+  [import_shared20.ERROR_CODES.SESSION_CLOSED]: "The SpotPatch session has closed.",
+  [import_shared20.ERROR_CODES.WORKTREE_DIRTY]: "Local changes require explicit inclusion consent.",
+  [import_shared20.ERROR_CODES.WORKTREE_NOT_REPOSITORY]: "The project root is not a Git repository.",
+  [import_shared20.ERROR_CODES.WORKTREE_OPERATION_IN_PROGRESS]: "A Git operation is currently in progress.",
+  [import_shared20.ERROR_CODES.WORKTREE_CONFLICTED]: "The local workspace contains unresolved merge conflicts.",
+  [import_shared20.ERROR_CODES.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: "The local workspace exceeds the safe isolation size limit.",
+  [import_shared20.ERROR_CODES.WORKTREE_UNTRACKED_UNSUPPORTED]: "An untracked path cannot be isolated safely.",
+  [import_shared20.ERROR_CODES.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: "The local workspace state cannot be isolated safely.",
+  [import_shared20.ERROR_CODES.TOOL_DENIED]: "The Agent tool request was denied.",
+  [import_shared20.ERROR_CODES.TOOL_INPUT_INVALID]: "The Agent tool input was invalid.",
+  [import_shared20.ERROR_CODES.TOOL_ARGUMENTS_INVALID]: "The Agent tool arguments are invalid.",
+  [import_shared20.ERROR_CODES.TOOL_CALL_ID_CONFLICT]: "A tool call ID conflicts within one Agent turn.",
+  [import_shared20.ERROR_CODES.TOOL_PATH_DENIED]: "The Agent tool path was denied.",
+  [import_shared20.ERROR_CODES.PATCH_REJECTED]: "The proposed patch was rejected.",
+  [import_shared20.ERROR_CODES.VALIDATION_FAILED]: "The proposed change failed validation.",
+  [import_shared20.ERROR_CODES.APPLY_CONFLICT]: "The change conflicts with the current worktree.",
+  [import_shared20.ERROR_CODES.INTERNAL_ERROR]: "The request could not be completed."
 });
 function writeJson2(response, status, payload) {
   response.statusCode = status;
@@ -3749,11 +3912,11 @@ function writeJson2(response, status, payload) {
   response.end(JSON.stringify(payload));
 }
 function asSpotPatchError(error) {
-  return error instanceof import_shared18.SpotPatchError ? error : new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INTERNAL_ERROR, void 0, { cause: error });
+  return error instanceof import_shared20.SpotPatchError ? error : new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.INTERNAL_ERROR, void 0, { cause: error });
 }
 function writeError(response, error, logger) {
   const normalized = asSpotPatchError(error);
-  if (normalized.code === import_shared18.ERROR_CODES.INTERNAL_ERROR) {
+  if (normalized.code === import_shared20.ERROR_CODES.INTERNAL_ERROR) {
     logger?.warn("[spotpatch:server] Internal request failure.");
   }
   writeJson2(response, STATUS_BY_ERROR[normalized.code], {
@@ -3772,11 +3935,11 @@ function requestPath(request) {
   }
 }
 async function handleSourceContext(request, options) {
-  const parsed = import_shared18.sourceContextRequestSchema.safeParse(
+  const parsed = import_shared20.sourceContextRequestSchema.safeParse(
     await readJsonRequestBody(request)
   );
   if (!parsed.success) {
-    throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.INVALID_REQUEST);
   }
   return readSourceContext({
     request: parsed.data,
@@ -3787,9 +3950,9 @@ async function handleSourceContext(request, options) {
   });
 }
 async function handleOpenEditor(request, options) {
-  const parsed = import_shared18.openEditorRequestSchema.safeParse(await readJsonRequestBody(request));
+  const parsed = import_shared20.openEditorRequestSchema.safeParse(await readJsonRequestBody(request));
   if (!parsed.success) {
-    throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INVALID_REQUEST);
+    throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.INVALID_REQUEST);
   }
   const body = parsed.data;
   const sourcePath = await resolveSourceFile({
@@ -3806,7 +3969,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 import_shared18.SpotPatchError(import_shared18.ERROR_CODES.EDITOR_OPEN_FAILED, void 0, {
+    throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.EDITOR_OPEN_FAILED, void 0, {
       cause: error
     });
   }
@@ -3814,16 +3977,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 !== import_shared18.SPOTPATCH_ENDPOINTS.sourceContext && path9 !== import_shared18.SPOTPATCH_ENDPOINTS.openEditor && path9 !== import_shared18.SPOTPATCH_ENDPOINTS.dataFlowComponentReport && path9 !== import_shared18.SPOTPATCH_ENDPOINTS.dataFlowPageReport && agentRoute === void 0 && externalHandoffRoute === void 0 && !path9.startsWith(`${import_shared18.SPOTPATCH_API_BASE}/`)) {
+    if (path9 !== import_shared20.SPOTPATCH_ENDPOINTS.sourceContext && path9 !== import_shared20.SPOTPATCH_ENDPOINTS.openEditor && path9 !== import_shared20.SPOTPATCH_ENDPOINTS.dataFlowComponentReport && path9 !== import_shared20.SPOTPATCH_ENDPOINTS.dataFlowPageReport && agentRoute === void 0 && externalAgentRoute === void 0 && externalHandoffRoute === void 0 && !path9.startsWith(`${import_shared20.SPOTPATCH_API_BASE}/`)) {
       next();
       return;
     }
     const handle = async () => {
-      if (path9 === import_shared18.SPOTPATCH_ENDPOINTS.bootstrap && bootstrap !== void 0) {
+      if (path9 === import_shared20.SPOTPATCH_ENDPOINTS.bootstrap && bootstrap !== void 0) {
         const data = await readRuntimeBootstrap(
           request,
           bootstrap
@@ -3835,25 +4000,25 @@ function createSpotPatchMiddleware(options) {
         allowLan: options.options.allowLan,
         sessionToken: options.session.token
       });
-      if (path9 === import_shared18.SPOTPATCH_ENDPOINTS.sourceContext) {
+      if (path9 === import_shared20.SPOTPATCH_ENDPOINTS.sourceContext) {
         if (request.method !== "POST") {
-          throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INVALID_REQUEST);
+          throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.INVALID_REQUEST);
         }
         const data = await handleSourceContext(request, options);
         writeJson2(response, 200, { ok: true, data });
         return;
       }
-      if (path9 === import_shared18.SPOTPATCH_ENDPOINTS.openEditor) {
+      if (path9 === import_shared20.SPOTPATCH_ENDPOINTS.openEditor) {
         if (request.method !== "POST") {
-          throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INVALID_REQUEST);
+          throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.INVALID_REQUEST);
         }
         const data = await handleOpenEditor(request, options);
         writeJson2(response, 200, { ok: true, data });
         return;
       }
-      if (path9 === import_shared18.SPOTPATCH_ENDPOINTS.dataFlowComponentReport) {
+      if (path9 === import_shared20.SPOTPATCH_ENDPOINTS.dataFlowComponentReport) {
         if (request.method !== "POST") {
-          throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INVALID_REQUEST);
+          throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.INVALID_REQUEST);
         }
         const data = await handleComponentDataFlowReport(
           request,
@@ -3863,14 +4028,28 @@ function createSpotPatchMiddleware(options) {
         writeJson2(response, 200, { ok: true, data });
         return;
       }
-      if (path9 === import_shared18.SPOTPATCH_ENDPOINTS.dataFlowPageReport) {
+      if (path9 === import_shared20.SPOTPATCH_ENDPOINTS.dataFlowPageReport) {
         if (request.method !== "POST") {
-          throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INVALID_REQUEST);
+          throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.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 import_shared20.SpotPatchError(import_shared20.ERROR_CODES.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,
@@ -3889,7 +4068,7 @@ function createSpotPatchMiddleware(options) {
         return;
       }
       if (agentRoute === void 0) {
-        throw new import_shared18.SpotPatchError(import_shared18.ERROR_CODES.INVALID_REQUEST);
+        throw new import_shared20.SpotPatchError(import_shared20.ERROR_CODES.INVALID_REQUEST);
       }
       await handleAgentRequest(
         request,
@@ -3905,6 +4084,11 @@ function createSpotPatchMiddleware(options) {
       writeError(response, error, options.logger);
     });
   };
+  return Object.assign(middleware, {
+    dispose() {
+      externalAgentController?.dispose();
+    }
+  });
 }
 
 // src/server/source-registration.ts
@@ -3912,14 +4096,26 @@ var import_node_crypto11 = require("crypto");
 var import_promises7 = require("fs/promises");
 var import_node_path8 = __toESM(require("path"), 1);
 var import_compiler = require("@spotpatch/compiler");
+var import_shared21 = require("@spotpatch/shared");
 var import_zod2 = require("zod");
-var REGISTRATION_BODY_LIMIT_BYTES = 4096;
+var REGISTRATION_BODY_LIMIT_BYTES = import_shared21.DEFAULT_DATA_FLOW_LIMITS.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 = import_zod2.z.strictObject({
   epoch: import_zod2.z.string().regex(REGISTRATION_IDENTITY_PATTERN),
-  resourcePath: import_zod2.z.string().min(1).max(3072)
+  resourcePath: import_zod2.z.string().min(1).max(3072),
+  dataFlow: import_zod2.z.strictObject({
+    sourceVersion: import_zod2.z.string().regex(DATA_FLOW_IDENTITY_PATTERN),
+    components: import_zod2.z.array(
+      import_zod2.z.strictObject({
+        componentSourceId: import_zod2.z.string().regex(DATA_FLOW_IDENTITY_PATTERN),
+        line: import_zod2.z.number().int().positive().max(1e7),
+        column: import_zod2.z.number().int().positive().max(1e7)
+      })
+    ).max(import_shared21.DEFAULT_DATA_FLOW_LIMITS.sourceMaxComponents)
+  }).optional()
 });
 function getSingleHeader3(request, name) {
   const value = request.headers[name.toLowerCase()];
@@ -3983,6 +4179,33 @@ async function createSourceRegistrationService(input) {
   }
   const root = await (0, import_promises7.realpath)(input.root);
   const sourceFilter = (0, import_compiler.createSourceFilter)(root, input.options);
+  const dataFlowFilter = (0, import_compiler.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 (0, import_promises7.readFile)(sourcePath, "utf8");
+      if ((0, import_compiler.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();
@@ -4003,16 +4226,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) {
@@ -4237,8 +4462,10 @@ function parseSerializedSpotPatchOptions(value) {
   readRuntimeBootstrap,
   resolveCredentialEnvironment,
   resolveEnvironmentAiConfiguration,
+  resolveManagedExecutionValidation,
   resolveOptions,
   resolveProjectOptions,
+  resolveProjectValidationChecks,
   resolveRuntimeBootstrapOptions,
   serializeResolvedSpotPatchOptions
 });