opendevbrowser 0.0.24 → 0.0.26

package/dist/{chunk-5I6TZRVS.js → chunk-GTTYIAI7.js}

@@ -8,6 +8,25 @@ import {
   applyRuntimePreviewBridge
 } from "./chunk-Y2KL55OG.js";
 import {
+  CANVAS_BROWSER_VALIDATION_MODES,
+  CANVAS_GENERATION_PLAN_REQUIRED_FIELDS,
+  CANVAS_GOVERNANCE_BLOCK_KEYS,
+  CANVAS_INTERACTION_STATES,
+  CANVAS_KEYBOARD_NAVIGATION_MODES,
+  CANVAS_MOTION_LEVELS,
+  CANVAS_NAVIGATION_MODELS,
+  CANVAS_OPTIONAL_INHERITED_GOVERNANCE_KEYS,
+  CANVAS_PLAN_THEMES,
+  CANVAS_PLAN_VIEWPORTS,
+  CANVAS_PUBLIC_WARNING_CLASSES,
+  CANVAS_REDUCED_MOTION_POLICIES,
+  CANVAS_REQUIRED_MUTATION_GOVERNANCE_KEYS,
+  CANVAS_REQUIRED_SAVE_GOVERNANCE_KEYS,
+  CANVAS_SCHEMA_VERSION,
+  CANVAS_SESSION_MODES,
+  CANVAS_THEME_STRATEGIES,
+  CANVAS_VALIDATION_TARGET_BLOCK_ON_CODES,
+  CANVAS_VISUAL_DIRECTION_PROFILES,
   ChallengeOrchestrator,
   buildBlockerArtifacts,
   buildMacroResolveSuccessHandoff,
@@ -28,7 +47,7 @@ import {
   runResearchWorkflow,
   runShoppingWorkflow,
   toSnippet
-} from "./chunk-K2TEHJCV.js";
+} from "./chunk-AVQL6WAS.js";
 import {
   ProviderRuntimeError
 } from "./chunk-FUSXMW3G.js";
@@ -1147,7 +1166,7 @@ function shouldRetry(error) {
   return !/missing|invalid|unknown ref|no active target/i.test(message);
 }
 function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
 // src/annotate/agent-inbox-store.ts
@@ -1907,7 +1926,7 @@ var buildCommandFailureMessage = (file, args2, stderr, signal) => {
   }
   return signal ? `Command failed: ${command} (${signal})` : `Command failed: ${command}`;
 };
-var spawnFileAsync = (file, args2 = [], options = {}) => new Promise((resolve8, reject) => {
+var spawnFileAsync = (file, args2 = [], options = {}) => new Promise((resolve9, reject) => {
   const encoding = options.encoding ?? "utf8";
   const maxBuffer = options.maxBuffer ?? MAX_PROCESS_OUTPUT_BYTES;
   const child = spawn(file, [...args2], { stdio: ["ignore", "pipe", "pipe"] });
@@ -1952,7 +1971,7 @@ var spawnFileAsync = (file, args2 = [], options = {}) => new Promise((resolve8,
   child.on("error", fail);
   child.on("close", (code, signal) => {
     if (code === 0) {
-      settle(() => resolve8({
+      settle(() => resolve9({
         stdout: decodeProcessOutput(stdout, encoding),
         stderr: decodeProcessOutput(stderr, encoding)
       }));
@@ -2684,14 +2703,14 @@ var OpsClient = class _OpsClient {
       if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
         this.clearReconnectTimer();
         this.socket = new WebSocket(this.url);
-        await new Promise((resolve8, reject) => {
+        await new Promise((resolve9, reject) => {
           if (!this.socket) {
             reject(new Error("Ops socket not created"));
             return;
           }
           const onOpen = () => {
             cleanup();
-            resolve8();
+            resolve9();
           };
           const onError = (error) => {
             cleanup();
@@ -2718,13 +2737,13 @@ var OpsClient = class _OpsClient {
         version: OPS_PROTOCOL_VERSION,
         maxPayloadBytes: this.maxPayloadBytes
       };
-      const ack = await new Promise((resolve8, reject) => {
+      const ack = await new Promise((resolve9, reject) => {
         const timeoutId = setTimeout(() => {
           reject(new Error("Ops handshake timeout"));
         }, this.handshakeTimeoutMs);
         const handler = (message) => {
           clearTimeout(timeoutId);
-          resolve8(message);
+          resolve9(message);
         };
         this.waitForHelloAck(handler, reject);
         try {
@@ -2775,7 +2794,7 @@ var OpsClient = class _OpsClient {
     if (!socket || socket.readyState === WebSocket.CLOSED) {
       return;
     }
-    this.disconnectPromise = new Promise((resolve8) => {
+    this.disconnectPromise = new Promise((resolve9) => {
       let settled = false;
       const finalize = () => {
         if (settled) return;
@@ -2784,7 +2803,7 @@ var OpsClient = class _OpsClient {
         socket.removeListener("close", onClose);
         socket.removeListener("error", onError);
         this.disconnectPromise = null;
-        resolve8();
+        resolve9();
       };
       const onClose = () => {
         finalize();
@@ -2830,7 +2849,7 @@ var OpsClient = class _OpsClient {
     if (Buffer.byteLength(serialized) > this.maxPayloadBytes) {
       throw new Error("Ops request payload exceeded max size");
     }
-    return await new Promise((resolve8, reject) => {
+    return await new Promise((resolve9, reject) => {
       const timeoutId = setTimeout(() => {
         this.pendingRequests.delete(requestId);
         reject(new OpsRequestTimeoutError({
@@ -2841,7 +2860,7 @@ var OpsClient = class _OpsClient {
           ...typeof leaseId === "string" ? { leaseId } : {}
         }));
       }, timeoutMs);
-      const resolvePending = (value) => resolve8(value);
+      const resolvePending = (value) => resolve9(value);
       this.pendingRequests.set(requestId, { resolve: resolvePending, reject, timeoutId });
       try {
         this.sendRaw(serialized);
@@ -2988,12 +3007,12 @@ var OpsClient = class _OpsClient {
     }
     const id2 = randomUUID5();
     const ping = { type: "ops_ping", id: id2 };
-    return await new Promise((resolve8, reject) => {
+    return await new Promise((resolve9, reject) => {
       const timeoutId = setTimeout(() => {
         this.pendingPings.delete(id2);
         reject(new Error("Ops ping timed out"));
       }, this.pingTimeoutMs);
-      this.pendingPings.set(id2, { resolve: resolve8, reject, timeoutId });
+      this.pendingPings.set(id2, { resolve: resolve9, reject, timeoutId });
       try {
         this.send(ping);
       } catch (error) {
@@ -3184,7 +3203,7 @@ var shouldAttachExtensionStartUrl = (request) => request.source === "social" ||
 var SOCIAL_EXTENSION_MODE_ATTEMPTS = 3;
 var resolveSocialExtensionModeAttempts = (request, preferredMode) => preferredMode === "extension" && request.source === "social" ? SOCIAL_EXTENSION_MODE_ATTEMPTS : 1;
 var waitForSocialExtensionRetryGap = async () => {
-  await new Promise((resolve8) => setTimeout(resolve8, SOCIAL_EXTENSION_RETRY_DELAY_MS));
+  await new Promise((resolve9) => setTimeout(resolve9, SOCIAL_EXTENSION_RETRY_DELAY_MS));
 };
 var resolveFallbackNavigationWaitUntil = (source, mode) => source === "shopping" && mode === "managed_headed" ? "domcontentloaded" : "load";
 var normalizeExtensionAttachUrl = (value) => {
@@ -3417,7 +3436,7 @@ var waitForFallbackCaptureDelay = async (delayMs, waitForTimeout) => {
     await waitForTimeout(delayMs);
     return;
   }
-  await new Promise((resolve8) => setTimeout(resolve8, delayMs));
+  await new Promise((resolve9) => setTimeout(resolve9, delayMs));
 };
 var waitForFallbackPageToSettle = async (manager, sessionId, _source, timeoutMs) => {
   if (typeof manager.waitForLoad !== "function") return;
@@ -5937,13 +5956,14 @@ function pushCanarySample(state, policy, sample) {
   const samples = [...state.samples, sample].slice(-windowSize);
   const averageScore = average(samples.map((entry) => Math.max(0, Math.min(100, entry.score))));
   const minSamples = Math.max(1, policy.minSamples);
+  const hadEligibleWindow = state.samples.length >= minSamples;
   let action = "none";
   let level = state.level;
   if (samples.length >= minSamples) {
-    if (averageScore >= policy.promoteThreshold) {
+    if (averageScore >= policy.promoteThreshold && (!hadEligibleWindow || state.averageScore < policy.promoteThreshold)) {
       level += 1;
       action = "promote";
-    } else if (averageScore <= policy.rollbackThreshold) {
+    } else if (averageScore <= policy.rollbackThreshold && (!hadEligibleWindow || state.averageScore > policy.rollbackThreshold)) {
       level = Math.max(0, level - 1);
       action = "rollback";
     }
@@ -6408,14 +6428,14 @@ var TargetManager = class {
   }
 };
 var readWithTimeout = async (reader, timeoutMs = TARGET_INFO_TIMEOUT_MS) => {
-  return await new Promise((resolve8) => {
-    const timeoutId = setTimeout(() => resolve8(void 0), timeoutMs);
+  return await new Promise((resolve9) => {
+    const timeoutId = setTimeout(() => resolve9(void 0), timeoutMs);
     reader().then((value) => {
       clearTimeout(timeoutId);
-      resolve8(value);
+      resolve9(value);
     }).catch(() => {
       clearTimeout(timeoutId);
-      resolve8(void 0);
+      resolve9(void 0);
     });
   });
 };
@@ -10328,13 +10348,13 @@ var BrowserManager = class {
       state.inflight += 1;
       return;
     }
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       const enqueuedAt = Date.now();
       const waiter = {
         targetId,
         enqueuedAt,
         timeoutMs,
-        resolve: resolve8,
+        resolve: resolve9,
         reject,
         timer: null
       };
@@ -10379,8 +10399,8 @@ var BrowserManager = class {
     const previous = this.targetQueues.get(queueKey) ?? Promise.resolve();
     let releaseQueue = () => {
     };
-    const gate = new Promise((resolve8) => {
-      releaseQueue = resolve8;
+    const gate = new Promise((resolve9) => {
+      releaseQueue = resolve9;
     });
     const tail = previous.then(() => gate, () => gate);
     this.targetQueues.set(queueKey, tail);
@@ -10587,14 +10607,14 @@ var BrowserManager = class {
     };
     const pendingClick = {
       dialogOpened: false,
-      dialogHandled: new Promise((resolve8) => {
-        resolveDialogHandled = resolve8;
+      dialogHandled: new Promise((resolve9) => {
+        resolveDialogHandled = resolve9;
       }),
       resolveDialogHandled: () => {
         resolveDialogHandled();
       },
-      completed: new Promise((resolve8) => {
-        resolveCompleted = resolve8;
+      completed: new Promise((resolve9) => {
+        resolveCompleted = resolve9;
       }),
       resolveCompleted: () => {
         resolveCompleted();
@@ -11454,7 +11474,7 @@ function isExtensionRelayDisconnectError(detail) {
 function isExtensionRelaySingleClientError(detail) {
   return detail.toLowerCase().includes("only one cdp client supported");
 }
-var delay2 = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
+var delay2 = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
 function truncateText(value, maxChars) {
   if (value.length <= maxChars) {
     return { text: value, truncated: false };
@@ -12490,7 +12510,7 @@ var OpsBrowserManager = class {
         }
       } catch {
       }
-      await new Promise((resolve8) => setTimeout(resolve8, 250));
+      await new Promise((resolve9) => setTimeout(resolve9, 250));
     }
     return false;
   }
@@ -13017,9 +13037,9 @@ async function runDirectAnnotate(manager, assets, request) {
     await ensureAnnotationReady(page);
     let readySeen = false;
     const completionHandlers = getCompletionMap(page);
-    const responsePromise = new Promise((resolve8) => {
+    const responsePromise = new Promise((resolve9) => {
       completionHandlers.set(requestId, (message) => {
-        resolve8(mapCompletionToResponse(message, requestId));
+        resolve9(mapCompletionToResponse(message, requestId));
       });
     });
     const startResponse = await dispatchMessage(page, {
@@ -13037,10 +13057,10 @@ async function runDirectAnnotate(manager, assets, request) {
       completionHandlers.delete(requestId);
       throw new Error("Annotation start acknowledgement missing active bridge.");
     }
-    const timeoutPromise = new Promise((resolve8) => {
+    const timeoutPromise = new Promise((resolve9) => {
       const timeoutId = setTimeout(() => {
         clearTimeout(timeoutId);
-        resolve8({
+        resolve9({
           version: 1,
           requestId,
           status: "error",
@@ -13048,10 +13068,10 @@ async function runDirectAnnotate(manager, assets, request) {
         });
       }, timeoutMs);
     });
-    const abortPromise = new Promise((resolve8) => {
+    const abortPromise = new Promise((resolve9) => {
       if (!request.signal) return;
       if (request.signal.aborted) {
-        resolve8({
+        resolve9({
           version: 1,
           requestId,
           status: "cancelled",
@@ -13060,7 +13080,7 @@ async function runDirectAnnotate(manager, assets, request) {
         return;
       }
       const onAbort = () => {
-        resolve8({
+        resolve9({
           version: 1,
           requestId,
           status: "cancelled",
@@ -13483,7 +13503,7 @@ var AnnotationManager = class {
         socket.close(1e3, "Annotation complete");
       }
     };
-    const responsePromise = new Promise((resolve8, reject) => {
+    const responsePromise = new Promise((resolve9, reject) => {
       socket.on("message", (data) => {
         const message = parseJson2(data);
         if (!message || typeof message !== "object") return;
@@ -13492,7 +13512,7 @@ var AnnotationManager = class {
           const response = record;
           if (response.payload?.requestId === requestId) {
             terminalResponse = response.payload;
-            resolve8(response.payload);
+            resolve9(response.payload);
           }
         } else if (record.type === "annotationEvent") {
           const event = record;
@@ -13507,11 +13527,11 @@ var AnnotationManager = class {
       socket.on("error", (error) => reject(error));
       socket.on("close", () => {
         if (terminalResponse) {
-          resolve8(terminalResponse);
+          resolve9(terminalResponse);
           return;
         }
         if (commandName === "start" && readySeen) {
-          resolve8({
+          resolve9({
             version: 1,
             requestId,
             status: "cancelled",
@@ -13523,11 +13543,11 @@ var AnnotationManager = class {
       });
     });
     let timedOut = false;
-    const timeoutPromise = new Promise((resolve8) => {
+    const timeoutPromise = new Promise((resolve9) => {
       const id2 = setTimeout(() => {
         clearTimeout(id2);
         timedOut = true;
-        resolve8({
+        resolve9({
           version: 1,
           requestId,
           status: "error",
@@ -13536,11 +13556,11 @@ var AnnotationManager = class {
       }, timeoutMs);
     });
     let locallyAborted = false;
-    const abortPromise = new Promise((resolve8) => {
+    const abortPromise = new Promise((resolve9) => {
       if (!options.signal) return;
       if (options.signal.aborted) {
         locallyAborted = true;
-        resolve8({
+        resolve9({
           version: 1,
           requestId,
           status: "cancelled",
@@ -13550,7 +13570,7 @@ var AnnotationManager = class {
       }
       const onAbort = () => {
         locallyAborted = true;
-        resolve8({
+        resolve9({
           version: 1,
           requestId,
           status: "cancelled",
@@ -13581,13 +13601,13 @@ var AnnotationManager = class {
   }
 };
 var waitForSocketOpen = (socket, timeoutMs) => {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const timeout = setTimeout(() => {
       reject(new Error("Annotation socket open timed out"));
     }, timeoutMs);
     socket.once("open", () => {
       clearTimeout(timeout);
-      resolve8();
+      resolve9();
     });
     socket.once("error", (error) => {
       clearTimeout(timeout);
@@ -13676,7 +13696,7 @@ var CanvasClient = class {
       if (!this.socket || this.socket.readyState !== WebSocket3.OPEN) {
         this.clearReconnectTimer();
         this.socket = new WebSocket3(this.url);
-        await new Promise((resolve8, reject) => {
+        await new Promise((resolve9, reject) => {
           if (!this.socket) {
             reject(new Error("Canvas socket not created"));
             return;
@@ -13691,7 +13711,7 @@ var CanvasClient = class {
           }, this.handshakeTimeoutMs);
           const onOpen = () => {
             cleanup();
-            resolve8();
+            resolve9();
           };
           const onError = (error) => {
             cleanup();
@@ -13726,7 +13746,7 @@ var CanvasClient = class {
         version: CANVAS_PROTOCOL_VERSION,
         maxPayloadBytes: this.maxPayloadBytes
       };
-      const ack = await new Promise((resolve8, reject) => {
+      const ack = await new Promise((resolve9, reject) => {
         const cleanup = () => {
           clearTimeout(timeoutId);
           this.socket?.removeListener("canvas_hello_ack", onAck);
@@ -13743,7 +13763,7 @@ var CanvasClient = class {
         }, this.handshakeTimeoutMs);
         const onAck = (message) => {
           cleanup();
-          resolve8(message);
+          resolve9(message);
         };
         const onError = (message) => {
           cleanup();
@@ -13819,13 +13839,13 @@ var CanvasClient = class {
     if (Buffer.byteLength(serialized) > this.maxPayloadBytes) {
       throw new Error("Canvas request payload exceeded max size");
     }
-    return await new Promise((resolve8, reject) => {
+    return await new Promise((resolve9, reject) => {
       const timeoutId = setTimeout(() => {
         this.pendingRequests.delete(requestId);
         reject(new Error("Canvas request timed out"));
       }, timeoutMs);
       timeoutId.unref?.();
-      this.pendingRequests.set(requestId, { resolve: (value) => resolve8(value), reject, timeoutId });
+      this.pendingRequests.set(requestId, { resolve: (value) => resolve9(value), reject, timeoutId });
       try {
         this.sendRaw(serialized);
       } catch (error) {
@@ -13954,7 +13974,7 @@ var CanvasClient = class {
     }
     const id2 = randomUUID14();
     const ping = { type: "canvas_ping", id: id2 };
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       const timeoutId = setTimeout(() => {
         this.pendingPings.delete(id2);
         this.missedPongs += 1;
@@ -13964,7 +13984,7 @@ var CanvasClient = class {
         reject(new Error("Canvas ping timed out"));
       }, this.pingTimeoutMs);
       timeoutId.unref?.();
-      this.pendingPings.set(id2, { resolve: resolve8, reject, timeoutId });
+      this.pendingPings.set(id2, { resolve: resolve9, reject, timeoutId });
       try {
         this.send(ping);
       } catch (error) {
@@ -15301,17 +15321,17 @@ var Doc = class _Doc extends ObservableV2 {
     this.isLoaded = false;
     this.isSynced = false;
     this.isDestroyed = false;
-    this.whenLoaded = create4((resolve8) => {
+    this.whenLoaded = create4((resolve9) => {
       this.on("load", () => {
         this.isLoaded = true;
-        resolve8(this);
+        resolve9(this);
       });
     });
-    const provideSyncedPromise = () => create4((resolve8) => {
+    const provideSyncedPromise = () => create4((resolve9) => {
       const eventHandler = (isSynced) => {
         if (isSynced === void 0 || isSynced === true) {
           this.off("sync", eventHandler);
-          resolve8();
+          resolve9();
         }
       };
       this.on("sync", eventHandler);
@@ -21497,133 +21517,6 @@ if (glo[importIdentifier] === true) {
 }
 glo[importIdentifier] = true;
 
-// src/canvas/types.ts
-var CANVAS_SCHEMA_VERSION = "1.0.0";
-var CANVAS_SESSION_MODES = ["low-fi-wireframe", "high-fi-live-edit", "dual-track", "document-only"];
-var CANVAS_GOVERNANCE_BLOCK_KEYS = [
-  "intent",
-  "generationPlan",
-  "designLanguage",
-  "contentModel",
-  "layoutSystem",
-  "typographySystem",
-  "colorSystem",
-  "surfaceSystem",
-  "iconSystem",
-  "motionSystem",
-  "responsiveSystem",
-  "accessibilityPolicy",
-  "libraryPolicy",
-  "runtimeBudgets"
-];
-var CANVAS_REQUIRED_MUTATION_GOVERNANCE_KEYS = [
-  "intent",
-  "generationPlan",
-  "designLanguage",
-  "contentModel",
-  "layoutSystem",
-  "typographySystem",
-  "motionSystem",
-  "responsiveSystem",
-  "accessibilityPolicy"
-];
-var CANVAS_REQUIRED_SAVE_GOVERNANCE_KEYS = [
-  "intent",
-  "generationPlan",
-  "designLanguage",
-  "contentModel",
-  "layoutSystem",
-  "typographySystem",
-  "colorSystem",
-  "surfaceSystem",
-  "iconSystem",
-  "motionSystem",
-  "responsiveSystem",
-  "accessibilityPolicy",
-  "libraryPolicy",
-  "runtimeBudgets"
-];
-var CANVAS_OPTIONAL_INHERITED_GOVERNANCE_KEYS = [
-  "colorSystem",
-  "surfaceSystem",
-  "iconSystem",
-  "libraryPolicy",
-  "runtimeBudgets"
-];
-var CANVAS_GENERATION_PLAN_REQUIRED_FIELDS = [
-  "targetOutcome",
-  "visualDirection",
-  "layoutStrategy",
-  "contentStrategy",
-  "componentStrategy",
-  "motionPosture",
-  "responsivePosture",
-  "accessibilityPosture",
-  "validationTargets"
-];
-var CANVAS_VISUAL_DIRECTION_PROFILES = [
-  "clean-room",
-  "cinematic-minimal",
-  "product-story",
-  "commerce-system",
-  "control-room",
-  "ops-control",
-  "auth-focused",
-  "settings-system",
-  "documentation"
-];
-var CANVAS_THEME_STRATEGIES = ["single-theme", "light-dark-parity", "multi-theme-system"];
-var CANVAS_NAVIGATION_MODELS = ["global-header", "sidebar", "tabbed", "contextual", "immersive"];
-var CANVAS_INTERACTION_STATES = [
-  "default",
-  "hover",
-  "focus",
-  "active",
-  "disabled",
-  "loading",
-  "empty",
-  "error",
-  "success",
-  "selected"
-];
-var CANVAS_PLAN_VIEWPORTS = ["desktop", "tablet", "mobile"];
-var CANVAS_PLAN_THEMES = ["light", "dark"];
-var CANVAS_MOTION_LEVELS = ["none", "minimal", "subtle", "expressive"];
-var CANVAS_REDUCED_MOTION_POLICIES = ["respect-user-preference", "static-alternative"];
-var CANVAS_KEYBOARD_NAVIGATION_MODES = ["full", "core-flows"];
-var CANVAS_BROWSER_VALIDATION_MODES = ["required", "optional"];
-var CANVAS_VALIDATION_TARGET_BLOCK_ON_CODES = [
-  "missing-generation-plan",
-  "invalid-generation-plan",
-  "missing-governance-block",
-  "missing-intent",
-  "missing-design-language",
-  "missing-content-model",
-  "missing-typography-system",
-  "missing-color-role",
-  "missing-surface-policy",
-  "missing-state-coverage",
-  "missing-reduced-motion-policy",
-  "missing-responsive-policy",
-  "overflow",
-  "token-missing",
-  "broken-asset-reference",
-  "contrast-failure",
-  "hierarchy-weak",
-  "asset-provenance-missing",
-  "font-policy-missing",
-  "font-load-failure",
-  "reduced-motion-violation",
-  "unresolved-component-binding",
-  "icon-policy-violation",
-  "library-policy-violation",
-  "responsive-mismatch",
-  "runtime-budget-exceeded",
-  "unsupported-target",
-  "export-warning"
-];
-var CANVAS_PUBLIC_WARNING_CLASSES = CANVAS_VALIDATION_TARGET_BLOCK_ON_CODES;
-
 // src/canvas/token-references.ts
 var TOKEN_CSS_PREFIX = "--odb-token-";
 function isRecord5(value) {
@@ -32047,8 +31940,8 @@ var CanvasManager = class {
             }
             continue;
           }
-          const awaited = await new Promise((resolve8) => {
-            subscription.waiters.push(resolve8);
+          const awaited = await new Promise((resolve9) => {
+            subscription.waiters.push(resolve9);
           });
           if (awaited) {
             yield awaited;
@@ -32077,14 +31970,14 @@ var CanvasManager = class {
         reason: "subscription_replaced"
       };
     }
-    return await new Promise((resolve8) => {
+    return await new Promise((resolve9) => {
       let timeoutHandle = null;
       const resolveWaiter = (event) => {
         if (timeoutHandle) {
           clearTimeout(timeoutHandle);
         }
         if (!event) {
-          resolve8({
+          resolve9({
             eventType: "feedback.complete",
             cursor: subscription.cursor,
             ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -32092,7 +31985,7 @@ var CanvasManager = class {
           });
           return;
         }
-        resolve8(event);
+        resolve9(event);
       };
       subscription.waiters.push(resolveWaiter);
       if (timeoutMs === void 0) {
@@ -32104,7 +31997,7 @@ var CanvasManager = class {
           subscription.waiters.splice(waiterIndex, 1);
         }
         subscription.lastHeartbeatAt = Date.now();
-        resolve8({
+        resolve9({
           eventType: "feedback.heartbeat",
           cursor: subscription.cursor,
           ts: new Date(subscription.lastHeartbeatAt).toISOString(),
@@ -34723,10 +34616,10 @@ var RelayServer = class _RelayServer {
       }
       socket.destroy();
     });
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       this.server?.once("error", reject);
       this.server?.listen(port, "127.0.0.1", () => {
-        resolve8();
+        resolve9();
       });
     });
     const address = this.server.address();
@@ -34842,15 +34735,15 @@ var RelayServer = class _RelayServer {
         error: { code: "invalid_request", message: "Duplicate annotation requestId." }
       };
     }
-    return await new Promise((resolve8) => {
+    return await new Promise((resolve9) => {
       const pending = {
-        resolve: resolve8,
+        resolve: resolve9,
         timeout: null,
         readySeen: false
       };
       const timeout = setTimeout(() => {
         this.annotationDirectPending.delete(command.requestId);
-        resolve8({
+        resolve9({
           version: 1,
           requestId: command.requestId,
           status: "error",
@@ -35064,10 +34957,10 @@ var RelayServer = class _RelayServer {
       response.writeHead(404);
       response.end();
     });
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       this.discoveryServer?.once("error", reject);
       this.discoveryServer?.listen(this.configuredDiscoveryPort, "127.0.0.1", () => {
-        resolve8();
+        resolve9();
       });
     });
     const address = this.discoveryServer.address();
@@ -36098,12 +35991,130 @@ function createOpenDevBrowserCore(options) {
   };
 }
 
+// src/cli/utils/http.ts
+var DEFAULT_HTTP_TIMEOUT_MS = 5e3;
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  return "name" in error && error.name === "AbortError";
+}
+var resolveTimeoutMs = (timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) => {
+  return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_HTTP_TIMEOUT_MS;
+};
+var createTimeoutError = (timeoutMs) => {
+  return new Error(`Request timed out after ${timeoutMs}ms`);
+};
+var createTimedSignal = (timeoutMs, upstreamSignal) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  let removeAbortListener;
+  if (upstreamSignal) {
+    if (upstreamSignal.aborted) {
+      controller.abort(upstreamSignal.reason);
+    } else {
+      const onAbort = () => controller.abort(upstreamSignal.reason);
+      upstreamSignal.addEventListener("abort", onAbort, { once: true });
+      removeAbortListener = () => upstreamSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timeoutId);
+      removeAbortListener?.();
+    }
+  };
+};
+var cancelResponseBody = (response) => {
+  try {
+    const cancelResult = response.body?.cancel?.();
+    if (cancelResult instanceof Promise) {
+      void cancelResult.catch(() => {
+      });
+    }
+  } catch {
+  }
+};
+var readResponseBodyWithTimeout = async (response, signal, timeoutMs, reader) => {
+  let bodyCancelled = false;
+  const cancelBody = () => {
+    if (bodyCancelled) {
+      return;
+    }
+    bodyCancelled = true;
+    cancelResponseBody(response);
+  };
+  if (signal.aborted) {
+    cancelBody();
+    throw createTimeoutError(timeoutMs);
+  }
+  let removeAbortListener;
+  const abortPromise = new Promise((_, reject) => {
+    const onAbort = () => {
+      cancelBody();
+      reject(createTimeoutError(timeoutMs));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+  });
+  try {
+    return await Promise.race([reader(), abortPromise]);
+  } catch (error) {
+    if (signal.aborted || isAbortError(error)) {
+      cancelBody();
+      throw createTimeoutError(timeoutMs);
+    }
+    throw error;
+  } finally {
+    removeAbortListener?.();
+  }
+};
+async function fetchWithTimeout(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
+  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
+  try {
+    return await fetch(input, { ...init, signal: timedSignal.signal });
+  } catch (error) {
+    if (isAbortError(error) || timedSignal.signal.aborted) {
+      throw createTimeoutError(resolvedTimeout);
+    }
+    throw error;
+  } finally {
+    timedSignal.dispose();
+  }
+}
+async function fetchWithTimeoutContext(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
+  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
+  try {
+    const response = await fetch(input, { ...init, signal: timedSignal.signal });
+    return {
+      response,
+      signal: timedSignal.signal,
+      timeoutMs: resolvedTimeout,
+      dispose: timedSignal.dispose
+    };
+  } catch (error) {
+    timedSignal.dispose();
+    if (isAbortError(error) || timedSignal.signal.aborted) {
+      throw createTimeoutError(resolvedTimeout);
+    }
+    throw error;
+  }
+}
+async function readResponseTextWithTimeout(response, signal, timeoutMs) {
+  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.text());
+}
+async function readResponseJsonWithTimeout(response, signal, timeoutMs) {
+  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.json());
+}
+
 // src/cli/daemon.ts
 import { createServer as createServer2 } from "http";
 import { createHash as createHash6, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync, existsSync as existsSync6 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join16, resolve as resolve7 } from "path";
+import { basename as basename2, dirname as dirname8, join as join16, resolve as resolve7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cli/daemon-commands.ts
 import { randomUUID as randomUUID22 } from "crypto";
@@ -36346,25 +36357,82 @@ function getBoolean(value) {
 var INSPIREDESIGN_CAPTURE_TIMEOUT_MS = 3e4;
 var INSPIREDESIGN_CAPTURE_MAX_CHARS = 12e3;
 var ACTIVE_SESSION_COOKIE_REUSE_UNAVAILABLE_MESSAGE = "Deep capture only honors configured provider cookie sources; active session cookies are not reused.";
+var DOM_CAPTURE_HELPER_UNAVAILABLE_MESSAGE = "DOM capture helper unavailable in this execution lane.";
+var SNAPSHOT_CAPTURE_EMPTY_MESSAGE = "Snapshot capture returned empty content.";
+var CLONE_CAPTURE_EMPTY_MESSAGE = "Clone capture returned empty component and CSS previews.";
+var DOM_CAPTURE_EMPTY_MESSAGE = "DOM capture returned empty HTML.";
+var SKIPPED_AFTER_TRANSPORT_TIMEOUT_SUFFIX = "transport timeout.";
 var createRemainingCaptureTimeout = (timeoutMs) => {
   const startedAtMs = Date.now();
-  return () => Math.max(1, timeoutMs - Math.max(0, Date.now() - startedAtMs));
+  let firstRead = true;
+  return () => {
+    if (firstRead) {
+      firstRead = false;
+      return timeoutMs;
+    }
+    return Math.max(1, timeoutMs - Math.max(0, Date.now() - startedAtMs));
+  };
 };
 var clampInspiredesignCaptureTimeout = (timeoutMs) => {
   if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) return INSPIREDESIGN_CAPTURE_TIMEOUT_MS;
   return Math.max(1, Math.min(timeoutMs, INSPIREDESIGN_CAPTURE_TIMEOUT_MS));
 };
-var sanitizeInspiredesignCaptureText = (value) => {
-  if (!value) return void 0;
+function sanitizeInspiredesignCaptureText(value) {
+  if (value === void 0) return void 0;
   const redacted = redactSensitive(value);
   return typeof redacted === "string" ? redacted : value;
+}
+var buildCaptureAttempt = (status, detail) => {
+  const sanitizedDetail = sanitizeInspiredesignCaptureText(detail);
+  return sanitizedDetail ? { status, detail: sanitizedDetail } : { status };
+};
+var detailFromCaptureError = (error, fallback) => {
+  return error instanceof Error ? error.message : fallback;
+};
+var isTransportTimeoutError = (error, detail) => {
+  if (error instanceof Error) {
+    const code = error.code;
+    if (error.name === "TimeoutError" || code === "ETIMEDOUT" || code === "ERR_HTTP_REQUEST_TIMEOUT") {
+      return true;
+    }
+  }
+  return /\btimed out after \d+ms\b/i.test(detail) || /exceeded timeout budget\./i.test(detail);
+};
+var isIgnorableNetworkIdleWaitError = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return /timed out|timeout/i.test(error.message);
+};
+var buildSkippedAfterTransportTimeoutAttempt = (label) => {
+  return buildCaptureAttempt("skipped", `Skipped after ${label} ${SKIPPED_AFTER_TRANSPORT_TIMEOUT_SUFFIX}`);
+};
+var hasUsableCaptureText = (value) => {
+  return typeof value === "string" && value.trim().length > 0;
 };
 var resolveInspiredesignCaptureCookiePolicy = (options) => {
   if (options.cookiePolicyOverride) return options.cookiePolicyOverride;
   return options.useCookies === false ? "off" : "auto";
 };
-var verifyRequiredCaptureCookies = async (manager, sessionId, url, importState) => {
-  const cookies = await manager.cookieList(sessionId, [url]);
+var withCaptureDeadline = async (promise, timeoutMs, label) => {
+  let clearDeadline = () => {
+  };
+  const timeoutPromise = new Promise((_, reject) => {
+    const handle = setTimeout(() => reject(new Error(`Deep capture ${label} exceeded timeout budget.`)), timeoutMs);
+    clearDeadline = () => clearTimeout(handle);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearDeadline();
+  }
+};
+var verifyRequiredCaptureCookies = async (manager, sessionId, url, importState, timeoutMs) => {
+  const cookies = await withCaptureDeadline(
+    manager.cookieList(sessionId, [url], void 0, timeoutMs),
+    timeoutMs,
+    "cookie verification"
+  );
   if (cookies.count > 0) return;
   if (!importState.sourceConfigured) {
     throw new Error(ACTIVE_SESSION_COOKIE_REUSE_UNAVAILABLE_MESSAGE);
@@ -36372,7 +36440,7 @@ var verifyRequiredCaptureCookies = async (manager, sessionId, url, importState)
   const sourceDetail = importState.sourceMessage ? ` ${importState.sourceMessage}` : "";
   throw new Error(`Deep capture requires observable cookies from the configured provider cookie source for the requested URL.${sourceDetail}`);
 };
-var importConfiguredCaptureCookies = async (manager, sessionId, source) => {
+var importConfiguredCaptureCookies = async (manager, sessionId, source, timeoutMs) => {
   if (!source || typeof manager.cookieImport !== "function") {
     return {
       sourceConfigured: Boolean(source),
@@ -36387,80 +36455,203 @@ var importConfiguredCaptureCookies = async (manager, sessionId, source) => {
       sourceMessage: loaded.message
     };
   }
-  await manager.cookieImport(sessionId, loaded.cookies, false);
+  await withCaptureDeadline(
+    manager.cookieImport(sessionId, loaded.cookies, false, void 0, timeoutMs),
+    timeoutMs,
+    "cookie import"
+  );
   return {
     sourceConfigured: true,
     sourceAvailable: loaded.available,
     sourceMessage: loaded.message
   };
 };
-var withCaptureDeadline = async (promise, timeoutMs, label) => {
-  let handle;
+var captureSnapshotArtifact = async (manager, sessionId, remainingTimeoutMs) => {
   try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        handle = setTimeout(() => reject(new Error(`Deep capture ${label} exceeded timeout budget.`)), timeoutMs);
-      })
-    ]);
-  } finally {
-    if (handle) clearTimeout(handle);
+    const snapshot = await withCaptureDeadline(
+      manager.snapshot(
+        sessionId,
+        "actionables",
+        INSPIREDESIGN_CAPTURE_MAX_CHARS,
+        void 0,
+        void 0,
+        remainingTimeoutMs()
+      ),
+      remainingTimeoutMs(),
+      "snapshot capture"
+    );
+    const content = sanitizeInspiredesignCaptureText(snapshot.content) ?? "";
+    if (!hasUsableCaptureText(content)) {
+      return {
+        attempt: buildCaptureAttempt("failed", SNAPSHOT_CAPTURE_EMPTY_MESSAGE)
+      };
+    }
+    return {
+      attempt: buildCaptureAttempt("captured"),
+      snapshot: {
+        content,
+        refCount: snapshot.refCount,
+        warnings: snapshot.warnings ?? []
+      }
+    };
+  } catch (error) {
+    const detail = detailFromCaptureError(error, "Snapshot capture failed.");
+    return {
+      attempt: buildCaptureAttempt("failed", detail),
+      ...isTransportTimeoutError(error, detail) ? { transportTimedOut: true } : {}
+    };
   }
 };
-var captureInspiredesignArtifacts = async (manager, sessionId, remainingTimeoutMs) => {
-  const snapshotTimeoutMs = remainingTimeoutMs();
-  const snapshot = await withCaptureDeadline(
-    manager.snapshot(sessionId, "actionables", INSPIREDESIGN_CAPTURE_MAX_CHARS),
-    snapshotTimeoutMs,
-    "snapshot capture"
-  );
-  const cloneTimeoutMs = remainingTimeoutMs();
-  const clone2 = await withCaptureDeadline(
-    manager.clonePage(sessionId),
-    cloneTimeoutMs,
-    "clone capture"
-  );
-  const dom = typeof manager.clonePageHtmlWithOptions === "function" ? await withCaptureDeadline(
-    manager.clonePageHtmlWithOptions(sessionId),
-    remainingTimeoutMs(),
-    "DOM capture"
-  ).catch(() => null) : null;
-  return {
-    snapshot: {
-      content: sanitizeInspiredesignCaptureText(snapshot.content) ?? snapshot.content,
-      refCount: snapshot.refCount,
-      warnings: snapshot.warnings ?? []
-    },
-    ...dom?.html ? {
+var captureCloneArtifact = async (manager, sessionId, remainingTimeoutMs) => {
+  try {
+    const clone2 = await withCaptureDeadline(
+      manager.clonePage(sessionId, void 0, remainingTimeoutMs()),
+      remainingTimeoutMs(),
+      "clone capture"
+    );
+    const componentPreview = sanitizeInspiredesignCaptureText(clone2.component) ?? "";
+    const cssPreview = sanitizeInspiredesignCaptureText(clone2.css) ?? "";
+    if (!hasUsableCaptureText(componentPreview) && !hasUsableCaptureText(cssPreview)) {
+      return {
+        attempt: buildCaptureAttempt("failed", CLONE_CAPTURE_EMPTY_MESSAGE)
+      };
+    }
+    return {
+      attempt: buildCaptureAttempt("captured"),
+      clone: {
+        componentPreview,
+        cssPreview,
+        warnings: clone2.warnings ?? []
+      }
+    };
+  } catch (error) {
+    const detail = detailFromCaptureError(error, "Clone capture failed.");
+    return {
+      attempt: buildCaptureAttempt("failed", detail),
+      ...isTransportTimeoutError(error, detail) ? { transportTimedOut: true } : {}
+    };
+  }
+};
+var captureDomArtifact = async (manager, sessionId, remainingTimeoutMs) => {
+  if (typeof manager.clonePageHtmlWithOptions !== "function") {
+    return {
+      attempt: buildCaptureAttempt("skipped", DOM_CAPTURE_HELPER_UNAVAILABLE_MESSAGE)
+    };
+  }
+  try {
+    const dom = await withCaptureDeadline(
+      manager.clonePageHtmlWithOptions(sessionId, void 0, void 0, remainingTimeoutMs()),
+      remainingTimeoutMs(),
+      "DOM capture"
+    );
+    const outerHTML = sanitizeInspiredesignCaptureText(dom.html) ?? "";
+    if (!hasUsableCaptureText(outerHTML)) {
+      return {
+        attempt: buildCaptureAttempt("failed", DOM_CAPTURE_EMPTY_MESSAGE)
+      };
+    }
+    return {
+      attempt: buildCaptureAttempt("captured"),
       dom: {
-        outerHTML: sanitizeInspiredesignCaptureText(dom.html) ?? dom.html,
+        outerHTML,
         truncated: false
       }
-    } : {},
-    clone: {
-      componentPreview: sanitizeInspiredesignCaptureText(clone2.component) ?? clone2.component,
-      cssPreview: sanitizeInspiredesignCaptureText(clone2.css) ?? clone2.css,
-      warnings: clone2.warnings ?? []
-    }
+    };
+  } catch (error) {
+    const detail = detailFromCaptureError(error, "DOM capture failed.");
+    return {
+      attempt: buildCaptureAttempt("failed", detail),
+      ...isTransportTimeoutError(error, detail) ? { transportTimedOut: true } : {}
+    };
+  }
+};
+var buildCaptureEvidence = (snapshot, clone2, dom) => {
+  const attempts = {
+    snapshot: snapshot.attempt,
+    clone: clone2.attempt,
+    dom: dom.attempt
+  };
+  return {
+    ...snapshot.snapshot ? { snapshot: snapshot.snapshot } : {},
+    ...dom.dom ? { dom: dom.dom } : {},
+    ...clone2.clone ? { clone: clone2.clone } : {},
+    attempts
   };
 };
+var buildTransportTimeoutCaptureEvidence = (snapshot, clone2, label) => {
+  const attempts = {
+    snapshot: snapshot.attempt,
+    clone: clone2?.attempt ?? buildSkippedAfterTransportTimeoutAttempt(label),
+    dom: buildSkippedAfterTransportTimeoutAttempt(label)
+  };
+  return {
+    ...snapshot.snapshot ? { snapshot: snapshot.snapshot } : {},
+    ...clone2?.clone ? { clone: clone2.clone } : {},
+    attempts
+  };
+};
+var captureInspiredesignArtifacts = async (manager, sessionId, remainingTimeoutMs) => {
+  const snapshot = await captureSnapshotArtifact(manager, sessionId, remainingTimeoutMs);
+  if (snapshot.transportTimedOut) {
+    return buildTransportTimeoutCaptureEvidence(snapshot, void 0, "snapshot capture");
+  }
+  const clone2 = await captureCloneArtifact(manager, sessionId, remainingTimeoutMs);
+  if (clone2.transportTimedOut) {
+    return buildTransportTimeoutCaptureEvidence(snapshot, clone2, "clone capture");
+  }
+  const dom = await captureDomArtifact(manager, sessionId, remainingTimeoutMs);
+  return buildCaptureEvidence(snapshot, clone2, dom);
+};
 async function captureInspiredesignReferenceFromManager(manager, url, options = {}) {
   const cookiePolicy = resolveInspiredesignCaptureCookiePolicy(options);
   const captureTimeoutMs = clampInspiredesignCaptureTimeout(options.timeoutMs);
   const remainingTimeoutMs = createRemainingCaptureTimeout(captureTimeoutMs);
-  const session = await manager.launch({
-    headless: true,
-    startUrl: "about:blank",
-    persistProfile: false
-  });
+  const launchTimeoutMs = remainingTimeoutMs();
+  const session = await withCaptureDeadline(
+    manager.launch({
+      headless: true,
+      startUrl: "about:blank",
+      persistProfile: false,
+      noExtension: true
+    }, launchTimeoutMs),
+    launchTimeoutMs,
+    "session launch"
+  );
   try {
-    const importState = cookiePolicy === "off" ? { sourceConfigured: false, sourceAvailable: false } : await importConfiguredCaptureCookies(manager, session.sessionId, options.cookieSource);
+    const importState = cookiePolicy === "off" ? { sourceConfigured: false, sourceAvailable: false } : await importConfiguredCaptureCookies(
+      manager,
+      session.sessionId,
+      options.cookieSource,
+      remainingTimeoutMs()
+    );
     if (cookiePolicy === "required") {
-      await verifyRequiredCaptureCookies(manager, session.sessionId, url, importState);
+      await verifyRequiredCaptureCookies(
+        manager,
+        session.sessionId,
+        url,
+        importState,
+        remainingTimeoutMs()
+      );
     }
     manager.setSessionChallengeAutomationMode?.(session.sessionId, options.challengeAutomationMode);
-    await manager.goto(session.sessionId, url, "load", remainingTimeoutMs());
-    await manager.waitForLoad(session.sessionId, "networkidle", remainingTimeoutMs()).catch(() => void 0);
+    const gotoTimeoutMs = remainingTimeoutMs();
+    await withCaptureDeadline(
+      manager.goto(session.sessionId, url, "load", gotoTimeoutMs),
+      gotoTimeoutMs,
+      "navigation"
+    );
+    const waitTimeoutMs = remainingTimeoutMs();
+    try {
+      await withCaptureDeadline(
+        manager.waitForLoad(session.sessionId, "networkidle", waitTimeoutMs),
+        waitTimeoutMs,
+        "network idle wait"
+      );
+    } catch (error) {
+      if (!isIgnorableNetworkIdleWaitError(error)) {
+        throw error;
+      }
+    }
     return await captureInspiredesignArtifacts(manager, session.sessionId, remainingTimeoutMs);
   } finally {
     await manager.disconnect(session.sessionId, true).catch(() => void 0);
@@ -37029,7 +37220,7 @@ var waitForBinding = async (clientId, timeoutMs) => {
     if (!getQueueEntry(clientId)) {
       break;
     }
-    await new Promise((resolve8) => setTimeout(resolve8, 250));
+    await new Promise((resolve9) => setTimeout(resolve9, 250));
   }
   dequeueClient(clientId);
   throw new Error("RELAY_WAIT_TIMEOUT: Timed out waiting for relay binding.");
@@ -37105,119 +37296,6 @@ var getBindingRenewConfig = () => ({
   waitMaxMs: WAIT_MAX_MS
 });
 
-// src/cli/utils/http.ts
-var DEFAULT_HTTP_TIMEOUT_MS = 5e3;
-function isAbortError(error) {
-  if (!error || typeof error !== "object") return false;
-  return "name" in error && error.name === "AbortError";
-}
-var resolveTimeoutMs = (timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) => {
-  return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_HTTP_TIMEOUT_MS;
-};
-var createTimeoutError = (timeoutMs) => {
-  return new Error(`Request timed out after ${timeoutMs}ms`);
-};
-var createTimedSignal = (timeoutMs, upstreamSignal) => {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  let removeAbortListener;
-  if (upstreamSignal) {
-    if (upstreamSignal.aborted) {
-      controller.abort(upstreamSignal.reason);
-    } else {
-      const onAbort = () => controller.abort(upstreamSignal.reason);
-      upstreamSignal.addEventListener("abort", onAbort, { once: true });
-      removeAbortListener = () => upstreamSignal.removeEventListener("abort", onAbort);
-    }
-  }
-  return {
-    signal: controller.signal,
-    dispose: () => {
-      clearTimeout(timeoutId);
-      removeAbortListener?.();
-    }
-  };
-};
-var cancelResponseBody = (response) => {
-  try {
-    void response.body?.cancel?.();
-  } catch {
-  }
-};
-var readResponseBodyWithTimeout = async (response, signal, timeoutMs, reader) => {
-  let bodyCancelled = false;
-  const cancelBody = () => {
-    if (bodyCancelled) {
-      return;
-    }
-    bodyCancelled = true;
-    cancelResponseBody(response);
-  };
-  if (signal.aborted) {
-    cancelBody();
-    throw createTimeoutError(timeoutMs);
-  }
-  let removeAbortListener;
-  const abortPromise = new Promise((_, reject) => {
-    const onAbort = () => {
-      cancelBody();
-      reject(createTimeoutError(timeoutMs));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-  });
-  try {
-    return await Promise.race([reader(), abortPromise]);
-  } catch (error) {
-    if (signal.aborted || isAbortError(error)) {
-      cancelBody();
-      throw createTimeoutError(timeoutMs);
-    }
-    throw error;
-  } finally {
-    removeAbortListener?.();
-  }
-};
-async function fetchWithTimeout(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
-  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
-  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
-  try {
-    return await fetch(input, { ...init, signal: timedSignal.signal });
-  } catch (error) {
-    if (isAbortError(error) || timedSignal.signal.aborted) {
-      throw createTimeoutError(resolvedTimeout);
-    }
-    throw error;
-  } finally {
-    timedSignal.dispose();
-  }
-}
-async function fetchWithTimeoutContext(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
-  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
-  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
-  try {
-    const response = await fetch(input, { ...init, signal: timedSignal.signal });
-    return {
-      response,
-      signal: timedSignal.signal,
-      timeoutMs: resolvedTimeout,
-      dispose: timedSignal.dispose
-    };
-  } catch (error) {
-    timedSignal.dispose();
-    if (isAbortError(error) || timedSignal.signal.aborted) {
-      throw createTimeoutError(resolvedTimeout);
-    }
-    throw error;
-  }
-}
-async function readResponseTextWithTimeout(response, signal, timeoutMs) {
-  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.text());
-}
-async function readResponseJsonWithTimeout(response, signal, timeoutMs) {
-  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.json());
-}
-
 // src/cli/daemon-commands.ts
 var createDaemonWorkflowRuntime = (core, options) => resolveBundledProviderRuntime({
   existingRuntime: core.providerRuntime,
@@ -37695,6 +37773,22 @@ async function handleDaemonCommand(core, request) {
             requireString3(params2.sessionId, "sessionId"),
             optionalString6(params2.targetId)
           );
+        case "export.clonePageHtml":
+          await authorizeSessionCommand(core, params2, request.name, bindingId);
+          if (typeof core.manager.clonePageHtmlWithOptions !== "function") {
+            throw new Error("clonePageHtmlWithOptions unavailable in this execution lane.");
+          }
+          {
+            const maxNodes = optionalPositiveInteger2(params2.maxNodes, "maxNodes");
+            return core.manager.clonePageHtmlWithOptions(
+              requireString3(params2.sessionId, "sessionId"),
+              optionalString6(params2.targetId),
+              {
+                ...typeof maxNodes === "number" ? { maxNodes } : {},
+                ...typeof params2.inlineStyles === "boolean" ? { inlineStyles: params2.inlineStyles } : {}
+              }
+            );
+          }
         case "export.cloneComponent":
           await authorizeSessionCommand(core, params2, request.name, bindingId);
           return core.manager.cloneComponent(
@@ -37984,8 +38078,8 @@ async function handleDaemonCommand(core, request) {
                   await core.manager.goto(session.sessionId, url, "load", captureTimeoutMs);
                   const screenshot = await Promise.race([
                     core.manager.screenshot(session.sessionId),
-                    new Promise((resolve8) => {
-                      setTimeout(() => resolve8(null), captureTimeoutMs);
+                    new Promise((resolve9) => {
+                      setTimeout(() => resolve9(null), captureTimeoutMs);
                     })
                   ]);
                   if (!screenshot || typeof screenshot.base64 !== "string" || screenshot.base64.length === 0) return null;
@@ -38623,6 +38717,15 @@ function requireFiniteNumber(value, label) {
   }
   throw new Error(`Invalid ${label}`);
 }
+function optionalPositiveInteger2(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  throw new Error(`Invalid ${label}`);
+}
 function requirePointerPoint(value, label) {
   const point = requireRecord2(value, label);
   return {
@@ -38769,7 +38872,7 @@ async function waitForRelayHandshake(relay, observedPort, timeoutMs) {
     if (observedStatus?.extensionHandshakeComplete) {
       return true;
     }
-    await new Promise((resolve8) => setTimeout(resolve8, delay3));
+    await new Promise((resolve9) => setTimeout(resolve9, delay3));
     delay3 = Math.min(delay3 * 2, WAIT_MAX_DELAY_MS);
   }
   return false;
@@ -38928,6 +39031,11 @@ async function resolveMacroExpression(options, config, manager, browserFallbackP
 
 // src/cli/daemon.ts
 var DEFAULT_DAEMON_PORT2 = 8788;
+var DAEMON_STOP_DEBUG_ENV = "OPDEVBROWSER_DEBUG_DAEMON_STOP";
+var DAEMON_FINGERPRINT_FILE = "daemon-fingerprint.json";
+var DAEMON_STOP_REASON_HEADER = "x-opendevbrowser-stop-reason";
+var DAEMON_STOP_CLIENT_PID_HEADER = "x-opendevbrowser-stop-client-pid";
+var DAEMON_STOP_FINGERPRINT_HEADER = "x-opendevbrowser-stop-fingerprint";
 var RECOVERABLE_PLAYWRIGHT_TRANSPORT_ERRORS = [
   "Cannot find context with specified id",
   "Detached while handling command."
@@ -38964,28 +39072,78 @@ function clearDaemonMetadata() {
   } catch {
   }
 }
-function resolveCurrentDaemonEntrypointPath() {
-  const rawEntry = process.argv[1];
+function resolveCurrentDaemonEntrypointPath(options = {}) {
+  const rawEntry = options.argv1 ?? process.argv[1];
   if (typeof rawEntry === "string" && rawEntry.trim().length > 0) {
     return resolve7(rawEntry);
   }
-  return resolve7(__filename);
+  const moduleUrl = options.moduleUrl ?? import.meta.url;
+  const cliEntrypoint = resolve7(fileURLToPath2(new URL("./index.js", moduleUrl)));
+  const entryExists = options.entryExists ?? existsSync6;
+  if (entryExists(cliEntrypoint)) {
+    return cliEntrypoint;
+  }
+  return resolve7(fileURLToPath2(moduleUrl));
 }
-function hashEntrypointContents(entryPath) {
+function hashFileContents(entryPath) {
   try {
     return createHash6("sha256").update(readFileSync5(entryPath)).digest("hex");
   } catch {
     return "missing";
   }
 }
-function getCurrentDaemonFingerprint() {
-  const entryPath = resolveCurrentDaemonEntrypointPath();
-  const entryHash = hashEntrypointContents(entryPath);
-  return createHash6("sha256").update([DAEMON_FINGERPRINT_VERSION, process.execPath, entryPath, entryHash].join("\n")).digest("hex");
+function resolveDaemonFingerprintDistRoot(modulePath) {
+  let currentDir = dirname8(modulePath);
+  while (true) {
+    if (basename2(currentDir) === "dist") {
+      return currentDir;
+    }
+    const parentDir = dirname8(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+function readDaemonFingerprintArtifact(modulePath) {
+  const distRoot = resolveDaemonFingerprintDistRoot(modulePath);
+  if (distRoot === null) {
+    return null;
+  }
+  try {
+    const content = readFileSync5(join16(distRoot, DAEMON_FINGERPRINT_FILE), "utf-8");
+    const payload = JSON.parse(content);
+    if (typeof payload.fingerprint === "string" && payload.fingerprint.trim().length > 0) {
+      return payload.fingerprint.trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function getCurrentDaemonFingerprint(options = {}) {
+  const modulePath = resolve7(fileURLToPath2(options.moduleUrl ?? import.meta.url));
+  const sharedFingerprint = readDaemonFingerprintArtifact(modulePath);
+  const fingerprintParts = [
+    DAEMON_FINGERPRINT_VERSION,
+    sharedFingerprint ?? hashFileContents(modulePath)
+  ];
+  return createHash6("sha256").update(fingerprintParts.join("\n")).digest("hex");
 }
 function isCurrentDaemonFingerprint(fingerprint) {
   return typeof fingerprint === "string" && fingerprint === getCurrentDaemonFingerprint();
 }
+function createDaemonStopHeaders(token, reason) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    [DAEMON_STOP_FINGERPRINT_HEADER]: getCurrentDaemonFingerprint(),
+    [DAEMON_STOP_REASON_HEADER]: reason
+  };
+  if (process.env[DAEMON_STOP_DEBUG_ENV] === "1") {
+    headers[DAEMON_STOP_CLIENT_PID_HEADER] = String(process.pid);
+  }
+  return headers;
+}
 function resolveDaemonFingerprint(...candidates) {
   for (const candidate of candidates) {
     if (typeof candidate === "string" && candidate.trim().length > 0) {
@@ -39027,6 +39185,20 @@ function sendJson(response, status, payload) {
   });
   response.end(JSON.stringify(payload));
 }
+function logDaemonStopDebug(message, details) {
+  if (process.env[DAEMON_STOP_DEBUG_ENV] !== "1") {
+    return;
+  }
+  const suffix = details ? ` ${JSON.stringify(details)}` : "";
+  console.error(`[daemon-stop-debug] ${message}${suffix}`);
+}
+function readSingleHeader(request, name) {
+  const value = request.headers[name];
+  if (typeof value === "string") {
+    return value;
+  }
+  return null;
+}
 var isDaemonCommandRequest = (value) => {
   if (typeof value.name !== "string") {
     return false;
@@ -39078,8 +39250,20 @@ async function startDaemon(options = {}) {
       return;
     }
     if (request.method === "POST" && url.pathname === "/stop") {
+      const stopFingerprint = readSingleHeader(request, DAEMON_STOP_FINGERPRINT_HEADER);
+      logDaemonStopDebug("http.stop", {
+        remoteAddress: request.socket.remoteAddress ?? null,
+        remotePort: request.socket.remotePort ?? null,
+        reason: readSingleHeader(request, DAEMON_STOP_REASON_HEADER),
+        clientPid: readSingleHeader(request, DAEMON_STOP_CLIENT_PID_HEADER),
+        fingerprintMatches: stopFingerprint === fingerprint
+      });
+      if (stopFingerprint !== fingerprint) {
+        sendJson(response, 409, { ok: false, error: "Stale daemon stop request." });
+        return;
+      }
       sendJson(response, 200, { ok: true });
-      await stop();
+      await stop("http.stop");
       return;
     }
     if (request.method === "POST" && url.pathname === "/command") {
@@ -39098,9 +39282,9 @@ async function startDaemon(options = {}) {
     }
     sendJson(response, 404, { error: "Not found" });
   });
-  await new Promise((resolve8, reject) => {
+  await new Promise((resolve9, reject) => {
     server.once("error", reject);
-    server.listen(port, "127.0.0.1", () => resolve8());
+    server.listen(port, "127.0.0.1", () => resolve9());
   });
   const state = {
     port,
@@ -39133,7 +39317,7 @@ async function startDaemon(options = {}) {
       return;
     }
     console.error(error);
-    void stop().finally(() => {
+    void stop("uncaughtException").finally(() => {
       process.exitCode = 1;
     });
   };
@@ -39142,15 +39326,16 @@ async function startDaemon(options = {}) {
       return;
     }
     console.error(reason);
-    void stop().finally(() => {
+    void stop("unhandledRejection").finally(() => {
       process.exitCode = 1;
     });
   };
-  const stop = async () => {
+  const stop = async (reason = "unknown") => {
     if (stopping) {
       return;
     }
     stopping = true;
+    logDaemonStopDebug("stop.begin", { reason });
     clearDaemonMetadata();
     clearBinding();
     process.off("SIGINT", sigintHandler);
@@ -39158,16 +39343,17 @@ async function startDaemon(options = {}) {
     process.off("uncaughtException", uncaughtExceptionHandler);
     process.off("unhandledRejection", unhandledRejectionHandler);
     core.cleanup();
-    await new Promise((resolve8) => {
-      server.close(() => resolve8());
+    await new Promise((resolve9) => {
+      server.close(() => resolve9());
     });
+    logDaemonStopDebug("stop.complete", { reason });
   };
   const sigintHandler = () => {
-    stop().catch(() => {
+    void stop("SIGINT").catch(() => {
     });
   };
   const sigtermHandler = () => {
-    stop().catch(() => {
+    void stop("SIGTERM").catch(() => {
     });
   };
   process.on("SIGINT", sigintHandler);
@@ -39177,7 +39363,7 @@ async function startDaemon(options = {}) {
   return { state, stop };
 }
 function readJson2(request) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let data = "";
     request.setEncoding("utf8");
     request.on("data", (chunk) => {
@@ -39190,7 +39376,7 @@ function readJson2(request) {
           reject(new Error("Invalid JSON body"));
           return;
         }
-        resolve8(parsed);
+        resolve9(parsed);
       } catch (error) {
         reject(error);
       }
@@ -39241,12 +39427,20 @@ function resolveExitCode(result) {
   return result.success ? EXIT_SUCCESS : EXIT_EXECUTION;
 }
 
+// src/cli/daemon-status-policy.ts
+var DEFAULT_DAEMON_STATUS_FETCH_OPTIONS = {
+  timeoutMs: 5e3,
+  retryAttempts: 5,
+  retryDelayMs: 250
+};
+
 // src/cli/daemon-status.ts
+var DEFAULT_DAEMON_STATUS_TIMEOUT_MS = DEFAULT_DAEMON_STATUS_FETCH_OPTIONS.timeoutMs;
 var sleep2 = async (delayMs) => {
   if (!(Number.isFinite(delayMs) && delayMs > 0)) {
     return;
   }
-  await new Promise((resolve8) => setTimeout(resolve8, delayMs));
+  await new Promise((resolve9) => setTimeout(resolve9, delayMs));
 };
 var resolveRetryAttempts = (retryAttempts) => {
   return typeof retryAttempts === "number" && Number.isFinite(retryAttempts) && retryAttempts > 1 ? Math.floor(retryAttempts) : 1;
@@ -39254,17 +39448,66 @@ var resolveRetryAttempts = (retryAttempts) => {
 var resolveRetryDelayMs = (retryDelayMs) => {
   return typeof retryDelayMs === "number" && Number.isFinite(retryDelayMs) && retryDelayMs > 0 ? retryDelayMs : 0;
 };
+var resolveStatusTimeoutMs = (timeoutMs) => {
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_DAEMON_STATUS_TIMEOUT_MS;
+};
+var withFingerprintCurrent = (status) => ({
+  ...status,
+  fingerprintCurrent: isCurrentDaemonFingerprint(status.fingerprint)
+});
+var readRemainingBudgetMs = (deadlineMs) => {
+  return Math.max(0, deadlineMs - Date.now());
+};
+var readSeedTimeoutMs = (remainingBudgetMs, remainingSeedCount) => {
+  if (remainingSeedCount <= 1) {
+    return remainingBudgetMs;
+  }
+  return Math.max(1, Math.floor(remainingBudgetMs / remainingSeedCount));
+};
+var resolveDaemonStatusSeeds = (metadata, config) => {
+  const seeds = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addSeed = (seed) => {
+    if (!seed) {
+      return;
+    }
+    const key = `${seed.port}:${seed.token}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    seeds.push(seed);
+  };
+  addSeed(
+    config.daemonPort > 0 && config.daemonToken ? {
+      port: config.daemonPort,
+      token: config.daemonToken,
+      relayPort: config.relayPort
+    } : null
+  );
+  addSeed(metadata);
+  return seeds;
+};
 async function fetchDaemonStatus(port, token, options = {}) {
   const attempts = resolveRetryAttempts(options.retryAttempts);
   const retryDelayMs = resolveRetryDelayMs(options.retryDelayMs);
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
-      const response = await fetchWithTimeout(`http://127.0.0.1:${port}/status`, {
+      const timedResponse = await fetchWithTimeoutContext(`http://127.0.0.1:${port}/status`, {
         method: "GET",
         headers: { Authorization: `Bearer ${token}` }
       }, options.timeoutMs);
-      if (response.ok) {
-        return await response.json();
+      try {
+        if (timedResponse.response.ok) {
+          const status = await readResponseJsonWithTimeout(
+            timedResponse.response,
+            timedResponse.signal,
+            timedResponse.timeoutMs
+          );
+          return withFingerprintCurrent(status);
+        }
+      } finally {
+        timedResponse.dispose();
       }
     } catch {
     }
@@ -39278,32 +39521,34 @@ async function fetchDaemonStatusFromMetadata(config, options = {}) {
   const resolvedConfig = config ?? loadGlobalConfig();
   const attempts = resolveRetryAttempts(options.retryAttempts);
   const retryDelayMs = resolveRetryDelayMs(options.retryDelayMs);
+  const deadlineMs = Date.now() + resolveStatusTimeoutMs(options.timeoutMs);
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     const metadata = readDaemonMetadata();
-    if (metadata) {
-      const status = await fetchDaemonStatus(metadata.port, metadata.token, { timeoutMs: options.timeoutMs });
-      if (status?.ok) {
-        persistDaemonStatusMetadata(metadata, status, resolvedConfig);
-        return status;
+    const seeds = resolveDaemonStatusSeeds(metadata, resolvedConfig);
+    for (let seedIndex = 0; seedIndex < seeds.length; seedIndex += 1) {
+      const seed = seeds[seedIndex];
+      if (!seed) {
+        continue;
       }
-    }
-    if (resolvedConfig.daemonPort > 0 && resolvedConfig.daemonToken) {
-      const status = await fetchDaemonStatus(resolvedConfig.daemonPort, resolvedConfig.daemonToken, {
-        timeoutMs: options.timeoutMs
+      const remainingBudgetMs = readRemainingBudgetMs(deadlineMs);
+      if (remainingBudgetMs <= 0) {
+        return null;
+      }
+      const timeoutMs = readSeedTimeoutMs(remainingBudgetMs, seeds.length - seedIndex);
+      const status = await fetchDaemonStatus(seed.port, seed.token, {
+        timeoutMs
       });
       if (status?.ok) {
-        persistDaemonStatusMetadata({
-          port: resolvedConfig.daemonPort,
-          token: resolvedConfig.daemonToken,
-          pid: status.pid,
-          relayPort: status.relay.port ?? resolvedConfig.relayPort,
-          startedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }, status, resolvedConfig);
+        persistDaemonStatusMetadata(seed, status, resolvedConfig);
         return status;
       }
     }
     if (attempt < attempts) {
-      await sleep2(retryDelayMs);
+      const remainingBudgetMs = readRemainingBudgetMs(deadlineMs);
+      if (remainingBudgetMs <= 0) {
+        break;
+      }
+      await sleep2(Math.min(retryDelayMs, remainingBudgetMs));
     }
   }
   return null;
@@ -39326,8 +39571,9 @@ function persistDaemonStatusMetadata(base, status, config) {
 // src/cli/daemon-client.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { join as join17 } from "path";
+import { join as join17, resolve as resolve8 } from "path";
 import { randomUUID as randomUUID23 } from "crypto";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var CLIENT_ID_FILE = "client.json";
 var DEFAULT_RENEW_AFTER_MS = 2e4;
 var MIN_RENEW_AFTER_MS = 5e3;
@@ -39338,10 +39584,23 @@ var DAEMON_STATUS_RETRY_OPTIONS = {
   retryAttempts: 5,
   retryDelayMs: 250
 };
+var DAEMON_CONFIG_PREFER_OPTIONS = {
+  timeoutMs: 500,
+  retryAttempts: 3,
+  retryDelayMs: 250
+};
 var DAEMON_RESTART_STATUS_TIMEOUT_MS = 5e3;
+var DAEMON_RECOVERY_READY_TIMEOUT_MS = 5e3;
 var DAEMON_RESTART_READY_TIMEOUT_MS = 15e3;
 var DAEMON_RESTART_POLL_DELAY_MS = 250;
 var cachedClientState;
+var logDaemonStopDebug2 = (message, details) => {
+  if (process.env[DAEMON_STOP_DEBUG_ENV] !== "1") {
+    return;
+  }
+  const suffix = details ? ` ${JSON.stringify(details)}` : "";
+  console.error(`[daemon-stop-debug] ${message}${suffix}`);
+};
 var getClientStateFilePath = () => {
   const cacheRoot = getCacheRoot();
   return join17(cacheRoot, CLIENT_ID_FILE);
@@ -39429,7 +39688,7 @@ var isLeaseInvalidError = (error) => {
   const message = error instanceof Error ? error.message : String(error ?? "");
   return message.startsWith("RELAY_LEASE_INVALID");
 };
-var isTransportTimeoutError = (error) => {
+var isTransportTimeoutError2 = (error) => {
   const message = error instanceof Error ? error.message : String(error ?? "");
   return message.startsWith("Request timed out after ");
 };
@@ -39465,7 +39724,7 @@ var DaemonClient = class {
         this.maybeTrackLease(name, params2, result);
         return result;
       }
-      if (!options.requireBinding && isBindingRequiredError(error)) {
+      if (isBindingRequiredError(error)) {
         if (this.binding) {
           this.clearBinding();
         }
@@ -39588,22 +39847,31 @@ var DaemonClient = class {
     }
   }
   async callRaw(name, params2, timeoutMs) {
-    const connection = await resolveDaemonConnection();
+    const budget = createTimeoutBudget(timeoutMs);
+    const connection = await resolveDaemonConnection(budget, {
+      preferConfiguredRecovery: requiresConfiguredRecovery(name)
+    });
     let timedResponse;
     try {
-      timedResponse = await openDaemonCommand(connection.port, connection.token, name, params2, timeoutMs);
+      timedResponse = await openDaemonCommand(
+        connection.port,
+        connection.token,
+        name,
+        params2,
+        readRemainingBudgetMs2(budget)
+      );
     } catch (error) {
-      if (isTransportTimeoutError(error)) {
+      if (isTransportTimeoutError2(error)) {
         throw error;
       }
-      timedResponse = await retryWithRefreshedConnection(name, params2, timeoutMs);
+      timedResponse = await retryWithRefreshedConnection(name, params2, budget);
     }
     try {
       if (!timedResponse.response.ok) {
         const message = await readDaemonErrorMessage(timedResponse);
         if (message.includes("Unauthorized") || timedResponse.response.status === 401) {
           timedResponse.dispose();
-          timedResponse = await retryWithRefreshedConnection(name, params2, timeoutMs);
+          timedResponse = await retryWithRefreshedConnection(name, params2, budget);
           if (!timedResponse.response.ok) {
             throw new CliError(await readDaemonErrorMessage(timedResponse), EXIT_EXECUTION);
           }
@@ -39628,6 +39896,37 @@ var DaemonClient = class {
 var asPositiveNumber = (value) => {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 };
+var createTransportTimeoutError = (timeoutMs) => {
+  return new Error(`Request timed out after ${timeoutMs}ms`);
+};
+var createTimeoutBudget = (timeoutMs) => {
+  const resolved = asPositiveNumber(timeoutMs);
+  return resolved === void 0 ? null : { timeoutMs: resolved, deadlineMs: Date.now() + resolved };
+};
+var readRemainingBudgetMs2 = (budget) => {
+  if (!budget) {
+    return void 0;
+  }
+  const remainingMs = budget.deadlineMs - Date.now();
+  if (remainingMs <= 0) {
+    throw createTransportTimeoutError(budget.timeoutMs);
+  }
+  return remainingMs;
+};
+var capTimeoutToBudget = (timeoutMs, budget) => {
+  const remainingMs = readRemainingBudgetMs2(budget);
+  return remainingMs === void 0 ? timeoutMs : Math.max(1, Math.min(timeoutMs, remainingMs));
+};
+var resolveReadyDeadlineMs = (readyTimeoutMs, budget) => {
+  const localDeadlineMs = Date.now() + readyTimeoutMs;
+  return budget ? Math.min(localDeadlineMs, budget.deadlineMs) : localDeadlineMs;
+};
+var hasBudgetTimedOut = (budget, deadlineMs) => {
+  if (!budget) {
+    return false;
+  }
+  return deadlineMs >= budget.deadlineMs && Date.now() >= budget.deadlineMs;
+};
 var deriveTransportTimeoutMs = (params2, explicitTimeoutMs) => {
   const explicit = asPositiveNumber(explicitTimeoutMs);
   if (explicit !== void 0) {
@@ -39649,11 +39948,98 @@ var cliClient = new DaemonClient({ autoRenew: false });
 async function callDaemon(command, params2, options) {
   return cliClient.call(command, params2 ?? {}, options);
 }
+var TYPESCRIPT_ENTRY_RE = /\.[cm]?ts$/i;
+var RESTART_LOADER_ARG_FLAGS = /* @__PURE__ */ new Set(["--experimental-loader", "--import", "--loader", "--require", "-r"]);
+var RESTART_TYPESCRIPT_CONTEXT_ARG_FLAGS = /* @__PURE__ */ new Set(["--experimental-strip-types", "--experimental-transform-types"]);
+var RESTART_DEBUG_ARG_FLAGS = /* @__PURE__ */ new Set(["--inspect", "--inspect-brk", "--inspect-port", "--debug", "--debug-brk"]);
+var isInlineRestartArg = (arg, flags) => {
+  for (const flag of flags) {
+    if (arg.startsWith(`${flag}=`)) {
+      return true;
+    }
+  }
+  return false;
+};
+var isRestartLoaderArg = (arg) => {
+  return RESTART_LOADER_ARG_FLAGS.has(arg) || isInlineRestartArg(arg, RESTART_LOADER_ARG_FLAGS);
+};
+var isRestartTypeScriptContextArg = (arg) => {
+  return RESTART_TYPESCRIPT_CONTEXT_ARG_FLAGS.has(arg) || isInlineRestartArg(arg, RESTART_TYPESCRIPT_CONTEXT_ARG_FLAGS);
+};
+var isRestartDebugArg = (arg) => {
+  return RESTART_DEBUG_ARG_FLAGS.has(arg) || isInlineRestartArg(arg, RESTART_DEBUG_ARG_FLAGS);
+};
+var resolveRestartSplitArgValue = (arg, value) => {
+  if (arg.includes("=")) return null;
+  if (typeof value !== "string") return null;
+  return value.startsWith("-") ? null : value;
+};
+var resolveRestartExecArgv = (entryPath, execArgv) => {
+  const preserved = [];
+  let hasLoaderContext = false;
+  for (let index = 0; index < execArgv.length; index += 1) {
+    const arg = execArgv[index];
+    if (!arg) {
+      continue;
+    }
+    if (isRestartDebugArg(arg)) {
+      const next = resolveRestartSplitArgValue(arg, execArgv[index + 1]);
+      if (RESTART_DEBUG_ARG_FLAGS.has(arg) && next) {
+        index += 1;
+      }
+      continue;
+    }
+    preserved.push(arg);
+    if (isRestartLoaderArg(arg) || isRestartTypeScriptContextArg(arg)) {
+      hasLoaderContext = true;
+    }
+    const value = resolveRestartSplitArgValue(arg, execArgv[index + 1]);
+    if (!value) continue;
+    preserved.push(value);
+    index += 1;
+  }
+  return TYPESCRIPT_ENTRY_RE.test(entryPath) && !hasLoaderContext ? [] : preserved;
+};
+var fetchCurrentDaemonStatus = async (connection, options, budget = null) => {
+  const attempts = typeof options.retryAttempts === "number" && Number.isFinite(options.retryAttempts) && options.retryAttempts > 1 ? Math.floor(options.retryAttempts) : 1;
+  const retryDelayMs = typeof options.retryDelayMs === "number" && Number.isFinite(options.retryDelayMs) && options.retryDelayMs > 0 ? options.retryDelayMs : 0;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const status = await fetchDaemonStatus(connection.port, connection.token, {
+      timeoutMs: capTimeoutToBudget(options.timeoutMs ?? DAEMON_RESTART_STATUS_TIMEOUT_MS, budget)
+    });
+    if (status?.ok && isCurrentDaemonFingerprint(status.fingerprint)) {
+      return status;
+    }
+    if (attempt < attempts) {
+      await sleep3(Math.min(retryDelayMs, readRemainingBudgetMs2(budget) ?? retryDelayMs));
+    }
+  }
+  return null;
+};
+var fetchAnyDaemonStatus = async (connection, options, budget = null) => {
+  const attempts = typeof options.retryAttempts === "number" && Number.isFinite(options.retryAttempts) && options.retryAttempts > 1 ? Math.floor(options.retryAttempts) : 1;
+  const retryDelayMs = typeof options.retryDelayMs === "number" && Number.isFinite(options.retryDelayMs) && options.retryDelayMs > 0 ? options.retryDelayMs : 0;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const status = await fetchDaemonStatus(connection.port, connection.token, {
+      timeoutMs: capTimeoutToBudget(options.timeoutMs ?? DAEMON_RESTART_STATUS_TIMEOUT_MS, budget)
+    });
+    if (status?.ok) {
+      return status;
+    }
+    if (attempt < attempts) {
+      await sleep3(Math.min(retryDelayMs, readRemainingBudgetMs2(budget) ?? retryDelayMs));
+    }
+  }
+  return null;
+};
 var sleep3 = async (delayMs) => {
   if (!(Number.isFinite(delayMs) && delayMs > 0)) {
     return;
   }
-  await new Promise((resolve8) => setTimeout(resolve8, delayMs));
+  await new Promise((resolve9) => setTimeout(resolve9, delayMs));
+};
+var requiresConfiguredRecovery = (name) => {
+  return name === "canvas.execute";
 };
 var getConfiguredDaemonConnection = () => {
   const config = loadGlobalConfig();
@@ -39674,18 +40060,91 @@ var persistResolvedDaemonStatus = (connection, status) => {
     fingerprint: status.fingerprint
   }, status, config);
 };
-var stopDaemonConnection = async (connection) => {
+var persistCurrentConfiguredConnection = async (configuredConnection, status, staleMetadata) => {
+  if (staleMetadata && !sameDaemonConnection(staleMetadata.connection, configuredConnection)) {
+    void stopDaemonConnection(staleMetadata.connection, null, "persistCurrentConfiguredConnection.staleMetadata").catch(() => void 0);
+  }
+  persistResolvedDaemonStatus(configuredConnection, status);
+  return configuredConnection;
+};
+var resolveConfiguredPreferenceOptions = (budget) => {
+  if (!budget) {
+    return DAEMON_CONFIG_PREFER_OPTIONS;
+  }
+  const remainingMs = readRemainingBudgetMs2(budget);
+  if (remainingMs === void 0 || remainingMs <= 1) {
+    return null;
+  }
+  const timeoutMs = Math.min(DAEMON_CONFIG_PREFER_OPTIONS.timeoutMs ?? remainingMs, remainingMs);
+  const retryDelayMs = Math.max(0, DAEMON_CONFIG_PREFER_OPTIONS.retryDelayMs ?? 0);
+  const maxAttempts = Math.max(1, DAEMON_CONFIG_PREFER_OPTIONS.retryAttempts ?? 1);
+  let retryAttempts = 1;
+  while (retryAttempts < maxAttempts) {
+    const nextAttempts = retryAttempts + 1;
+    const nextWorstCaseMs = nextAttempts * timeoutMs + (nextAttempts - 1) * retryDelayMs;
+    if (nextWorstCaseMs > remainingMs) {
+      break;
+    }
+    retryAttempts = nextAttempts;
+  }
+  return {
+    timeoutMs,
+    retryAttempts,
+    retryDelayMs: retryAttempts > 1 ? retryDelayMs : 0
+  };
+};
+var stopDaemonConnection = async (connection, budget = null, reason = "unknown") => {
+  const stopTimeoutMs = capTimeoutToBudget(DAEMON_RESTART_STATUS_TIMEOUT_MS, budget);
+  logDaemonStopDebug2("client.stop.request", { reason, port: connection.port });
   try {
-    await fetchWithTimeout(`http://127.0.0.1:${connection.port}/stop`, {
+    const response = await fetchWithTimeout(`http://127.0.0.1:${connection.port}/stop`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${connection.token}` }
-    }, DAEMON_RESTART_STATUS_TIMEOUT_MS);
+      headers: createDaemonStopHeaders(connection.token, reason)
+    }, stopTimeoutMs);
+    if (response.status === 409) {
+      logDaemonStopDebug2("client.stop.fingerprintRejected", { reason, port: connection.port });
+      return "fingerprint_rejected";
+    }
+    if (!response.ok) {
+      logDaemonStopDebug2("client.stop.rejected", { reason, port: connection.port, status: response.status });
+      return "unreachable";
+    }
+    logDaemonStopDebug2("client.stop.complete", { reason, port: connection.port });
+    return "stopped";
   } catch {
+    logDaemonStopDebug2("client.stop.error", { reason, port: connection.port });
+    return "unreachable";
+  }
+};
+function resolveDaemonRestartCommand(options = {}) {
+  const execPath = options.execPath ?? process.execPath;
+  const execArgv = options.execArgv ?? process.execArgv;
+  const moduleUrl = options.moduleUrl ?? import.meta.url;
+  const argv1 = options.argv1 ?? process.argv[1];
+  const entryPath = resolveCurrentDaemonEntrypointPath({
+    argv1,
+    moduleUrl,
+    entryExists: options.entryExists ?? existsSync7
+  });
+  if (!(typeof argv1 === "string" && argv1.trim().length > 0)) {
+    const modulePath = resolve8(fileURLToPath3(moduleUrl));
+    if (entryPath === modulePath) {
+      throw createDisconnectedError("Daemon restart requires a stable CLI entrypoint. Start with `opendevbrowser serve`.");
+    }
   }
-};
+  const restartExecArgv = resolveRestartExecArgv(entryPath, execArgv);
+  if (TYPESCRIPT_ENTRY_RE.test(entryPath) && restartExecArgv.length === 0) {
+    throw createDisconnectedError("Daemon restart requires the original loader context. Start with `opendevbrowser serve`.");
+  }
+  return {
+    command: execPath,
+    args: [...restartExecArgv, entryPath]
+  };
+}
 var restartDaemonConnection = async (connection) => {
-  const child = spawn2(process.execPath, [
-    resolveCurrentDaemonEntrypointPath(),
+  const restart = resolveDaemonRestartCommand();
+  const child = spawn2(restart.command, [
+    ...restart.args,
     "serve",
     "--port",
     String(connection.port),
@@ -39699,11 +40158,18 @@ var restartDaemonConnection = async (connection) => {
   });
   child.unref();
 };
-var waitForCurrentDaemonStatus = async (connection) => {
-  const deadline = Date.now() + DAEMON_RESTART_READY_TIMEOUT_MS;
+var waitForCurrentDaemonStatus = async (connection, readyTimeoutMs = DAEMON_RESTART_READY_TIMEOUT_MS, budget = null) => {
+  const deadline = resolveReadyDeadlineMs(readyTimeoutMs, budget);
   while (true) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      if (hasBudgetTimedOut(budget, deadline)) {
+        throw createTransportTimeoutError(budget.timeoutMs);
+      }
+      return null;
+    }
     const status = await fetchDaemonStatus(connection.port, connection.token, {
-      timeoutMs: DAEMON_RESTART_STATUS_TIMEOUT_MS
+      timeoutMs: Math.min(DAEMON_RESTART_STATUS_TIMEOUT_MS, remainingMs)
     });
     if (status?.ok && isCurrentDaemonFingerprint(status.fingerprint)) {
       return status;
@@ -39711,15 +40177,36 @@ var waitForCurrentDaemonStatus = async (connection) => {
     if (Date.now() >= deadline) {
       return null;
     }
-    await sleep3(DAEMON_RESTART_POLL_DELAY_MS);
+    await sleep3(Math.min(DAEMON_RESTART_POLL_DELAY_MS, Math.max(0, deadline - Date.now())));
   }
 };
-var resolveMetadataConnection = async (metadataConnection, configuredConnection) => {
-  const status = await fetchDaemonStatus(
-    metadataConnection.port,
-    metadataConnection.token,
-    DAEMON_STATUS_RETRY_OPTIONS
-  );
+var waitForDaemonShutdown = async (connection, readyTimeoutMs = DAEMON_RECOVERY_READY_TIMEOUT_MS, budget = null) => {
+  const deadline = resolveReadyDeadlineMs(readyTimeoutMs, budget);
+  while (true) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      if (hasBudgetTimedOut(budget, deadline)) {
+        throw createTransportTimeoutError(budget.timeoutMs);
+      }
+      return null;
+    }
+    const status = await fetchDaemonStatus(connection.port, connection.token, {
+      timeoutMs: Math.min(DAEMON_RESTART_STATUS_TIMEOUT_MS, remainingMs)
+    });
+    if (!status?.ok) {
+      return "stopped";
+    }
+    if (isCurrentDaemonFingerprint(status.fingerprint)) {
+      return status;
+    }
+    if (Date.now() >= deadline) {
+      return null;
+    }
+    await sleep3(Math.min(DAEMON_RESTART_POLL_DELAY_MS, Math.max(0, deadline - Date.now())));
+  }
+};
+var resolveMetadataConnection = async (metadataConnection, configuredConnection, budget = null) => {
+  const status = await fetchAnyDaemonStatus(metadataConnection, DAEMON_STATUS_RETRY_OPTIONS, budget);
   if (!status?.ok) {
     return null;
   }
@@ -39732,57 +40219,130 @@ var resolveMetadataConnection = async (metadataConnection, configuredConnection)
   }
   return { connection: metadataConnection, status };
 };
-var resolveFreshDaemonConnection = async () => {
+var resolveFreshDaemonConnection = async (budget = null, options = {}) => {
   const configuredConnection = getConfiguredDaemonConnection();
   if (!configuredConnection) {
     throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
   }
-  const configuredStatus = await fetchDaemonStatus(
-    configuredConnection.port,
-    configuredConnection.token,
-    DAEMON_STATUS_RETRY_OPTIONS
-  );
-  if (configuredStatus?.ok && isCurrentDaemonFingerprint(configuredStatus.fingerprint)) {
-    persistResolvedDaemonStatus(configuredConnection, configuredStatus);
-    return configuredConnection;
-  }
+  const configuredStatus = await fetchAnyDaemonStatus(configuredConnection, DAEMON_STATUS_RETRY_OPTIONS, budget);
+  let currentConfiguredStatus = configuredStatus?.ok && isCurrentDaemonFingerprint(configuredStatus.fingerprint) ? configuredStatus : null;
   const metadata = readDaemonMetadata();
   const metadataConnection = metadata ? { port: metadata.port, token: metadata.token } : null;
-  const staleMetadata = metadataConnection ? await resolveMetadataConnection(metadataConnection, configuredConnection) : null;
-  if (staleMetadata?.status.ok && isCurrentDaemonFingerprint(staleMetadata.status.fingerprint)) {
+  const staleMetadata = metadataConnection ? await resolveMetadataConnection(metadataConnection, configuredConnection, budget) : null;
+  if (currentConfiguredStatus?.ok) {
+    return await persistCurrentConfiguredConnection(configuredConnection, currentConfiguredStatus, staleMetadata);
+  }
+  if (options.preferConfiguredRecovery && staleMetadata) {
+    currentConfiguredStatus = await waitForCurrentDaemonStatus(
+      configuredConnection,
+      DAEMON_RECOVERY_READY_TIMEOUT_MS,
+      budget
+    );
+    if (currentConfiguredStatus?.ok) {
+      return await persistCurrentConfiguredConnection(configuredConnection, currentConfiguredStatus, staleMetadata);
+    }
+    if (!configuredStatus?.ok) {
+      throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
+    }
+  }
+  if (!options.preferConfiguredRecovery && staleMetadata?.status.ok && isCurrentDaemonFingerprint(staleMetadata.status.fingerprint)) {
+    if (configuredStatus?.ok) {
+      void stopDaemonConnection(configuredConnection, budget, "resolveFreshDaemonConnection.configuredCurrentMetadataPreferred").catch(() => void 0);
+    }
     return staleMetadata.connection;
   }
+  if (!configuredStatus?.ok && staleMetadata) {
+    currentConfiguredStatus = await waitForCurrentDaemonStatus(
+      configuredConnection,
+      DAEMON_RECOVERY_READY_TIMEOUT_MS,
+      budget
+    );
+    if (currentConfiguredStatus?.ok) {
+      return await persistCurrentConfiguredConnection(configuredConnection, currentConfiguredStatus, staleMetadata);
+    }
+    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
+  }
   const staleConnections = [];
   if (configuredStatus?.ok) {
-    staleConnections.push(configuredConnection);
-  }
-  if (staleMetadata && !sameDaemonConnection(staleMetadata.connection, configuredConnection)) {
-    staleConnections.push(staleMetadata.connection);
+    staleConnections.push({ connection: configuredConnection, status: configuredStatus });
   }
   if (staleConnections.length === 0) {
+    const recoveringStatus = await waitForCurrentDaemonStatus(
+      configuredConnection,
+      DAEMON_RECOVERY_READY_TIMEOUT_MS,
+      budget
+    );
+    if (recoveringStatus?.ok) {
+      persistResolvedDaemonStatus(configuredConnection, recoveringStatus);
+      return configuredConnection;
+    }
     throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
   }
   for (const staleConnection of staleConnections) {
-    await stopDaemonConnection(staleConnection);
+    const stopOutcome = await stopDaemonConnection(
+      staleConnection.connection,
+      budget,
+      "resolveFreshDaemonConnection.staleConnections"
+    );
+    if (stopOutcome === "fingerprint_rejected") {
+      throw createDisconnectedError(
+        `Daemon on 127.0.0.1:${staleConnection.connection.port} pid=${staleConnection.status.pid} is protected by a different opendevbrowser build. Start with \`opendevbrowser serve\`.`
+      );
+    }
+  }
+  if (configuredStatus?.ok) {
+    const shutdownOutcome = await waitForDaemonShutdown(configuredConnection, DAEMON_RECOVERY_READY_TIMEOUT_MS, budget);
+    if (!shutdownOutcome) {
+      throw createDisconnectedError("Daemon restart could not reclaim the configured port after fingerprint mismatch. Start with `opendevbrowser serve`.");
+    }
+    if (shutdownOutcome !== "stopped") {
+      persistResolvedDaemonStatus(configuredConnection, shutdownOutcome);
+      return configuredConnection;
+    }
   }
   await restartDaemonConnection(configuredConnection);
-  const refreshedStatus = await waitForCurrentDaemonStatus(configuredConnection);
+  const refreshedStatus = await waitForCurrentDaemonStatus(configuredConnection, DAEMON_RESTART_READY_TIMEOUT_MS, budget);
   if (!refreshedStatus?.ok) {
     throw createDisconnectedError("Daemon restart failed after fingerprint mismatch. Start with `opendevbrowser serve`.");
   }
   persistResolvedDaemonStatus(configuredConnection, refreshedStatus);
   return configuredConnection;
 };
-var resolveDaemonConnection = async () => {
+var resolveDaemonConnection = async (budget = null, options = {}) => {
   const metadata = readDaemonMetadata();
   if (metadata && isCurrentDaemonFingerprint(metadata.fingerprint)) {
-    return { port: metadata.port, token: metadata.token };
+    const metadataConnection = { port: metadata.port, token: metadata.token };
+    const configuredConnection = getConfiguredDaemonConnection();
+    if (!configuredConnection || sameDaemonConnection(metadataConnection, configuredConnection)) {
+      return metadataConnection;
+    }
+    const configuredOptions = resolveConfiguredPreferenceOptions(budget);
+    if (!configuredOptions) {
+      if (options.preferConfiguredRecovery) {
+        return await resolveFreshDaemonConnection(budget, options);
+      }
+      return metadataConnection;
+    }
+    const configuredStatus = await fetchCurrentDaemonStatus(configuredConnection, configuredOptions, budget);
+    if (configuredStatus?.ok) {
+      return await persistCurrentConfiguredConnection(
+        configuredConnection,
+        configuredStatus,
+        { connection: metadataConnection }
+      );
+    }
+    if (options.preferConfiguredRecovery) {
+      return await resolveFreshDaemonConnection(budget, options);
+    }
+    return metadataConnection;
   }
-  return await resolveFreshDaemonConnection();
+  return await resolveFreshDaemonConnection(budget, options);
 };
-var retryWithRefreshedConnection = async (name, params2, timeoutMs) => {
-  const connection = await resolveFreshDaemonConnection();
-  return await openDaemonCommand(connection.port, connection.token, name, params2, timeoutMs);
+var retryWithRefreshedConnection = async (name, params2, budget) => {
+  const connection = await resolveFreshDaemonConnection(budget, {
+    preferConfiguredRecovery: requiresConfiguredRecovery(name)
+  });
+  return await openDaemonCommand(connection.port, connection.token, name, params2, readRemainingBudgetMs2(budget));
 };
 var openDaemonCommand = async (port, token, name, params2, timeoutMs) => {
   return await fetchWithTimeoutContext(`http://127.0.0.1:${port}/command`, {
@@ -39967,6 +40527,15 @@ var buildAnnotateResult = async (payload) => {
   };
 };
 
+// src/cli/transport-timeouts.ts
+var DEFAULT_CLICK_TRANSPORT_TIMEOUT_MS = 6e4;
+var DEFAULT_DIALOG_TRANSPORT_TIMEOUT_MS = 3e4;
+var DEFAULT_TARGET_CREATION_TRANSPORT_TIMEOUT_MS = 3e4;
+var DEFAULT_SNAPSHOT_TRANSPORT_TIMEOUT_MS = 3e4;
+var DEFAULT_REVIEW_TRANSPORT_TIMEOUT_MS = 3e4;
+var DEFAULT_SCREENSHOT_TRANSPORT_TIMEOUT_MS = 3e4;
+var DEFAULT_WORKFLOW_TRANSPORT_TIMEOUT_MS = 12e4;
+
 // src/public-surface/generated-manifest.ts
 var PUBLIC_SURFACE_MANIFEST = {
   "schemaVersion": "2026-04-04",
@@ -40547,10 +41116,10 @@ var PUBLIC_SURFACE_MANIFEST = {
           "--cookie-policy"
         ],
         "examples": [
-          'npx opendevbrowser inspiredesign run --brief "Extract a reusable dashboard design contract from live references" --url https://linear.app --capture-mode deep --include-prototype-guidance --output-dir /tmp/inspiredesign --output-format json'
+          'npx opendevbrowser inspiredesign run --brief "Extract a reusable dashboard design contract from live references" --url https://linear.app --include-prototype-guidance --output-dir /tmp/inspiredesign --output-format json'
         ],
         "notes": [
-          "--capture-mode defaults to off; opt into deep only when live DOM or layout evidence is required.",
+          "Any inspiredesign --url forces deep capture for DOM/layout evidence; without URLs, --capture-mode defaults to off.",
           "Repeat --url for multiple references. There is no --urls alias."
         ],
         "groupId": "provider_workflows",
@@ -42489,7 +43058,7 @@ var PUBLIC_SURFACE_MANIFEST = {
         "name": "opendevbrowser_inspiredesign_run",
         "description": "Run the inspiredesign workflow directly.",
         "cliEquivalent": "inspiredesign",
-        "example": 'npx opendevbrowser inspiredesign run --brief "Extract a reusable dashboard design contract from live references" --url https://linear.app --capture-mode deep --include-prototype-guidance --output-dir /tmp/inspiredesign --output-format json'
+        "example": 'npx opendevbrowser inspiredesign run --brief "Extract a reusable dashboard design contract from live references" --url https://linear.app --include-prototype-guidance --output-dir /tmp/inspiredesign --output-format json'
       },
       {
         "name": "opendevbrowser_canvas",
@@ -42942,21 +43511,31 @@ export {
   executeMacroWithRuntime,
   fetchWithTimeout,
   readDaemonMetadata,
-  getCurrentDaemonFingerprint,
+  isCurrentDaemonFingerprint,
+  createDaemonStopHeaders,
   startDaemon,
   EXIT_USAGE,
   EXIT_EXECUTION,
   EXIT_DISCONNECTED,
   createUsageError,
+  createDisconnectedError,
   toCliError,
   formatErrorPayload,
   resolveExitCode,
+  DEFAULT_DAEMON_STATUS_FETCH_OPTIONS,
   fetchDaemonStatus,
   fetchDaemonStatusFromMetadata,
   DaemonClient,
   callDaemon,
   onboarding_metadata_default,
   buildAnnotateResult,
+  DEFAULT_CLICK_TRANSPORT_TIMEOUT_MS,
+  DEFAULT_DIALOG_TRANSPORT_TIMEOUT_MS,
+  DEFAULT_TARGET_CREATION_TRANSPORT_TIMEOUT_MS,
+  DEFAULT_SNAPSHOT_TRANSPORT_TIMEOUT_MS,
+  DEFAULT_REVIEW_TRANSPORT_TIMEOUT_MS,
+  DEFAULT_SCREENSHOT_TRANSPORT_TIMEOUT_MS,
+  DEFAULT_WORKFLOW_TRANSPORT_TIMEOUT_MS,
   VALID_FLAGS,
   VALID_EQUALS_FLAGS,
   CLI_COMMANDS,
@@ -42965,4 +43544,4 @@ export {
   TOOL_SURFACE_ENTRIES
 };
 /* v8 ignore next -- @preserve */
-//# sourceMappingURL=chunk-5I6TZRVS.js.map
+//# sourceMappingURL=chunk-GTTYIAI7.js.map