opendevbrowser 0.0.19 → 0.0.21

package/dist/{chunk-5FZQJRBQ.js → chunk-ZE2E7ZGH.js}

@@ -2,6 +2,7 @@ import {
   ProviderRuntimeError,
   createProviderError,
   isProviderReasonCode,
+  isProviderRuntimeError,
   normalizeProviderReasonCode,
   providerErrorCodeFromReasonCode,
   toProviderError
@@ -796,6 +797,12 @@ var applyProviderIssueHint = (details, hint) => {
   if (hint.constraint && !isProviderConstraint(next.constraint)) {
     next.constraint = hint.constraint;
   }
+  if (typeof next.guidance === "undefined") {
+    const guidance = buildProviderIssueGuidance({ hint, details: next });
+    if (guidance) {
+      next.guidance = guidance;
+    }
+  }
   return next;
 };
 var providerLabel = (provider) => {
@@ -805,6 +812,77 @@ var providerLabel = (provider) => {
   const tail = separator >= 0 ? normalized.slice(separator + 1) : normalized;
   return tail.charAt(0).toUpperCase() + tail.slice(1);
 };
+var hasPreservedBrowserState = (details) => {
+  return typeof details?.preservedSessionId === "string" || typeof details?.preservedTargetId === "string";
+};
+var buildGuidance = (reason, recommendedNextCommands) => ({
+  reason,
+  recommendedNextCommands
+});
+var buildAuthGuidance = (subject, preservedBrowserState) => {
+  return preservedBrowserState ? buildGuidance(
+    `${subject} preserved browser state that can finish authentication.`,
+    [
+      "Complete the login or account checkpoint in the preserved browser session.",
+      "Rerun the same provider or workflow after the session is fully authenticated."
+    ]
+  ) : buildGuidance(
+    `${subject} needs an authenticated session before retrying.`,
+    [
+      "Reuse an authenticated browser session, import logged-in cookies, or use the provider sign-in flow.",
+      "Rerun the same provider or workflow once the session is active."
+    ]
+  );
+};
+var buildChallengeGuidance = (subject, preservedBrowserState) => {
+  return preservedBrowserState ? buildGuidance(
+    `${subject} preserved browser state that can complete the current challenge.`,
+    [
+      "Finish the login or anti-bot challenge in the preserved browser session.",
+      "Rerun the same provider or workflow after the page unlocks."
+    ]
+  ) : buildGuidance(
+    `${subject} hit a challenge that still needs browser-assisted follow-up.`,
+    [
+      "Retry with browser assistance so the challenge can be completed interactively.",
+      "Only ask for manual credentials if browser-assisted recovery still cannot unlock the page."
+    ]
+  );
+};
+var buildRenderGuidance = (subject, preservedBrowserState) => {
+  return preservedBrowserState ? buildGuidance(
+    `${subject} still needs a live browser-rendered page, but browser state is already preserved.`,
+    [
+      "Inspect the preserved browser session until usable content is visible.",
+      "Rerun the same provider or workflow after the rendered page is ready."
+    ]
+  ) : buildGuidance(
+    `${subject} needs a live browser-rendered page before retrying.`,
+    [
+      "Retry with browser assistance or a headed browser session.",
+      "Rerun the same provider or workflow after the rendered page is ready."
+    ]
+  );
+};
+var buildProviderIssueGuidance = (args) => {
+  const subject = providerLabel(args.provider);
+  const preservedBrowserState = hasPreservedBrowserState(args.details);
+  const disposition = toNonEmptyString(args.details?.disposition);
+  if (disposition === "completed") return void 0;
+  if (disposition === "challenge_preserved") {
+    return buildChallengeGuidance(subject, true);
+  }
+  if (args.hint.reasonCode === "token_required" || args.hint.reasonCode === "auth_required") {
+    return buildAuthGuidance(subject, preservedBrowserState);
+  }
+  if (args.hint.reasonCode === "challenge_detected") {
+    return buildChallengeGuidance(subject, preservedBrowserState);
+  }
+  if (args.hint.constraint?.kind === "render_required" || args.hint.reasonCode === "env_limited") {
+    return buildRenderGuidance(subject, preservedBrowserState);
+  }
+  return void 0;
+};
 var summaryPriority = (hint) => {
   if (hint.reasonCode === "token_required" || hint.reasonCode === "auth_required") return 3;
   if (hint.reasonCode === "challenge_detected") return 2;
@@ -836,10 +914,16 @@ var summarizePrimaryProviderIssue = (failures) => {
     });
     if (!hint) continue;
     const summary = summarizeProviderIssue({ provider: failure.provider, hint });
+    const guidance = buildProviderIssueGuidance({
+      provider: failure.provider,
+      hint,
+      details: failure.error?.details
+    });
     const candidate = {
       provider: failure.provider,
       summary,
-      ...hint
+      ...hint,
+      ...guidance ? { guidance } : {}
     };
     if (!best || summaryPriority(candidate) > summaryPriority(best)) {
       best = candidate;
@@ -1983,6 +2067,138 @@ var verifyChallengeProgress = async (args) => {
   };
 };
 
+// src/challenges/capability-matrix.ts
+var buildCapabilityMatrix = (bundle, interpretation, gate) => {
+  const hasActionables = bundle.actionables.length > 0;
+  const helperActionRefs = [
+    ...bundle.continuity.loginRefs,
+    ...bundle.continuity.sessionReuseRefs,
+    ...bundle.continuity.humanVerificationRefs,
+    ...bundle.continuity.checkpointRefs,
+    ...bundle.interaction?.clickRefs ?? [],
+    ...bundle.interaction?.holdRefs ?? [],
+    ...bundle.interaction?.dragRefs ?? []
+  ];
+  const authLaneRelevant = interpretation.classification === "auth_required" || interpretation.classification === "existing_session_reuse" || bundle.continuity.likelyLoginPage || bundle.continuity.likelySessionPicker;
+  const canNavigateToAuth = gate.allowedActions.includes("auth_navigation") && authLaneRelevant && (bundle.continuity.loginRefs.length > 0 || typeof bundle.url === "string");
+  const canReuseExistingSession = gate.allowedActions.includes("session_reuse") && (bundle.continuity.hasPreservedSession || bundle.continuity.attachedSession || bundle.continuity.sessionReuseRefs.length > 0);
+  const canReuseCookies = gate.allowedActions.includes("cookie_reuse") && authLaneRelevant && (bundle.continuity.canReuseExistingCookies || bundle.continuity.canImportCookies);
+  const canFillNonSecretFields = gate.allowedActions.includes("non_secret_form_fill") && bundle.continuity.hasNonSecretTaskData && bundle.continuity.nonSecretFieldRefs.length > 0;
+  const canExploreClicks = gate.allowedActions.includes("click_path") && (hasActionables || bundle.continuity.loginRefs.length > 0 || bundle.continuity.sessionReuseRefs.length > 0 || bundle.continuity.checkpointRefs.length > 0);
+  const mustYield = interpretation.humanBoundary === "secret_entry" || interpretation.humanBoundary === "mfa" || interpretation.humanBoundary === "explicit_consent" || interpretation.humanBoundary === "exhausted_no_progress";
+  const mustDefer = interpretation.humanBoundary === "policy_blocked" || !bundle.blocker && bundle.blockerState === "clear";
+  let helperEligibility = gate.helperEligibility ?? (gate.optionalComputerUseBridge ? {
+    allowed: true,
+    reason: "Optional helper bridge remains eligible after policy resolution."
+  } : {
+    allowed: false,
+    reason: "Optional computer-use bridge is disabled by policy.",
+    standDownReason: "helper_disabled_by_policy"
+  });
+  if (helperEligibility.allowed && interpretation.humanBoundary !== "none") {
+    helperEligibility = {
+      allowed: false,
+      reason: `Helper bridge is blocked by human boundary: ${interpretation.humanBoundary}.`,
+      standDownReason: "helper_blocked_by_human_boundary"
+    };
+  } else if (helperEligibility.allowed && helperActionRefs.length === 0) {
+    helperEligibility = {
+      allowed: false,
+      reason: "Canonical evidence did not expose any safe browser-scoped helper actions.",
+      standDownReason: "helper_no_safe_actions"
+    };
+  }
+  return {
+    canNavigateToAuth,
+    canReuseExistingSession,
+    canReuseCookies,
+    canFillNonSecretFields,
+    canExploreClicks,
+    canUseOwnedEnvironmentFixture: interpretation.classification === "owned_environment_test_challenge" && gate.governedLanes.includes("owned_environment_fixture"),
+    canUseSanctionedIdentity: gate.governedLanes.includes("sanctioned_identity"),
+    canUseServiceAdapter: gate.governedLanes.includes("service_adapter"),
+    canUseComputerUseBridge: helperEligibility.allowed,
+    helperEligibility,
+    mustYield,
+    mustDefer
+  };
+};
+
+// src/challenges/capture.ts
+async function captureChallengeEvidence(args) {
+  const status = await args.handle.status(args.sessionId);
+  const effectiveTargetId = args.targetId ?? status.activeTargetId ?? null;
+  const snapshot = await args.handle.snapshot(
+    args.sessionId,
+    "actionables",
+    2400,
+    void 0,
+    effectiveTargetId
+  );
+  const debugTrace = await args.handle.debugTraceSnapshot(args.sessionId, { max: 50 });
+  const cookies = status.url ? await args.handle.cookieList(args.sessionId, [status.url]) : { count: 0 };
+  return buildChallengeEvidenceBundle({
+    status,
+    snapshot: {
+      snapshotId: snapshot.snapshotId,
+      content: snapshot.content,
+      warnings: snapshot.warnings
+    },
+    debugTrace,
+    cookieCount: cookies.count,
+    canImportCookies: args.canImportCookies,
+    fallbackDisposition: args.fallbackDisposition,
+    registryPressure: args.registryPressure,
+    taskData: args.taskData
+  });
+}
+
+// src/challenges/human-yield-gate.ts
+var shouldYieldToHuman = (args) => {
+  if (args.noProgressExhausted) {
+    return {
+      yield: true,
+      reason: "exhausted_no_progress"
+    };
+  }
+  return {
+    yield: args.interpretation.humanBoundary !== "none",
+    reason: args.interpretation.humanBoundary
+  };
+};
+var buildHumanYieldPacket = (args) => {
+  const challengeId = args.bundle.challengeId ?? `challenge-${Date.now()}`;
+  const targetHints = [
+    ...args.bundle.continuity.loginRefs,
+    ...args.bundle.continuity.sessionReuseRefs,
+    ...args.bundle.continuity.humanVerificationRefs,
+    ...args.bundle.continuity.checkpointRefs
+  ];
+  return {
+    challengeId,
+    classification: args.interpretation.classification,
+    reason: args.reason,
+    sessionId: args.sessionId,
+    targetId: args.targetId ?? args.bundle.activeTargetId,
+    ownerSurface: args.bundle.challenge?.ownerSurface ?? args.bundle.ownerSurface,
+    url: args.bundle.url,
+    title: args.bundle.title,
+    requiredHumanStep: args.reason === "mfa" ? "Complete MFA or passkey verification, then continue." : args.reason === "secret_entry" ? "Enter the required secret-bearing credentials, then continue." : args.reason === "unsupported_third_party" ? "Complete the unsupported third-party challenge manually, then continue." : "Review the page state and continue when ready.",
+    targetHints,
+    expectedPostAuthCheckpoint: args.interpretation.likelyCheckpoint,
+    preserveUntil: args.bundle.challenge?.preserveUntil,
+    verifyUntil: args.bundle.challenge?.verifyUntil,
+    traceRequestId: args.bundle.diagnostics.traceRequestId,
+    ...args.verification ? {
+      lastVerificationStatus: args.verification.status,
+      lastVerificationReason: args.verification.reason
+    } : {},
+    evidenceSummary: args.interpretation.summary,
+    reclaimHint: "Resume the preserved session and re-run verification after the human step completes.",
+    resumeRule: "Re-run manager-owned verification after the human step completes before resuming automation."
+  };
+};
+
 // src/challenges/optional-computer-use-bridge.ts
 var OPTIONAL_BRIDGE_SUGGESTION_REASON = "Optional bridge suggested a browser-scoped click follow-up from canonical evidence.";
 var buildComputerUseSuggestions = (bundle, maxSuggestions) => {
@@ -2027,907 +2243,955 @@ var suggestComputerUseActions = (args) => {
   };
 };
 
-// src/challenges/action-loop.ts
-var SENSITIVE_FIELD_RE = /\b(password|passcode|secret|otp|mfa|token|verification code|passkey)\b/i;
-var DEFAULT_HOLD_MS2 = 1500;
-var hasExecuted = (steps, kind, ref, url) => {
-  return steps.some((step) => step.kind === kind && step.ref === ref && step.url === url);
-};
-var getActionable = (bundle, ref) => {
-  return bundle.actionables.find((entry) => entry.ref === ref);
-};
-var deriveAuthUrls = (url) => {
-  if (!url) return [];
-  try {
-    const current = new URL(url);
-    const candidates = ["/login", "/signin", "/sign-in", "/account/login", "/session", "/auth/login"];
-    return candidates.map((path2) => new URL(path2, current.origin).toString());
-  } catch {
-    return [];
+// src/challenges/policy-gate.ts
+var ALL_ACTIONS = [
+  "wait",
+  "auth_navigation",
+  "session_reuse",
+  "cookie_reuse",
+  "element_discovery",
+  "click_path",
+  "click_and_hold",
+  "non_secret_form_fill",
+  "dropdown",
+  "scroll",
+  "hover",
+  "press",
+  "pointer",
+  "drag",
+  "verification",
+  "debug_trace"
+];
+var DEFAULT_HANDOFF_TRIGGERS = [
+  "secret_entry",
+  "mfa",
+  "explicit_consent",
+  "policy_blocked",
+  "unsupported_third_party",
+  "exhausted_no_progress"
+];
+var buildResolvedPolicy = (mode, source) => {
+  if (mode === "off") {
+    return {
+      mode,
+      source,
+      standDownReason: "challenge_automation_off"
+    };
   }
-};
-var resolveTaskValue = (bundle, ref) => {
-  const actionable = getActionable(bundle, ref);
-  const name = actionable?.name?.toLowerCase();
-  if (!name || !bundle.taskData) return void 0;
-  const entries = Object.entries(bundle.taskData);
-  for (const [key, value] of entries) {
-    if (SENSITIVE_FIELD_RE.test(key) || SENSITIVE_FIELD_RE.test(name)) {
-      continue;
-    }
-    if (!name.includes(key.toLowerCase())) {
-      continue;
-    }
-    switch (typeof value) {
-      case "string":
-      case "number":
-      case "boolean":
-        return String(value);
-      default:
-        break;
-    }
+  if (mode === "browser") {
+    return {
+      mode,
+      source,
+      standDownReason: "helper_disabled_for_browser_mode"
+    };
   }
-  return void 0;
-};
-var nextUnusedRef = (refs, steps, kind) => {
-  return refs.find((ref) => !hasExecuted(steps, kind, ref));
+  return { mode, source };
 };
-var planInteractionStep = (bundle, decision, executedSteps) => {
-  const interaction = bundle.interaction;
-  if (!interaction || interaction.preferredAction === "unknown") {
-    return void 0;
-  }
-  if (interaction.preferredAction === "click" && decision.allowedActionFamilies.includes("click_path")) {
-    const clickRef = nextUnusedRef(interaction.clickRefs, executedSteps, "click");
-    if (clickRef) {
-      return {
-        kind: "click",
-        ref: clickRef,
-        reason: "Visible popup or interstitial exposes a bounded click path."
-      };
-    }
+var resolveChallengeAutomationPolicy = (args) => {
+  if (args.runMode) {
+    return buildResolvedPolicy(args.runMode, "run");
   }
-  if (interaction.preferredAction === "click_and_hold" && decision.allowedActionFamilies.includes("click_and_hold")) {
-    const holdRef = nextUnusedRef(interaction.holdRefs, executedSteps, "click_and_hold");
-    if (holdRef || !hasExecuted(executedSteps, "click_and_hold")) {
-      return {
-        kind: "click_and_hold",
-        ...holdRef ? { ref: holdRef } : {},
-        ...typeof interaction.holdMs === "number" ? { holdMs: interaction.holdMs } : {},
-        reason: "Visible challenge requests a bounded click-and-hold gesture."
-      };
-    }
+  if (args.sessionMode) {
+    return buildResolvedPolicy(args.sessionMode, "session");
   }
-  if (interaction.preferredAction === "drag" && decision.allowedActionFamilies.includes("drag") && !hasExecuted(executedSteps, "drag")) {
-    return {
-      kind: "drag",
-      ...interaction.dragRefs[0] ? { ref: interaction.dragRefs[0] } : {},
-      coordinates: { x: 640, y: 360 },
-      reason: "Visible challenge requests a bounded drag gesture."
-    };
-  }
-  return void 0;
+  return buildResolvedPolicy(args.configMode, "config");
 };
-var planGenericStep = (bundle, decision, executedSteps) => {
-  const sessionRef = nextUnusedRef(bundle.continuity.sessionReuseRefs, executedSteps, "click");
-  if (sessionRef) {
+var resolveHelperEligibility = (config, policy) => {
+  if (policy.mode === "off") {
     return {
-      kind: "click",
-      ref: sessionRef,
-      reason: "Try the existing-session or account-selection path first."
+      allowed: false,
+      reason: "Challenge automation mode is off; detection and reporting remain active.",
+      standDownReason: "challenge_automation_off"
     };
   }
-  const loginRef = nextUnusedRef(bundle.continuity.loginRefs, executedSteps, "click");
-  if (decision.allowedActionFamilies.includes("auth_navigation") && loginRef) {
+  if (policy.mode === "browser") {
     return {
-      kind: "click",
-      ref: loginRef,
-      reason: "Try the visible auth-navigation entrypoint."
+      allowed: false,
+      reason: "Browser mode keeps the optional helper bridge disabled.",
+      standDownReason: "helper_disabled_for_browser_mode"
     };
   }
-  if (decision.allowedActionFamilies.includes("auth_navigation")) {
-    const loginUrl = deriveAuthUrls(bundle.url).find((candidate) => !hasExecuted(executedSteps, "goto", void 0, candidate));
-    if (loginUrl) {
-      return {
-        kind: "goto",
-        url: loginUrl,
-        reason: "Try a conventional auth-navigation URL on the current origin."
-      };
-    }
-  }
-  const fieldRef = nextUnusedRef(bundle.continuity.nonSecretFieldRefs, executedSteps, "type");
-  const fieldValue = fieldRef ? resolveTaskValue(bundle, fieldRef) : void 0;
-  if (decision.allowedActionFamilies.includes("non_secret_form_fill") && fieldRef && fieldValue) {
+  if (!config.optionalComputerUseBridge.enabled) {
     return {
-      kind: "type",
-      ref: fieldRef,
-      text: fieldValue,
-      reason: "Fill a non-secret field from caller-provided task data."
+      allowed: false,
+      reason: "Optional computer-use bridge is disabled by policy.",
+      standDownReason: "helper_disabled_by_policy"
     };
   }
-  const checkpointRef = nextUnusedRef(bundle.continuity.checkpointRefs, executedSteps, "click");
-  if (decision.allowedActionFamilies.includes("click_path") && checkpointRef) {
+  return {
+    allowed: true,
+    reason: "Optional helper bridge remains eligible after mode resolution."
+  };
+};
+var buildChallengePolicyGate = (config, interpretation, resolvedPolicy = resolveChallengeAutomationPolicy({
+  configMode: config.mode
+})) => {
+  const helperEligibility = resolveHelperEligibility(config, resolvedPolicy);
+  if (resolvedPolicy.mode === "off") {
     return {
-      kind: "click",
-      ref: checkpointRef,
-      reason: "Try the next visible checkpoint or continue action."
+      resolvedPolicy,
+      allowedActions: [],
+      forbiddenActions: [...ALL_ACTIONS],
+      handoffTriggers: [...DEFAULT_HANDOFF_TRIGGERS],
+      governedLanes: [],
+      optionalComputerUseBridge: false,
+      helperEligibility
     };
   }
-  const hoverRef = nextUnusedRef([...bundle.continuity.loginRefs, ...bundle.continuity.checkpointRefs], executedSteps, "hover");
-  if (decision.allowedActionFamilies.includes("hover") && hoverRef) {
-    return {
-      kind: "hover",
-      ref: hoverRef,
-      reason: "Hover a likely action target to reveal hidden menus or session pickers."
-    };
+  const allowed = /* @__PURE__ */ new Set(["wait", "verification", "debug_trace"]);
+  if (config.allowAuthNavigation) {
+    allowed.add("auth_navigation");
   }
-  if (decision.allowedActionFamilies.includes("scroll") && !hasExecuted(executedSteps, "scroll")) {
-    return {
-      kind: "scroll",
-      dy: 900,
-      reason: "Scroll down to uncover the next actionable region."
-    };
+  if (config.allowSessionReuse) {
+    allowed.add("session_reuse");
   }
-  if (decision.allowedActionFamilies.includes("scroll") && executedSteps.filter((step) => step.kind === "scroll").length === 1) {
-    return {
-      kind: "scroll",
-      dy: -450,
-      reason: "Scroll back up to re-evaluate the visible challenge state."
-    };
+  if (config.allowCookieReuse) {
+    allowed.add("cookie_reuse");
   }
-  if (decision.allowedActionFamilies.includes("press") && !hasExecuted(executedSteps, "press")) {
-    return {
-      kind: "press",
-      text: "Tab",
-      reason: "Advance focus through the challenge surface."
-    };
+  if (config.allowNonSecretFormFill) {
+    allowed.add("non_secret_form_fill");
+    allowed.add("dropdown");
   }
-  if (decision.allowedActionFamilies.includes("pointer") && !hasExecuted(executedSteps, "pointer")) {
-    return {
-      kind: "pointer",
-      coordinates: { x: 640, y: 360 },
-      reason: "Move the pointer through the center of the current browser surface."
-    };
+  if (config.allowInteractionExploration) {
+    allowed.add("element_discovery");
+    allowed.add("click_path");
+    allowed.add("click_and_hold");
+    allowed.add("scroll");
+    allowed.add("hover");
+    allowed.add("press");
+    allowed.add("pointer");
+    allowed.add("drag");
   }
-  if (decision.allowedActionFamilies.includes("drag") && !hasExecuted(executedSteps, "drag")) {
-    return {
-      kind: "drag",
-      coordinates: { x: 640, y: 360 },
-      reason: "Attempt one bounded vertical drag across the visible surface."
-    };
+  if (interpretation.humanBoundary === "secret_entry" || interpretation.humanBoundary === "mfa") {
+    allowed.delete("non_secret_form_fill");
   }
-  if (!hasExecuted(executedSteps, "wait")) {
-    return {
-      kind: "wait",
-      reason: "Give the page a short bounded settle window before yielding."
-    };
+  const governedLanes = [];
+  if (config.governed.allowOwnedEnvironmentFixtures) {
+    governedLanes.push("owned_environment_fixture");
   }
-  return void 0;
-};
-var resolveStepPoint = async (args) => {
-  if (!args.step.ref) {
-    return args.step.coordinates ?? args.fallback;
+  if (config.governed.allowSanctionedIdentity) {
+    governedLanes.push("sanctioned_identity");
   }
-  return await args.handle.resolveRefPoint(args.sessionId, args.step.ref, args.targetId);
-};
-var executeStep = async (args) => {
-  const timeoutMs = args.config.stepTimeoutMs;
-  switch (args.step.kind) {
-    case "goto":
-      if (args.step.url) {
-        await args.handle.goto(args.sessionId, args.step.url, "domcontentloaded", timeoutMs, void 0, args.targetId);
-      }
-      return;
-    case "click":
-      if (args.step.ref) {
-        await args.handle.click(args.sessionId, args.step.ref, args.targetId);
-      }
-      return;
-    case "click_and_hold": {
-      const point = await resolveStepPoint({
-        handle: args.handle,
-        sessionId: args.sessionId,
-        step: args.step,
-        targetId: args.targetId,
-        fallback: { x: 640, y: 360 }
-      });
-      await args.handle.pointerMove(args.sessionId, point.x, point.y, args.targetId, 12);
-      await args.handle.pointerDown(args.sessionId, point.x, point.y, args.targetId, "left", 1);
-      await new Promise((resolve2) => setTimeout(resolve2, Math.max(250, args.step.holdMs ?? DEFAULT_HOLD_MS2)));
-      await args.handle.pointerUp(args.sessionId, point.x, point.y, args.targetId, "left", 1);
-      return;
-    }
-    case "hover":
-      if (args.step.ref) {
-        await args.handle.hover(args.sessionId, args.step.ref, args.targetId);
-      }
-      return;
-    case "press":
-      await args.handle.press(args.sessionId, args.step.text ?? "Tab", void 0, args.targetId);
-      return;
-    case "type":
-      if (args.step.ref && typeof args.step.text === "string") {
-        await args.handle.type(args.sessionId, args.step.ref, args.step.text, true, false, args.targetId);
-      }
-      return;
-    case "select":
-      if (args.step.ref && args.step.values?.length) {
-        await args.handle.select(args.sessionId, args.step.ref, args.step.values, args.targetId);
-      }
-      return;
-    case "scroll":
-      await args.handle.scroll(args.sessionId, args.step.dy ?? 600, void 0, args.targetId);
-      return;
-    case "pointer":
-      await args.handle.pointerMove(
-        args.sessionId,
-        args.step.coordinates?.x ?? 640,
-        args.step.coordinates?.y ?? 360,
-        args.targetId,
-        12
-      );
-      return;
-    case "drag":
-      {
-        const point = await resolveStepPoint({
-          handle: args.handle,
-          sessionId: args.sessionId,
-          step: args.step,
-          targetId: args.targetId,
-          fallback: args.step.coordinates ?? { x: 640, y: 360 }
-        });
-        await args.handle.drag(
-          args.sessionId,
-          point,
-          {
-            x: point.x,
-            y: point.y + 260
-          },
-          args.targetId,
-          16
-        );
-      }
-      return;
-    case "cookie_list":
-      await args.handle.cookieList(args.sessionId, args.step.url ? [args.step.url] : void 0);
-      return;
-    case "cookie_import":
-      await args.handle.cookieImport(args.sessionId, args.step.cookies ?? [], true);
-      return;
-    case "snapshot":
-      await args.handle.snapshot(
-        args.sessionId,
-        "actionables",
-        args.step.snapshotChars ?? 2400,
-        void 0,
-        args.targetId
-      );
-      return;
-    case "debug_trace":
-      await args.handle.debugTraceSnapshot(args.sessionId, { max: args.step.traceMax ?? 50 });
-      return;
-    case "wait":
-      await args.handle.waitForLoad(args.sessionId, "networkidle", Math.min(timeoutMs, 3e3), args.targetId);
-      return;
-    default:
-      return;
+  if (config.governed.allowServiceAdapters) {
+    governedLanes.push("service_adapter");
   }
+  return {
+    resolvedPolicy,
+    allowedActions: ALL_ACTIONS.filter((action) => allowed.has(action)),
+    forbiddenActions: ALL_ACTIONS.filter((action) => !allowed.has(action)),
+    handoffTriggers: [...DEFAULT_HANDOFF_TRIGGERS],
+    governedLanes,
+    optionalComputerUseBridge: helperEligibility.allowed,
+    helperEligibility
+  };
 };
-var runChallengeActionLoop = async (args) => {
-  let currentBundle = args.initialBundle;
-  let currentTargetId = args.targetId ?? args.initialBundle.activeTargetId ?? null;
-  const executedSteps = [];
-  let noProgressCount = 0;
-  let reusedExistingSession = false;
-  let reusedCookies = false;
-  for (let attempt = 1; attempt <= args.decision.attemptBudget; attempt += 1) {
-    const suggestedStep = args.suggestedSteps?.find((candidate) => !hasExecuted(executedSteps, candidate.kind, candidate.ref, candidate.url));
-    const helperSuggestedStep = args.config.optionalComputerUseBridge.enabled ? buildComputerUseSuggestions(
-      currentBundle,
-      args.config.optionalComputerUseBridge.maxSuggestions
-    ).find((candidate) => !hasExecuted(executedSteps, candidate.kind, candidate.ref, candidate.url)) : void 0;
-    const interactionStep = planInteractionStep(currentBundle, args.decision, executedSteps);
-    const step = args.decision.lane === "optional_computer_use_bridge" ? suggestedStep ?? helperSuggestedStep : suggestedStep ?? interactionStep ?? planGenericStep(currentBundle, args.decision, executedSteps) ?? helperSuggestedStep;
-    if (!step) {
-      return {
-        status: "no_progress",
-        attempts: attempt - 1,
-        noProgressCount,
-        executedSteps,
-        verification: {
-          status: "still_blocked",
-          blockerState: currentBundle.blockerState,
-          blocker: currentBundle.blocker,
-          challenge: currentBundle.challenge,
-          bundle: currentBundle,
-          changed: false,
-          reason: "No additional safe browser action remained.",
-          url: currentBundle.url,
-          title: currentBundle.title
-        },
-        reusedExistingSession,
-        reusedCookies
-      };
-    }
-    try {
-      await executeStep({
-        handle: args.handle,
-        sessionId: args.sessionId,
-        targetId: currentTargetId,
-        step,
-        config: args.config
-      });
-    } catch {
+
+// src/challenges/strategy-selector.ts
+var buildDecision = (config, lane, rationale, allowedActionFamilies, verificationLevel, stopConditions, governedLane) => ({
+  lane,
+  ...governedLane ? { governedLane } : {},
+  rationale,
+  attemptBudget: config.attemptBudget,
+  noProgressLimit: config.noProgressLimit,
+  verificationLevel,
+  stopConditions,
+  allowedActionFamilies: [...allowedActionFamilies]
+});
+var selectChallengeStrategy = (args) => {
+  const { config, bundle, capabilityMatrix, gate, interpretation } = args;
+  const registryCooldownActive = (bundle.registryPressure?.cooldownUntilMs ?? 0) > Date.now();
+  const registryPressureElevated = (bundle.registryPressure?.activeChallenges ?? 0) > 0 || (bundle.registryPressure?.recentChallengeRatio ?? 0) >= 0.5 || (bundle.registryPressure?.recentRateLimitRatio ?? 0) >= 0.5;
+  const stopConditions = [
+    "manager_verification_clears_blocker",
+    "policy_gate_denies_next_action",
+    "human_boundary_detected",
+    "no_progress_budget_exhausted"
+  ];
+  const { mode, standDownReason } = gate.resolvedPolicy;
+  if (mode === "off") {
+    return buildDecision(
+      config,
+      "defer",
+      "Challenge automation mode is off; challenge handling is detect-and-report only.",
+      [],
+      "light",
+      [standDownReason ?? "challenge_automation_off"]
+    );
+  }
+  if (capabilityMatrix.mustDefer) {
+    return buildDecision(
+      config,
+      "defer",
+      "Current policy or blocker state requires deferral before further automation.",
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      ["policy_blocked_or_clear_state"]
+    );
+  }
+  if (registryCooldownActive && !capabilityMatrix.canReuseExistingSession && !capabilityMatrix.canReuseCookies && !capabilityMatrix.canNavigateToAuth) {
+    return buildDecision(
+      config,
+      "defer",
+      "Registry cooldown is still active and no legitimate continuity or auth-navigation lane is currently available.",
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      ["registry_cooldown_active"]
+    );
+  }
+  if (capabilityMatrix.canUseOwnedEnvironmentFixture) {
+    return buildDecision(
+      config,
+      "owned_environment_fixture",
+      "Owned-environment fixture detected and explicitly allowlisted.",
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      stopConditions,
+      "owned_environment_fixture"
+    );
+  }
+  if (capabilityMatrix.mustYield) {
+    return buildDecision(
+      config,
+      "human_yield",
+      `Human authority boundary reached: ${interpretation.humanBoundary}.`,
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      [...stopConditions, "human_authority_required"]
+    );
+  }
+  if (capabilityMatrix.canNavigateToAuth || capabilityMatrix.canReuseExistingSession || capabilityMatrix.canReuseCookies || capabilityMatrix.canFillNonSecretFields || capabilityMatrix.canExploreClicks) {
+    return buildDecision(
+      config,
+      "generic_browser_autonomy",
+      registryPressureElevated ? "Registry pressure is elevated, but legitimate browser continuity remains available for one bounded generic autonomy pass." : "Existing browser controls can attempt bounded auth navigation, session reuse, non-secret fill, or interaction exploration.",
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      registryPressureElevated ? [...stopConditions, "registry_pressure_elevated"] : stopConditions
+    );
+  }
+  if (capabilityMatrix.canUseComputerUseBridge) {
+    return buildDecision(
+      config,
+      "optional_computer_use_bridge",
+      "DOM-native autonomy is exhausted, but the optional browser-scoped bridge is enabled.",
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      stopConditions
+    );
+  }
+  if (capabilityMatrix.canUseSanctionedIdentity) {
+    return buildDecision(
+      config,
+      "sanctioned_identity",
+      "Sanctioned identity lane is enabled and generic browser autonomy is insufficient.",
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      stopConditions,
+      "sanctioned_identity"
+    );
+  }
+  if (capabilityMatrix.canUseServiceAdapter) {
+    return buildDecision(
+      config,
+      "service_adapter",
+      "Governed service-adapter lane is enabled as the last non-human option.",
+      gate.allowedActions,
+      interpretation.requiredVerification,
+      stopConditions,
+      "service_adapter"
+    );
+  }
+  return buildDecision(
+    config,
+    "human_yield",
+    `No legitimate autonomous lane remains after applying policy and continuity checks. ${capabilityMatrix.helperEligibility.reason}`,
+    gate.allowedActions,
+    interpretation.requiredVerification,
+    [...stopConditions, "no_legitimate_lane_remaining"]
+  );
+};
+
+// src/challenges/inspect-plan.ts
+var SENSITIVE_FIELD_RE = /\b(password|passcode|secret|otp|mfa|token|verification code|passkey)\b/i;
+var hasExecuted = (steps, kind, ref, url) => {
+  return steps.some((step) => step.kind === kind && step.ref === ref && step.url === url);
+};
+var getActionable = (bundle, ref) => {
+  return bundle.actionables.find((entry) => entry.ref === ref);
+};
+var deriveAuthUrls = (url) => {
+  if (!url) {
+    return [];
+  }
+  try {
+    const current = new URL(url);
+    const candidates = [
+      "/login",
+      "/signin",
+      "/sign-in",
+      "/account/login",
+      "/session",
+      "/auth/login"
+    ];
+    return candidates.map((path2) => new URL(path2, current.origin).toString());
+  } catch {
+    return [];
+  }
+};
+var resolveTaskValue = (bundle, ref) => {
+  const actionable = getActionable(bundle, ref);
+  const name = actionable?.name?.toLowerCase();
+  if (!name || !bundle.taskData) {
+    return void 0;
+  }
+  for (const [key, value] of Object.entries(bundle.taskData)) {
+    if (SENSITIVE_FIELD_RE.test(key) || SENSITIVE_FIELD_RE.test(name)) {
+      continue;
     }
-    executedSteps.push(step);
-    if (step.ref && currentBundle.continuity.sessionReuseRefs.includes(step.ref)) {
-      reusedExistingSession = true;
+    if (!name.includes(key.toLowerCase())) {
+      continue;
     }
-    if (step.kind === "goto" && currentBundle.continuity.canReuseExistingCookies) {
-      reusedCookies = true;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return String(value);
     }
-    const verification = await verifyChallengeProgress({
-      handle: args.handle,
-      sessionId: args.sessionId,
-      targetId: currentTargetId,
-      previous: currentBundle,
-      canImportCookies: currentBundle.continuity.canImportCookies,
-      fallbackDisposition: currentBundle.fallbackDisposition,
-      registryPressure: currentBundle.registryPressure,
-      taskData: currentBundle.taskData
-    });
-    currentBundle = verification.bundle ?? currentBundle;
-    currentTargetId = verification.bundle?.activeTargetId ?? currentTargetId;
-    if (verification.status === "clear") {
+  }
+  return void 0;
+};
+var nextUnusedRef = (refs, steps, kind) => {
+  return refs.find((ref) => !hasExecuted(steps, kind, ref));
+};
+var planInteractionStep = (bundle, decision, executedSteps) => {
+  const interaction = bundle.interaction;
+  if (!interaction || interaction.preferredAction === "unknown") {
+    return void 0;
+  }
+  if (interaction.preferredAction === "click" && decision.allowedActionFamilies.includes("click_path")) {
+    const clickRef = nextUnusedRef(interaction.clickRefs, executedSteps, "click");
+    if (clickRef) {
       return {
-        status: "resolved",
-        attempts: attempt,
-        noProgressCount,
-        executedSteps,
-        verification,
-        reusedExistingSession,
-        reusedCookies
+        kind: "click",
+        ref: clickRef,
+        reason: "Visible popup or interstitial exposes a bounded click path."
       };
     }
-    if (verification.status === "yield_required") {
+  }
+  if (interaction.preferredAction === "click_and_hold" && decision.allowedActionFamilies.includes("click_and_hold")) {
+    const holdRef = nextUnusedRef(interaction.holdRefs, executedSteps, "click_and_hold");
+    if (holdRef || !hasExecuted(executedSteps, "click_and_hold")) {
       return {
-        status: "yield_required",
-        attempts: attempt,
-        noProgressCount,
-        executedSteps,
-        verification,
-        reusedExistingSession,
-        reusedCookies
+        kind: "click_and_hold",
+        ...holdRef ? { ref: holdRef } : {},
+        ...typeof interaction.holdMs === "number" ? { holdMs: interaction.holdMs } : {},
+        reason: "Visible challenge requests a bounded click-and-hold gesture."
       };
     }
-    if (verification.status === "deferred") {
-      return {
-        status: "deferred",
-        attempts: attempt,
-        noProgressCount,
-        executedSteps,
-        verification,
-        reusedExistingSession,
-        reusedCookies
-      };
-    }
-    if (verification.changed) {
-      noProgressCount = 0;
-      continue;
-    }
-    noProgressCount += 1;
-    if (noProgressCount >= args.decision.noProgressLimit) {
+  }
+  if (interaction.preferredAction === "drag" && decision.allowedActionFamilies.includes("drag") && !hasExecuted(executedSteps, "drag")) {
+    return {
+      kind: "drag",
+      ...interaction.dragRefs[0] ? { ref: interaction.dragRefs[0] } : {},
+      coordinates: { x: 640, y: 360 },
+      reason: "Visible challenge requests a bounded drag gesture."
+    };
+  }
+  return void 0;
+};
+var planGenericStep = (bundle, decision, executedSteps) => {
+  const sessionRef = nextUnusedRef(
+    bundle.continuity.sessionReuseRefs,
+    executedSteps,
+    "click"
+  );
+  if (sessionRef) {
+    return {
+      kind: "click",
+      ref: sessionRef,
+      reason: "Try the existing-session or account-selection path first."
+    };
+  }
+  const loginRef = nextUnusedRef(bundle.continuity.loginRefs, executedSteps, "click");
+  if (decision.allowedActionFamilies.includes("auth_navigation") && loginRef) {
+    return {
+      kind: "click",
+      ref: loginRef,
+      reason: "Try the visible auth-navigation entrypoint."
+    };
+  }
+  if (decision.allowedActionFamilies.includes("auth_navigation")) {
+    const loginUrl = deriveAuthUrls(bundle.url).find((candidate) => {
+      return !hasExecuted(executedSteps, "goto", void 0, candidate);
+    });
+    if (loginUrl) {
       return {
-        status: "no_progress",
-        attempts: attempt,
-        noProgressCount,
-        executedSteps,
-        verification,
-        reusedExistingSession,
-        reusedCookies
+        kind: "goto",
+        url: loginUrl,
+        reason: "Try a conventional auth-navigation URL on the current origin."
       };
     }
   }
-  return {
-    status: "still_blocked",
-    attempts: args.decision.attemptBudget,
-    noProgressCount,
+  const fieldRef = nextUnusedRef(
+    bundle.continuity.nonSecretFieldRefs,
     executedSteps,
-    verification: {
-      status: "still_blocked",
-      blockerState: currentBundle.blockerState,
-      blocker: currentBundle.blocker,
-      challenge: currentBundle.challenge,
-      bundle: currentBundle,
-      changed: false,
-      reason: "Attempt budget exhausted without clearing the blocker.",
-      url: currentBundle.url,
-      title: currentBundle.title
-    },
-    reusedExistingSession,
-    reusedCookies
-  };
-};
-
-// src/challenges/capability-matrix.ts
-var buildCapabilityMatrix = (bundle, interpretation, gate) => {
-  const hasActionables = bundle.actionables.length > 0;
-  const helperActionRefs = [
-    ...bundle.continuity.loginRefs,
-    ...bundle.continuity.sessionReuseRefs,
-    ...bundle.continuity.humanVerificationRefs,
-    ...bundle.continuity.checkpointRefs,
-    ...bundle.interaction?.clickRefs ?? [],
-    ...bundle.interaction?.holdRefs ?? [],
-    ...bundle.interaction?.dragRefs ?? []
-  ];
-  const authLaneRelevant = interpretation.classification === "auth_required" || interpretation.classification === "existing_session_reuse" || bundle.continuity.likelyLoginPage || bundle.continuity.likelySessionPicker;
-  const canNavigateToAuth = gate.allowedActions.includes("auth_navigation") && authLaneRelevant && (bundle.continuity.loginRefs.length > 0 || typeof bundle.url === "string");
-  const canReuseExistingSession = gate.allowedActions.includes("session_reuse") && (bundle.continuity.hasPreservedSession || bundle.continuity.attachedSession || bundle.continuity.sessionReuseRefs.length > 0);
-  const canReuseCookies = gate.allowedActions.includes("cookie_reuse") && authLaneRelevant && (bundle.continuity.canReuseExistingCookies || bundle.continuity.canImportCookies);
-  const canFillNonSecretFields = gate.allowedActions.includes("non_secret_form_fill") && bundle.continuity.hasNonSecretTaskData && bundle.continuity.nonSecretFieldRefs.length > 0;
-  const canExploreClicks = gate.allowedActions.includes("click_path") && (hasActionables || bundle.continuity.loginRefs.length > 0 || bundle.continuity.sessionReuseRefs.length > 0 || bundle.continuity.checkpointRefs.length > 0);
-  const mustYield = interpretation.humanBoundary === "secret_entry" || interpretation.humanBoundary === "mfa" || interpretation.humanBoundary === "explicit_consent" || interpretation.humanBoundary === "exhausted_no_progress";
-  const mustDefer = interpretation.humanBoundary === "policy_blocked" || !bundle.blocker && bundle.blockerState === "clear";
-  let helperEligibility = gate.helperEligibility ?? (gate.optionalComputerUseBridge ? {
-    allowed: true,
-    reason: "Optional helper bridge remains eligible after policy resolution."
-  } : {
-    allowed: false,
-    reason: "Optional computer-use bridge is disabled by policy.",
-    standDownReason: "helper_disabled_by_policy"
-  });
-  if (helperEligibility.allowed && interpretation.humanBoundary !== "none") {
-    helperEligibility = {
-      allowed: false,
-      reason: `Helper bridge is blocked by human boundary: ${interpretation.humanBoundary}.`,
-      standDownReason: "helper_blocked_by_human_boundary"
+    "type"
+  );
+  const fieldValue = fieldRef ? resolveTaskValue(bundle, fieldRef) : void 0;
+  if (decision.allowedActionFamilies.includes("non_secret_form_fill") && fieldRef && fieldValue) {
+    return {
+      kind: "type",
+      ref: fieldRef,
+      text: fieldValue,
+      reason: "Fill a non-secret field from caller-provided task data."
     };
-  } else if (helperEligibility.allowed && helperActionRefs.length === 0) {
-    helperEligibility = {
-      allowed: false,
-      reason: "Canonical evidence did not expose any safe browser-scoped helper actions.",
-      standDownReason: "helper_no_safe_actions"
+  }
+  const checkpointRef = nextUnusedRef(
+    bundle.continuity.checkpointRefs,
+    executedSteps,
+    "click"
+  );
+  if (decision.allowedActionFamilies.includes("click_path") && checkpointRef) {
+    return {
+      kind: "click",
+      ref: checkpointRef,
+      reason: "Try the next visible checkpoint or continue action."
     };
   }
-  return {
-    canNavigateToAuth,
-    canReuseExistingSession,
-    canReuseCookies,
-    canFillNonSecretFields,
-    canExploreClicks,
-    canUseOwnedEnvironmentFixture: interpretation.classification === "owned_environment_test_challenge" && gate.governedLanes.includes("owned_environment_fixture"),
-    canUseSanctionedIdentity: gate.governedLanes.includes("sanctioned_identity"),
-    canUseServiceAdapter: gate.governedLanes.includes("service_adapter"),
-    canUseComputerUseBridge: helperEligibility.allowed,
-    helperEligibility,
-    mustYield,
-    mustDefer
-  };
+  const hoverRef = nextUnusedRef(
+    [...bundle.continuity.loginRefs, ...bundle.continuity.checkpointRefs],
+    executedSteps,
+    "hover"
+  );
+  if (decision.allowedActionFamilies.includes("hover") && hoverRef) {
+    return {
+      kind: "hover",
+      ref: hoverRef,
+      reason: "Hover a likely action target to reveal hidden menus or session pickers."
+    };
+  }
+  if (decision.allowedActionFamilies.includes("scroll") && !hasExecuted(executedSteps, "scroll")) {
+    return {
+      kind: "scroll",
+      dy: 900,
+      reason: "Scroll down to uncover the next actionable region."
+    };
+  }
+  if (decision.allowedActionFamilies.includes("scroll") && executedSteps.filter((step) => step.kind === "scroll").length === 1) {
+    return {
+      kind: "scroll",
+      dy: -450,
+      reason: "Scroll back up to re-evaluate the visible challenge state."
+    };
+  }
+  if (decision.allowedActionFamilies.includes("press") && !hasExecuted(executedSteps, "press")) {
+    return {
+      kind: "press",
+      text: "Tab",
+      reason: "Advance focus through the challenge surface."
+    };
+  }
+  if (decision.allowedActionFamilies.includes("pointer") && !hasExecuted(executedSteps, "pointer")) {
+    return {
+      kind: "pointer",
+      coordinates: { x: 640, y: 360 },
+      reason: "Move the pointer through the center of the current browser surface."
+    };
+  }
+  if (decision.allowedActionFamilies.includes("drag") && !hasExecuted(executedSteps, "drag")) {
+    return {
+      kind: "drag",
+      coordinates: { x: 640, y: 360 },
+      reason: "Attempt one bounded vertical drag across the visible surface."
+    };
+  }
+  if (!hasExecuted(executedSteps, "wait")) {
+    return {
+      kind: "wait",
+      reason: "Give the page a short bounded settle window before yielding."
+    };
+  }
+  return void 0;
 };
-
-// src/challenges/owned-environment-lane.ts
-var APPROVED_FIXTURE_RE = /\b(turnstile-checkbox|recaptcha-v2-checkbox|1x00000000000000000000AA|6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI)\b/i;
-var runOwnedEnvironmentLane = (request) => {
-  const haystack = [request.bundle.url, request.bundle.title, request.bundle.snapshotText].filter((value) => typeof value === "string" && value.length > 0).join(" ");
-  const approved = APPROVED_FIXTURE_RE.test(haystack);
-  return {
-    status: approved ? "executed" : "blocked",
-    lane: "owned_environment_fixture",
-    reason: approved ? "Approved owned-environment fixture detected." : "Owned-environment lane requires an approved vendor test fixture.",
-    auditMetadata: {
-      approvedFixture: approved
+var pendingSteps = (steps, executedSteps) => {
+  return (steps ?? []).filter((step) => {
+    return !hasExecuted(executedSteps, step.kind, step.ref, step.url);
+  });
+};
+var dedupeSteps = (steps) => {
+  const seen = /* @__PURE__ */ new Set();
+  return steps.filter((step) => {
+    const key = JSON.stringify([
+      step.kind,
+      step.ref ?? null,
+      step.url ?? null,
+      step.text ?? null,
+      step.reason
+    ]);
+    if (seen.has(key)) {
+      return false;
     }
-  };
+    seen.add(key);
+    return true;
+  });
 };
-
-// src/challenges/sanctioned-identity-lane.ts
-var runSanctionedIdentityLane = (request) => {
-  const entitlement = request.auditContext?.identityEntitlement;
-  const approved = typeof entitlement === "string" && entitlement.trim().length > 0;
+var buildChallengeActionSuggestions = (args) => {
+  const executedSteps = args.executedSteps ?? [];
+  const helper = suggestComputerUseActions({
+    helperEligibility: args.helperEligibility,
+    bundle: args.bundle,
+    maxSuggestions: args.config.optionalComputerUseBridge.maxSuggestions
+  });
+  const preferredSteps = pendingSteps(args.preferredSteps, executedSteps);
+  const interactionStep = planInteractionStep(args.bundle, args.decision, executedSteps);
+  const genericStep = planGenericStep(args.bundle, args.decision, executedSteps);
+  const helperSteps = pendingSteps(helper.suggestedSteps, executedSteps);
+  const suggestedSteps = args.decision.lane === "optional_computer_use_bridge" ? dedupeSteps([...preferredSteps, ...helperSteps]) : dedupeSteps([
+    ...preferredSteps,
+    ...interactionStep ? [interactionStep] : [],
+    ...genericStep ? [genericStep] : [],
+    ...helperSteps
+  ]);
   return {
-    status: approved ? "executed" : "blocked",
-    lane: "sanctioned_identity",
-    reason: approved ? "Sanctioned identity lane approved by explicit entitlement." : "Sanctioned identity lane requires explicit entitlement metadata.",
-    auditMetadata: {
-      approved,
-      ...approved ? { entitlement } : {}
-    }
+    helper,
+    suggestedSteps
   };
 };
-
-// src/challenges/service-adapter-lane.ts
-var runServiceAdapterLane = (request) => {
-  const adapter = request.auditContext?.adapterId;
-  const approved = typeof adapter === "string" && adapter.trim().length > 0;
+var selectChallengeActionStep = (args) => {
+  return buildChallengeActionSuggestions(args).suggestedSteps[0];
+};
+function buildChallengeInspectPlan(args) {
+  const interpretation = interpretChallengeEvidence(args.bundle);
+  const policy = resolveChallengeAutomationPolicy({
+    runMode: args.runMode,
+    sessionMode: args.sessionMode,
+    configMode: args.config.mode
+  });
+  const gate = buildChallengePolicyGate(args.config, interpretation, policy);
+  const capabilityMatrix = buildCapabilityMatrix(args.bundle, interpretation, gate);
+  const decision = selectChallengeStrategy({
+    config: args.config,
+    bundle: args.bundle,
+    interpretation,
+    capabilityMatrix,
+    gate
+  });
+  const actionSuggestions = buildChallengeActionSuggestions({
+    bundle: args.bundle,
+    decision,
+    helperEligibility: capabilityMatrix.helperEligibility,
+    config: args.config,
+    preferredSteps: args.preferredSteps,
+    executedSteps: args.executedSteps
+  });
+  const yieldDecision = shouldYieldToHuman({
+    interpretation,
+    noProgressExhausted: false
+  });
+  const standDownReason = capabilityMatrix.helperEligibility.standDownReason ?? gate.resolvedPolicy.standDownReason ?? actionSuggestions.helper.standDownReason;
   return {
-    status: approved ? "executed" : "blocked",
-    lane: "service_adapter",
-    reason: approved ? "Governed service adapter approved by explicit adapter metadata." : "Service-adapter lane requires an explicit adapter identifier and entitlement.",
-    auditMetadata: {
-      approved,
-      ...approved ? { adapterId: adapter } : {}
+    challengeId: args.bundle.challengeId,
+    ...args.bundle.mode ? { sessionMode: args.bundle.mode } : {},
+    classification: interpretation.classification,
+    authState: interpretation.authState,
+    summary: interpretation.summary,
+    mode: gate.resolvedPolicy.mode,
+    source: gate.resolvedPolicy.source,
+    helperEligibility: capabilityMatrix.helperEligibility,
+    ...standDownReason ? { standDownReason } : {},
+    yield: {
+      required: yieldDecision.yield,
+      reason: yieldDecision.reason
+    },
+    decision,
+    allowedActionFamilies: gate.allowedActions,
+    forbiddenActionFamilies: gate.forbiddenActions,
+    governedLanes: gate.governedLanes,
+    capabilityMatrix,
+    helper: actionSuggestions.helper,
+    suggestedSteps: actionSuggestions.suggestedSteps,
+    evidence: {
+      blockerState: args.bundle.blockerState,
+      ...args.bundle.blocker?.type ? { blockerType: args.bundle.blocker.type } : {},
+      ...args.bundle.url ? { url: args.bundle.url } : {},
+      ...args.bundle.title ? { title: args.bundle.title } : {},
+      ...typeof args.bundle.activeTargetId !== "undefined" ? { activeTargetId: args.bundle.activeTargetId } : {},
+      ...args.bundle.snapshotId ? { snapshotId: args.bundle.snapshotId } : {},
+      loginRefs: args.bundle.continuity.loginRefs,
+      sessionReuseRefs: args.bundle.continuity.sessionReuseRefs,
+      humanVerificationRefs: args.bundle.continuity.humanVerificationRefs,
+      checkpointRefs: args.bundle.continuity.checkpointRefs
     }
   };
-};
+}
+async function inspectChallengePlanFromRuntime(args) {
+  const bundle = await captureChallengeEvidence({
+    handle: args.handle,
+    sessionId: args.sessionId,
+    targetId: args.targetId,
+    canImportCookies: args.canImportCookies ?? true
+  });
+  return buildChallengeInspectPlan({
+    bundle,
+    config: args.config,
+    runMode: args.runMode,
+    sessionMode: args.sessionMode
+  });
+}
 
-// src/challenges/governed-adapter-gateway.ts
-var evaluateGovernedLane = (config, request) => {
-  if (config.mode === "off") {
-    return {
-      status: "blocked",
-      lane: request.lane,
-      reason: "Challenge automation mode is off.",
-      auditMetadata: {}
-    };
+// src/challenges/action-loop.ts
+var DEFAULT_HOLD_MS2 = 1500;
+var resolveStepPoint = async (args) => {
+  if (!args.step.ref) {
+    return args.step.coordinates ?? args.fallback;
   }
-  switch (request.lane) {
-    case "owned_environment_fixture":
-      if (!config.governed.allowOwnedEnvironmentFixtures) {
-        return {
-          status: "blocked",
-          lane: request.lane,
-          reason: "Owned-environment fixtures are disabled by policy.",
-          auditMetadata: {}
-        };
+  return await args.handle.resolveRefPoint(args.sessionId, args.step.ref, args.targetId);
+};
+var executeStep = async (args) => {
+  const timeoutMs = args.config.stepTimeoutMs;
+  switch (args.step.kind) {
+    case "goto":
+      if (args.step.url) {
+        await args.handle.goto(args.sessionId, args.step.url, "domcontentloaded", timeoutMs, void 0, args.targetId);
       }
-      return runOwnedEnvironmentLane(request);
-    case "sanctioned_identity":
-      if (!config.governed.allowSanctionedIdentity) {
-        return {
-          status: "blocked",
-          lane: request.lane,
-          reason: "Sanctioned identity is disabled by policy.",
-          auditMetadata: {}
-        };
+      return;
+    case "click":
+      if (args.step.ref) {
+        await args.handle.click(args.sessionId, args.step.ref, args.targetId);
       }
-      return runSanctionedIdentityLane(request);
-    case "service_adapter":
-      if (!config.governed.allowServiceAdapters) {
-        return {
-          status: "blocked",
-          lane: request.lane,
-          reason: "Service adapters are disabled by policy.",
-          auditMetadata: {}
-        };
+      return;
+    case "click_and_hold": {
+      const point = await resolveStepPoint({
+        handle: args.handle,
+        sessionId: args.sessionId,
+        step: args.step,
+        targetId: args.targetId,
+        fallback: { x: 640, y: 360 }
+      });
+      await args.handle.pointerMove(args.sessionId, point.x, point.y, args.targetId, 12);
+      await args.handle.pointerDown(args.sessionId, point.x, point.y, args.targetId, "left", 1);
+      await new Promise((resolve2) => setTimeout(resolve2, Math.max(250, args.step.holdMs ?? DEFAULT_HOLD_MS2)));
+      await args.handle.pointerUp(args.sessionId, point.x, point.y, args.targetId, "left", 1);
+      return;
+    }
+    case "hover":
+      if (args.step.ref) {
+        await args.handle.hover(args.sessionId, args.step.ref, args.targetId);
       }
-      return runServiceAdapterLane(request);
-  }
-};
-
-// src/challenges/human-yield-gate.ts
-var shouldYieldToHuman = (args) => {
-  if (args.noProgressExhausted) {
-    return {
-      yield: true,
-      reason: "exhausted_no_progress"
-    };
-  }
-  return {
-    yield: args.interpretation.humanBoundary !== "none",
-    reason: args.interpretation.humanBoundary
-  };
-};
-var buildHumanYieldPacket = (args) => {
-  const challengeId = args.bundle.challengeId ?? `challenge-${Date.now()}`;
-  const targetHints = [
-    ...args.bundle.continuity.loginRefs,
-    ...args.bundle.continuity.sessionReuseRefs,
-    ...args.bundle.continuity.humanVerificationRefs,
-    ...args.bundle.continuity.checkpointRefs
-  ];
-  return {
-    challengeId,
-    classification: args.interpretation.classification,
-    reason: args.reason,
-    sessionId: args.sessionId,
-    targetId: args.targetId ?? args.bundle.activeTargetId,
-    ownerSurface: args.bundle.challenge?.ownerSurface ?? args.bundle.ownerSurface,
-    url: args.bundle.url,
-    title: args.bundle.title,
-    requiredHumanStep: args.reason === "mfa" ? "Complete MFA or passkey verification, then continue." : args.reason === "secret_entry" ? "Enter the required secret-bearing credentials, then continue." : args.reason === "unsupported_third_party" ? "Complete the unsupported third-party challenge manually, then continue." : "Review the page state and continue when ready.",
-    targetHints,
-    expectedPostAuthCheckpoint: args.interpretation.likelyCheckpoint,
-    preserveUntil: args.bundle.challenge?.preserveUntil,
-    verifyUntil: args.bundle.challenge?.verifyUntil,
-    traceRequestId: args.bundle.diagnostics.traceRequestId,
-    ...args.verification ? {
-      lastVerificationStatus: args.verification.status,
-      lastVerificationReason: args.verification.reason
-    } : {},
-    evidenceSummary: args.interpretation.summary,
-    reclaimHint: "Resume the preserved session and re-run verification after the human step completes.",
-    resumeRule: "Re-run manager-owned verification after the human step completes before resuming automation."
-  };
-};
-
-// src/challenges/outcome-recorder.ts
-var MAX_RECORDS_PER_CHALLENGE = 25;
-var OutcomeRecorder = class {
-  records = /* @__PURE__ */ new Map();
-  record(record) {
-    const key = record.challengeId ?? "__untracked__";
-    const existing = this.records.get(key) ?? [];
-    const next = [...existing, record].slice(-MAX_RECORDS_PER_CHALLENGE);
-    this.records.set(key, next);
-  }
-  latest(challengeId) {
-    if (!challengeId) return void 0;
-    const entries = this.records.get(challengeId);
-    return entries?.[entries.length - 1];
-  }
-  read(challengeId) {
-    if (!challengeId) return [];
-    return [...this.records.get(challengeId) ?? []];
+      return;
+    case "press":
+      await args.handle.press(args.sessionId, args.step.text ?? "Tab", void 0, args.targetId);
+      return;
+    case "type":
+      if (args.step.ref && typeof args.step.text === "string") {
+        await args.handle.type(args.sessionId, args.step.ref, args.step.text, true, false, args.targetId);
+      }
+      return;
+    case "select":
+      if (args.step.ref && args.step.values?.length) {
+        await args.handle.select(args.sessionId, args.step.ref, args.step.values, args.targetId);
+      }
+      return;
+    case "scroll":
+      await args.handle.scroll(args.sessionId, args.step.dy ?? 600, void 0, args.targetId);
+      return;
+    case "pointer":
+      await args.handle.pointerMove(
+        args.sessionId,
+        args.step.coordinates?.x ?? 640,
+        args.step.coordinates?.y ?? 360,
+        args.targetId,
+        12
+      );
+      return;
+    case "drag":
+      {
+        const point = await resolveStepPoint({
+          handle: args.handle,
+          sessionId: args.sessionId,
+          step: args.step,
+          targetId: args.targetId,
+          fallback: args.step.coordinates ?? { x: 640, y: 360 }
+        });
+        await args.handle.drag(
+          args.sessionId,
+          point,
+          {
+            x: point.x,
+            y: point.y + 260
+          },
+          args.targetId,
+          16
+        );
+      }
+      return;
+    case "cookie_list":
+      await args.handle.cookieList(args.sessionId, args.step.url ? [args.step.url] : void 0);
+      return;
+    case "cookie_import":
+      await args.handle.cookieImport(args.sessionId, args.step.cookies ?? [], true);
+      return;
+    case "snapshot":
+      await args.handle.snapshot(
+        args.sessionId,
+        "actionables",
+        args.step.snapshotChars ?? 2400,
+        void 0,
+        args.targetId
+      );
+      return;
+    case "debug_trace":
+      await args.handle.debugTraceSnapshot(args.sessionId, { max: args.step.traceMax ?? 50 });
+      return;
+    case "wait":
+      await args.handle.waitForLoad(args.sessionId, "networkidle", Math.min(timeoutMs, 3e3), args.targetId);
+      return;
+    default:
+      return;
   }
 };
-
-// src/challenges/policy-gate.ts
-var ALL_ACTIONS = [
-  "wait",
-  "auth_navigation",
-  "session_reuse",
-  "cookie_reuse",
-  "element_discovery",
-  "click_path",
-  "click_and_hold",
-  "non_secret_form_fill",
-  "dropdown",
-  "scroll",
-  "hover",
-  "press",
-  "pointer",
-  "drag",
-  "verification",
-  "debug_trace"
-];
-var DEFAULT_HANDOFF_TRIGGERS = [
-  "secret_entry",
-  "mfa",
-  "explicit_consent",
-  "policy_blocked",
-  "unsupported_third_party",
-  "exhausted_no_progress"
-];
-var buildResolvedPolicy = (mode, source) => {
-  if (mode === "off") {
-    return {
-      mode,
-      source,
-      standDownReason: "challenge_automation_off"
-    };
-  }
-  if (mode === "browser") {
-    return {
-      mode,
-      source,
-      standDownReason: "helper_disabled_for_browser_mode"
-    };
+var runChallengeActionLoop = async (args) => {
+  let currentBundle = args.initialBundle;
+  let currentTargetId = args.targetId ?? args.initialBundle.activeTargetId ?? null;
+  const executedSteps = [];
+  let noProgressCount = 0;
+  let reusedExistingSession = false;
+  let reusedCookies = false;
+  for (let attempt = 1; attempt <= args.decision.attemptBudget; attempt += 1) {
+    const step = selectChallengeActionStep({
+      bundle: currentBundle,
+      decision: args.decision,
+      helperEligibility: args.helperEligibility,
+      config: args.config,
+      preferredSteps: args.suggestedSteps,
+      executedSteps
+    });
+    if (!step) {
+      return {
+        status: "no_progress",
+        attempts: attempt - 1,
+        noProgressCount,
+        executedSteps,
+        verification: {
+          status: "still_blocked",
+          blockerState: currentBundle.blockerState,
+          blocker: currentBundle.blocker,
+          challenge: currentBundle.challenge,
+          bundle: currentBundle,
+          changed: false,
+          reason: "No additional safe browser action remained.",
+          url: currentBundle.url,
+          title: currentBundle.title
+        },
+        reusedExistingSession,
+        reusedCookies
+      };
+    }
+    try {
+      await executeStep({
+        handle: args.handle,
+        sessionId: args.sessionId,
+        targetId: currentTargetId,
+        step,
+        config: args.config
+      });
+    } catch {
+    }
+    executedSteps.push(step);
+    if (step.ref && currentBundle.continuity.sessionReuseRefs.includes(step.ref)) {
+      reusedExistingSession = true;
+    }
+    if (step.kind === "goto" && currentBundle.continuity.canReuseExistingCookies) {
+      reusedCookies = true;
+    }
+    const verification = await verifyChallengeProgress({
+      handle: args.handle,
+      sessionId: args.sessionId,
+      targetId: currentTargetId,
+      previous: currentBundle,
+      canImportCookies: currentBundle.continuity.canImportCookies,
+      fallbackDisposition: currentBundle.fallbackDisposition,
+      registryPressure: currentBundle.registryPressure,
+      taskData: currentBundle.taskData
+    });
+    currentBundle = verification.bundle ?? currentBundle;
+    currentTargetId = verification.bundle?.activeTargetId ?? currentTargetId;
+    if (verification.status === "clear") {
+      return {
+        status: "resolved",
+        attempts: attempt,
+        noProgressCount,
+        executedSteps,
+        verification,
+        reusedExistingSession,
+        reusedCookies
+      };
+    }
+    if (verification.status === "yield_required") {
+      return {
+        status: "yield_required",
+        attempts: attempt,
+        noProgressCount,
+        executedSteps,
+        verification,
+        reusedExistingSession,
+        reusedCookies
+      };
+    }
+    if (verification.status === "deferred") {
+      return {
+        status: "deferred",
+        attempts: attempt,
+        noProgressCount,
+        executedSteps,
+        verification,
+        reusedExistingSession,
+        reusedCookies
+      };
+    }
+    if (verification.changed) {
+      noProgressCount = 0;
+      continue;
+    }
+    noProgressCount += 1;
+    if (noProgressCount >= args.decision.noProgressLimit) {
+      return {
+        status: "no_progress",
+        attempts: attempt,
+        noProgressCount,
+        executedSteps,
+        verification,
+        reusedExistingSession,
+        reusedCookies
+      };
+    }
   }
-  return { mode, source };
+  return {
+    status: "still_blocked",
+    attempts: args.decision.attemptBudget,
+    noProgressCount,
+    executedSteps,
+    verification: {
+      status: "still_blocked",
+      blockerState: currentBundle.blockerState,
+      blocker: currentBundle.blocker,
+      challenge: currentBundle.challenge,
+      bundle: currentBundle,
+      changed: false,
+      reason: "Attempt budget exhausted without clearing the blocker.",
+      url: currentBundle.url,
+      title: currentBundle.title
+    },
+    reusedExistingSession,
+    reusedCookies
+  };
 };
-var resolveChallengeAutomationPolicy = (args) => {
-  if (args.runMode) {
-    return buildResolvedPolicy(args.runMode, "run");
-  }
-  if (args.sessionMode) {
-    return buildResolvedPolicy(args.sessionMode, "session");
-  }
-  return buildResolvedPolicy(args.configMode, "config");
+
+// src/challenges/owned-environment-lane.ts
+var APPROVED_FIXTURE_RE = /\b(turnstile-checkbox|recaptcha-v2-checkbox|1x00000000000000000000AA|6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI)\b/i;
+var runOwnedEnvironmentLane = (request) => {
+  const haystack = [request.bundle.url, request.bundle.title, request.bundle.snapshotText].filter((value) => typeof value === "string" && value.length > 0).join(" ");
+  const approved = APPROVED_FIXTURE_RE.test(haystack);
+  return {
+    status: approved ? "executed" : "blocked",
+    lane: "owned_environment_fixture",
+    reason: approved ? "Approved owned-environment fixture detected." : "Owned-environment lane requires an approved vendor test fixture.",
+    auditMetadata: {
+      approvedFixture: approved
+    }
+  };
 };
-var resolveHelperEligibility = (config, policy) => {
-  if (policy.mode === "off") {
-    return {
-      allowed: false,
-      reason: "Challenge automation mode is off; detection and reporting remain active.",
-      standDownReason: "challenge_automation_off"
-    };
-  }
-  if (policy.mode === "browser") {
-    return {
-      allowed: false,
-      reason: "Browser mode keeps the optional helper bridge disabled.",
-      standDownReason: "helper_disabled_for_browser_mode"
-    };
-  }
-  if (!config.optionalComputerUseBridge.enabled) {
-    return {
-      allowed: false,
-      reason: "Optional computer-use bridge is disabled by policy.",
-      standDownReason: "helper_disabled_by_policy"
-    };
-  }
+
+// src/challenges/sanctioned-identity-lane.ts
+var runSanctionedIdentityLane = (request) => {
+  const entitlement = request.auditContext?.identityEntitlement;
+  const approved = typeof entitlement === "string" && entitlement.trim().length > 0;
   return {
-    allowed: true,
-    reason: "Optional helper bridge remains eligible after mode resolution."
+    status: approved ? "executed" : "blocked",
+    lane: "sanctioned_identity",
+    reason: approved ? "Sanctioned identity lane approved by explicit entitlement." : "Sanctioned identity lane requires explicit entitlement metadata.",
+    auditMetadata: {
+      approved,
+      ...approved ? { entitlement } : {}
+    }
   };
 };
-var buildChallengePolicyGate = (config, interpretation, resolvedPolicy = resolveChallengeAutomationPolicy({
-  configMode: config.mode
-})) => {
-  const helperEligibility = resolveHelperEligibility(config, resolvedPolicy);
-  if (resolvedPolicy.mode === "off") {
-    return {
-      resolvedPolicy,
-      allowedActions: [],
-      forbiddenActions: [...ALL_ACTIONS],
-      handoffTriggers: [...DEFAULT_HANDOFF_TRIGGERS],
-      governedLanes: [],
-      optionalComputerUseBridge: false,
-      helperEligibility
-    };
-  }
-  const allowed = /* @__PURE__ */ new Set(["wait", "verification", "debug_trace"]);
-  if (config.allowAuthNavigation) {
-    allowed.add("auth_navigation");
-  }
-  if (config.allowSessionReuse) {
-    allowed.add("session_reuse");
-  }
-  if (config.allowCookieReuse) {
-    allowed.add("cookie_reuse");
-  }
-  if (config.allowNonSecretFormFill) {
-    allowed.add("non_secret_form_fill");
-    allowed.add("dropdown");
-  }
-  if (config.allowInteractionExploration) {
-    allowed.add("element_discovery");
-    allowed.add("click_path");
-    allowed.add("click_and_hold");
-    allowed.add("scroll");
-    allowed.add("hover");
-    allowed.add("press");
-    allowed.add("pointer");
-    allowed.add("drag");
-  }
-  if (interpretation.humanBoundary === "secret_entry" || interpretation.humanBoundary === "mfa") {
-    allowed.delete("non_secret_form_fill");
-  }
-  const governedLanes = [];
-  if (config.governed.allowOwnedEnvironmentFixtures) {
-    governedLanes.push("owned_environment_fixture");
-  }
-  if (config.governed.allowSanctionedIdentity) {
-    governedLanes.push("sanctioned_identity");
-  }
-  if (config.governed.allowServiceAdapters) {
-    governedLanes.push("service_adapter");
-  }
+
+// src/challenges/service-adapter-lane.ts
+var runServiceAdapterLane = (request) => {
+  const adapter = request.auditContext?.adapterId;
+  const approved = typeof adapter === "string" && adapter.trim().length > 0;
   return {
-    resolvedPolicy,
-    allowedActions: ALL_ACTIONS.filter((action) => allowed.has(action)),
-    forbiddenActions: ALL_ACTIONS.filter((action) => !allowed.has(action)),
-    handoffTriggers: [...DEFAULT_HANDOFF_TRIGGERS],
-    governedLanes,
-    optionalComputerUseBridge: helperEligibility.allowed,
-    helperEligibility
+    status: approved ? "executed" : "blocked",
+    lane: "service_adapter",
+    reason: approved ? "Governed service adapter approved by explicit adapter metadata." : "Service-adapter lane requires an explicit adapter identifier and entitlement.",
+    auditMetadata: {
+      approved,
+      ...approved ? { adapterId: adapter } : {}
+    }
   };
 };
 
-// src/challenges/strategy-selector.ts
-var buildDecision = (config, lane, rationale, allowedActionFamilies, verificationLevel, stopConditions, governedLane) => ({
-  lane,
-  ...governedLane ? { governedLane } : {},
-  rationale,
-  attemptBudget: config.attemptBudget,
-  noProgressLimit: config.noProgressLimit,
-  verificationLevel,
-  stopConditions,
-  allowedActionFamilies: [...allowedActionFamilies]
-});
-var selectChallengeStrategy = (args) => {
-  const { config, bundle, capabilityMatrix, gate, interpretation } = args;
-  const registryCooldownActive = (bundle.registryPressure?.cooldownUntilMs ?? 0) > Date.now();
-  const registryPressureElevated = (bundle.registryPressure?.activeChallenges ?? 0) > 0 || (bundle.registryPressure?.recentChallengeRatio ?? 0) >= 0.5 || (bundle.registryPressure?.recentRateLimitRatio ?? 0) >= 0.5;
-  const stopConditions = [
-    "manager_verification_clears_blocker",
-    "policy_gate_denies_next_action",
-    "human_boundary_detected",
-    "no_progress_budget_exhausted"
-  ];
-  const { mode, standDownReason } = gate.resolvedPolicy;
-  if (mode === "off") {
-    return buildDecision(
-      config,
-      "defer",
-      "Challenge automation mode is off; challenge handling is detect-and-report only.",
-      [],
-      "light",
-      [standDownReason ?? "challenge_automation_off"]
-    );
-  }
-  if (capabilityMatrix.mustDefer) {
-    return buildDecision(
-      config,
-      "defer",
-      "Current policy or blocker state requires deferral before further automation.",
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      ["policy_blocked_or_clear_state"]
-    );
-  }
-  if (registryCooldownActive && !capabilityMatrix.canReuseExistingSession && !capabilityMatrix.canReuseCookies && !capabilityMatrix.canNavigateToAuth) {
-    return buildDecision(
-      config,
-      "defer",
-      "Registry cooldown is still active and no legitimate continuity or auth-navigation lane is currently available.",
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      ["registry_cooldown_active"]
-    );
-  }
-  if (capabilityMatrix.canUseOwnedEnvironmentFixture) {
-    return buildDecision(
-      config,
-      "owned_environment_fixture",
-      "Owned-environment fixture detected and explicitly allowlisted.",
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      stopConditions,
-      "owned_environment_fixture"
-    );
-  }
-  if (capabilityMatrix.mustYield) {
-    return buildDecision(
-      config,
-      "human_yield",
-      `Human authority boundary reached: ${interpretation.humanBoundary}.`,
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      [...stopConditions, "human_authority_required"]
-    );
+// src/challenges/governed-adapter-gateway.ts
+var evaluateGovernedLane = (config, request) => {
+  if (config.mode === "off") {
+    return {
+      status: "blocked",
+      lane: request.lane,
+      reason: "Challenge automation mode is off.",
+      auditMetadata: {}
+    };
   }
-  if (capabilityMatrix.canNavigateToAuth || capabilityMatrix.canReuseExistingSession || capabilityMatrix.canReuseCookies || capabilityMatrix.canFillNonSecretFields || capabilityMatrix.canExploreClicks) {
-    return buildDecision(
-      config,
-      "generic_browser_autonomy",
-      registryPressureElevated ? "Registry pressure is elevated, but legitimate browser continuity remains available for one bounded generic autonomy pass." : "Existing browser controls can attempt bounded auth navigation, session reuse, non-secret fill, or interaction exploration.",
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      registryPressureElevated ? [...stopConditions, "registry_pressure_elevated"] : stopConditions
-    );
+  switch (request.lane) {
+    case "owned_environment_fixture":
+      if (!config.governed.allowOwnedEnvironmentFixtures) {
+        return {
+          status: "blocked",
+          lane: request.lane,
+          reason: "Owned-environment fixtures are disabled by policy.",
+          auditMetadata: {}
+        };
+      }
+      return runOwnedEnvironmentLane(request);
+    case "sanctioned_identity":
+      if (!config.governed.allowSanctionedIdentity) {
+        return {
+          status: "blocked",
+          lane: request.lane,
+          reason: "Sanctioned identity is disabled by policy.",
+          auditMetadata: {}
+        };
+      }
+      return runSanctionedIdentityLane(request);
+    case "service_adapter":
+      if (!config.governed.allowServiceAdapters) {
+        return {
+          status: "blocked",
+          lane: request.lane,
+          reason: "Service adapters are disabled by policy.",
+          auditMetadata: {}
+        };
+      }
+      return runServiceAdapterLane(request);
   }
-  if (capabilityMatrix.canUseComputerUseBridge) {
-    return buildDecision(
-      config,
-      "optional_computer_use_bridge",
-      "DOM-native autonomy is exhausted, but the optional browser-scoped bridge is enabled.",
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      stopConditions
-    );
+};
+
+// src/challenges/outcome-recorder.ts
+var MAX_RECORDS_PER_CHALLENGE = 25;
+var OutcomeRecorder = class {
+  records = /* @__PURE__ */ new Map();
+  record(record) {
+    const key = record.challengeId ?? "__untracked__";
+    const existing = this.records.get(key) ?? [];
+    const next = [...existing, record].slice(-MAX_RECORDS_PER_CHALLENGE);
+    this.records.set(key, next);
   }
-  if (capabilityMatrix.canUseSanctionedIdentity) {
-    return buildDecision(
-      config,
-      "sanctioned_identity",
-      "Sanctioned identity lane is enabled and generic browser autonomy is insufficient.",
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      stopConditions,
-      "sanctioned_identity"
-    );
+  latest(challengeId) {
+    if (!challengeId) return void 0;
+    const entries = this.records.get(challengeId);
+    return entries?.[entries.length - 1];
   }
-  if (capabilityMatrix.canUseServiceAdapter) {
-    return buildDecision(
-      config,
-      "service_adapter",
-      "Governed service-adapter lane is enabled as the last non-human option.",
-      gate.allowedActions,
-      interpretation.requiredVerification,
-      stopConditions,
-      "service_adapter"
-    );
+  read(challengeId) {
+    if (!challengeId) return [];
+    return [...this.records.get(challengeId) ?? []];
   }
-  return buildDecision(
-    config,
-    "human_yield",
-    `No legitimate autonomous lane remains after applying policy and continuity checks. ${capabilityMatrix.helperEligibility.reason}`,
-    gate.allowedActions,
-    interpretation.requiredVerification,
-    [...stopConditions, "no_legitimate_lane_remaining"]
-  );
 };
 
 // src/challenges/orchestrator.ts
@@ -2999,25 +3263,7 @@ var ChallengeOrchestrator = class {
     return this.recorder;
   }
   async captureEvidence(args) {
-    const status = await args.handle.status(args.sessionId);
-    const effectiveTargetId = status.activeTargetId ?? args.targetId ?? null;
-    const snapshot = await args.handle.snapshot(args.sessionId, "actionables", 2400, void 0, effectiveTargetId);
-    const debugTrace = await args.handle.debugTraceSnapshot(args.sessionId, { max: 50 });
-    const cookies = status.url ? await args.handle.cookieList(args.sessionId, [status.url]) : { count: 0 };
-    return buildChallengeEvidenceBundle({
-      status,
-      snapshot: {
-        snapshotId: snapshot.snapshotId,
-        content: snapshot.content,
-        warnings: snapshot.warnings
-      },
-      debugTrace,
-      cookieCount: cookies.count,
-      canImportCookies: args.canImportCookies,
-      fallbackDisposition: args.fallbackDisposition,
-      registryPressure: args.registryPressure,
-      taskData: args.taskData
-    });
+    return captureChallengeEvidence(args);
   }
   async orchestrate(args) {
     const bundle = await this.captureEvidence({
@@ -3204,6 +3450,7 @@ var ChallengeOrchestrator = class {
       targetId: args.targetId,
       initialBundle: bundle,
       decision,
+      helperEligibility: capabilityMatrix.helperEligibility,
       config: this.config,
       suggestedSteps
     });
@@ -3366,6 +3613,20 @@ var fallbackDispositionMessage = (fallback, url) => {
 var toProviderFallbackError = (args) => {
   const { fallback } = args;
   const reasonCode = fallback.reasonCode;
+  const details = {
+    url: args.url,
+    disposition: fallback.disposition,
+    ...fallback.mode ? { browserFallbackMode: fallback.mode } : {},
+    ...fallback.challenge ? { challenge: toJsonRecord(fallback.challenge) } : {},
+    ...fallback.preservedSessionId ? { preservedSessionId: fallback.preservedSessionId } : {},
+    ...fallback.preservedTargetId ? { preservedTargetId: fallback.preservedTargetId } : {},
+    ...toJsonRecord(fallback.details ?? {})
+  };
+  const hint = readProviderIssueHint({
+    reasonCode,
+    details
+  });
+  const guidance = hint ? buildProviderIssueGuidance({ provider: args.provider, hint, details }) : void 0;
   return new ProviderRuntimeError(
     providerErrorCodeFromReasonCode(reasonCode),
     fallbackDispositionMessage(fallback, args.url),
@@ -3374,15 +3635,7 @@ var toProviderFallbackError = (args) => {
       source: args.source,
       retryable: reasonCode === "rate_limited",
       reasonCode,
-      details: {
-        url: args.url,
-        disposition: fallback.disposition,
-        ...fallback.mode ? { browserFallbackMode: fallback.mode } : {},
-        ...fallback.challenge ? { challenge: toJsonRecord(fallback.challenge) } : {},
-        ...fallback.preservedSessionId ? { preservedSessionId: fallback.preservedSessionId } : {},
-        ...fallback.preservedTargetId ? { preservedTargetId: fallback.preservedTargetId } : {},
-        ...toJsonRecord(fallback.details ?? {})
-      }
+      details: guidance ? { ...details, guidance } : details
     }
   );
 };
@@ -9173,7 +9426,7 @@ var isJsonRecord = (value) => typeof value === "object" && value !== null && !Ar
 var isWorkflowStage = (value) => value === "compile" || value === "execute" || value === "postprocess" || value === "resume";
 var isWorkflowCheckpoint = (value) => isJsonRecord(value) && isWorkflowStage(value.stage) && (value.stepId === void 0 || typeof value.stepId === "string") && (value.stepIndex === void 0 || typeof value.stepIndex === "number") && (value.state === void 0 || isJsonRecord(value.state)) && (value.updatedAt === void 0 || typeof value.updatedAt === "string");
 var isWorkflowTraceEntry = (value) => isJsonRecord(value) && typeof value.at === "string" && isWorkflowStage(value.stage) && typeof value.event === "string" && (value.details === void 0 || isJsonRecord(value.details));
-var isWorkflowKind = (value) => value === "research" || value === "shopping" || value === "product_video";
+var isWorkflowKind = (value) => value === "research" || value === "shopping" || value === "product_video" || value === "inspiredesign";
 var buildWorkflowResumeEnvelope = (kind, input, options = {}) => ({
   kind,
   input,
@@ -9184,7 +9437,7 @@ var isWorkflowResumeEnvelope = (value) => isJsonRecord(value) && isWorkflowKind(
 var isWorkflowResumePayload = (value) => isJsonRecord(value) && isWorkflowResumeEnvelope(value.workflow);
 
 // src/providers/workflows.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 
 // src/providers/artifacts.ts
 import { mkdir, readdir as readdir2, readFile, rm as rm2, stat, writeFile } from "fs/promises";
@@ -9483,6 +9736,46 @@ var enrichResearchRecords = (records, timebox, now = /* @__PURE__ */ new Date())
   return records.map((record) => toResearchRecord(record, timebox, now));
 };
 
+// src/inspiredesign/handoff.ts
+var INSPIREDESIGN_HANDOFF_FILES = {
+  designMarkdown: "design.md",
+  designContract: "design-contract.json",
+  canvasPlanRequest: "canvas-plan.request.json",
+  designAgentHandoff: "design-agent-handoff.json",
+  generationPlan: "generation-plan.json",
+  implementationPlanMarkdown: "implementation-plan.md",
+  implementationPlan: "implementation-plan.json",
+  evidence: "evidence.json",
+  prototypeGuidance: "prototype-guidance.md"
+};
+var INSPIREDESIGN_HANDOFF_SKILLS = {
+  bestPractices: {
+    name: "opendevbrowser-best-practices",
+    topic: "quick start"
+  },
+  designAgent: {
+    name: "opendevbrowser-design-agent",
+    topic: "canvas-contract"
+  }
+};
+var formatSkillReference = (skill) => `${skill.name} "${skill.topic}"`;
+var formatSkillLoadCommand = (skill) => `opendevbrowser_skill_load ${skill.name} "${skill.topic}"`;
+var INSPIREDESIGN_HANDOFF_COMMANDS = {
+  loadBestPractices: formatSkillLoadCommand(INSPIREDESIGN_HANDOFF_SKILLS.bestPractices),
+  loadDesignAgent: formatSkillLoadCommand(INSPIREDESIGN_HANDOFF_SKILLS.designAgent),
+  continueInCanvas: `opendevbrowser canvas --command canvas.plan.set --params-file ./${INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest}`
+};
+var INSPIREDESIGN_HANDOFF_RECOMMENDED_SKILLS = [
+  formatSkillReference(INSPIREDESIGN_HANDOFF_SKILLS.bestPractices),
+  formatSkillReference(INSPIREDESIGN_HANDOFF_SKILLS.designAgent)
+];
+var INSPIREDESIGN_HANDOFF_GUIDANCE = {
+  prepareCanvasPlanRequest: `Fill canvasSessionId, leaseId, and documentId in ${INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest} before running ${INSPIREDESIGN_HANDOFF_COMMANDS.continueInCanvas}.`,
+  deepCaptureRecommendation: "Rerun inspiredesign with captureMode=deep only when you need richer evidence for visual hierarchy, protected references, or capture-specific debugging."
+};
+var buildInspiredesignFollowthroughSummary = () => `Continue in OpenDevBrowser Canvas with ${INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest} and ${INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff}, load ${INSPIREDESIGN_HANDOFF_RECOMMENDED_SKILLS[0]} plus ${INSPIREDESIGN_HANDOFF_RECOMMENDED_SKILLS[1]} before implementation, and rerun with captureMode=deep only when you need richer evidence.`;
+var buildInspiredesignNextStep = () => `${INSPIREDESIGN_HANDOFF_GUIDANCE.prepareCanvasPlanRequest} Then run ${INSPIREDESIGN_HANDOFF_COMMANDS.continueInCanvas}, confirm planStatus=accepted, then patch only the governance blocks listed in ${INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff}.`;
+
 // src/providers/renderer.ts
 var toCurrency = (value) => `$${value.toFixed(2)}`;
 var primaryConstraintSummaryFromMeta = (meta) => {
@@ -9517,22 +9810,225 @@ var renderResearch = (args) => {
     "```"
   ].join("\n");
   const contextPayload = {
-    topic: args.topic,
-    highlights: lines,
-    records: args.records,
+    topic: args.topic,
+    highlights: lines,
+    records: args.records,
+    meta: args.meta
+  };
+  const files = [
+    { path: "summary.md", content: markdown },
+    { path: "records.json", content: { records: args.records } },
+    { path: "context.json", content: contextPayload },
+    { path: "meta.json", content: args.meta }
+  ];
+  if (args.mode === "compact") {
+    return {
+      response: {
+        mode: args.mode,
+        summary,
+        meta: args.meta
+      },
+      files
+    };
+  }
+  if (args.mode === "json") {
+    return {
+      response: {
+        mode: args.mode,
+        records: args.records,
+        meta: args.meta
+      },
+      files
+    };
+  }
+  if (args.mode === "md") {
+    return {
+      response: {
+        mode: args.mode,
+        markdown,
+        meta: args.meta
+      },
+      files
+    };
+  }
+  if (args.mode === "context") {
+    return {
+      response: {
+        mode: args.mode,
+        context: contextPayload,
+        meta: args.meta
+      },
+      files
+    };
+  }
+  return {
+    response: {
+      mode: "path",
+      meta: args.meta
+    },
+    files
+  };
+};
+var toComparisonCsv = (offers) => {
+  const header = ["provider", "title", "price", "shipping", "deal_score", "availability", "url"].join(",");
+  const rows = offers.map((offer) => {
+    return [
+      offer.provider,
+      JSON.stringify(offer.title),
+      offer.price.amount.toFixed(2),
+      offer.shipping.amount.toFixed(2),
+      offer.deal_score.toFixed(4),
+      offer.availability,
+      canonicalizeUrl(offer.url)
+    ].join(",");
+  });
+  return [header, ...rows].join("\n");
+};
+var compactShoppingLines = (offers, meta) => {
+  if (offers.length === 0) {
+    const summary = primaryConstraintSummaryFromMeta(meta);
+    return summary ? [
+      "No offers available from the selected providers.",
+      `Primary constraint: ${summary}`
+    ] : ["No offers available from the selected providers."];
+  }
+  return offers.slice(0, 10).map((offer, index) => {
+    const total = offer.price.amount + offer.shipping.amount;
+    return `${index + 1}. ${offer.title} - ${toCurrency(total)} (${offer.provider}, deal=${offer.deal_score.toFixed(2)})`;
+  });
+};
+var renderShopping = (args) => {
+  const lines = compactShoppingLines(args.offers, args.meta);
+  const markdown = [
+    `# Shopping: ${args.query}`,
+    "",
+    ...lines,
+    "",
+    "## Metadata",
+    "```json",
+    JSON.stringify(args.meta, null, 2),
+    "```"
+  ].join("\n");
+  const comparisonCsv = toComparisonCsv(args.offers);
+  const contextPayload = {
+    query: args.query,
+    highlights: lines,
+    offers: args.offers,
+    meta: args.meta
+  };
+  const files = [
+    { path: "deals.md", content: markdown },
+    { path: "offers.json", content: { offers: args.offers } },
+    { path: "comparison.csv", content: comparisonCsv },
+    { path: "meta.json", content: args.meta },
+    { path: "deals-context.json", content: contextPayload }
+  ];
+  if (args.mode === "compact") {
+    return {
+      response: {
+        mode: args.mode,
+        summary: lines.join("\n"),
+        meta: args.meta
+      },
+      files
+    };
+  }
+  if (args.mode === "json") {
+    return {
+      response: {
+        mode: args.mode,
+        offers: args.offers,
+        meta: args.meta
+      },
+      files
+    };
+  }
+  if (args.mode === "md") {
+    return {
+      response: {
+        mode: args.mode,
+        markdown,
+        meta: args.meta
+      },
+      files
+    };
+  }
+  if (args.mode === "context") {
+    return {
+      response: {
+        mode: args.mode,
+        context: contextPayload,
+        meta: args.meta
+      },
+      files
+    };
+  }
+  return {
+    response: {
+      mode: "path",
+      meta: args.meta
+    },
+    files
+  };
+};
+var renderInspiredesign = (args) => {
+  const summary = [
+    `Brief: ${args.brief}`,
+    `References: ${args.urls.length}`,
+    `Profile: ${args.generationPlan.visualDirection.profile}`
+  ].join("\n");
+  const contextPayload = {
+    brief: args.brief,
+    urls: args.urls,
+    designContract: args.designContract,
+    canvasPlanRequest: args.canvasPlanRequest,
+    designAgentHandoff: args.designAgentHandoff,
+    generationPlan: args.generationPlan,
+    implementationPlan: args.implementationPlan,
+    designMarkdown: args.designMarkdown,
+    implementationPlanMarkdown: args.implementationPlanMarkdown,
+    prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+    evidence: args.evidence,
     meta: args.meta
   };
+  const suggestedSteps = [
+    {
+      reason: "Load the baseline workflow runbook before implementation.",
+      command: args.designAgentHandoff.commandExamples.loadBestPractices
+    },
+    {
+      reason: "Load the Canvas contract lane before patching.",
+      command: args.designAgentHandoff.commandExamples.loadDesignAgent
+    },
+    {
+      reason: INSPIREDESIGN_HANDOFF_GUIDANCE.prepareCanvasPlanRequest,
+      command: args.designAgentHandoff.commandExamples.continueInCanvas
+    },
+    {
+      reason: args.designAgentHandoff.deepCaptureRecommendation
+    }
+  ];
   const files = [
-    { path: "summary.md", content: markdown },
-    { path: "records.json", content: { records: args.records } },
-    { path: "context.json", content: contextPayload },
-    { path: "meta.json", content: args.meta }
+    { path: INSPIREDESIGN_HANDOFF_FILES.designMarkdown, content: args.designMarkdown },
+    { path: INSPIREDESIGN_HANDOFF_FILES.designContract, content: args.designContract },
+    { path: INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest, content: args.canvasPlanRequest },
+    { path: INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff, content: args.designAgentHandoff },
+    { path: INSPIREDESIGN_HANDOFF_FILES.generationPlan, content: args.generationPlan },
+    { path: INSPIREDESIGN_HANDOFF_FILES.implementationPlanMarkdown, content: args.implementationPlanMarkdown },
+    { path: INSPIREDESIGN_HANDOFF_FILES.implementationPlan, content: args.implementationPlan },
+    { path: INSPIREDESIGN_HANDOFF_FILES.evidence, content: args.evidence }
   ];
+  if (args.prototypeGuidanceMarkdown) {
+    files.push({ path: INSPIREDESIGN_HANDOFF_FILES.prototypeGuidance, content: args.prototypeGuidanceMarkdown });
+  }
   if (args.mode === "compact") {
     return {
       response: {
         mode: args.mode,
         summary,
+        followthroughSummary: args.designAgentHandoff.summary,
+        suggestedNextAction: args.designAgentHandoff.nextStep,
+        suggestedSteps,
         meta: args.meta
       },
       files
@@ -9542,7 +10038,18 @@ var renderResearch = (args) => {
     return {
       response: {
         mode: args.mode,
-        records: args.records,
+        brief: args.brief,
+        urls: args.urls,
+        canvasPlanRequest: args.canvasPlanRequest,
+        designAgentHandoff: args.designAgentHandoff,
+        designContract: args.designContract,
+        generationPlan: args.generationPlan,
+        implementationPlan: args.implementationPlan,
+        prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+        evidence: args.evidence,
+        followthroughSummary: args.designAgentHandoff.summary,
+        suggestedNextAction: args.designAgentHandoff.nextStep,
+        suggestedSteps,
         meta: args.meta
       },
       files
@@ -9552,7 +10059,12 @@ var renderResearch = (args) => {
     return {
       response: {
         mode: args.mode,
-        markdown,
+        markdown: args.designMarkdown,
+        implementationPlanMarkdown: args.implementationPlanMarkdown,
+        prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+        followthroughSummary: args.designAgentHandoff.summary,
+        suggestedNextAction: args.designAgentHandoff.nextStep,
+        suggestedSteps,
         meta: args.meta
       },
       files
@@ -9563,6 +10075,9 @@ var renderResearch = (args) => {
       response: {
         mode: args.mode,
         context: contextPayload,
+        followthroughSummary: args.designAgentHandoff.summary,
+        suggestedNextAction: args.designAgentHandoff.nextStep,
+        suggestedSteps,
         meta: args.meta
       },
       files
@@ -9571,116 +10086,1209 @@ var renderResearch = (args) => {
   return {
     response: {
       mode: "path",
+      followthroughSummary: args.designAgentHandoff.summary,
+      suggestedNextAction: args.designAgentHandoff.nextStep,
+      suggestedSteps,
       meta: args.meta
     },
     files
   };
 };
-var toComparisonCsv = (offers) => {
-  const header = ["provider", "title", "price", "shipping", "deal_score", "availability", "url"].join(",");
-  const rows = offers.map((offer) => {
-    return [
-      offer.provider,
-      JSON.stringify(offer.title),
-      offer.price.amount.toFixed(2),
-      offer.shipping.amount.toFixed(2),
-      offer.deal_score.toFixed(4),
-      offer.availability,
-      canonicalizeUrl(offer.url)
-    ].join(",");
-  });
-  return [header, ...rows].join("\n");
+
+// src/providers/inspiredesign-contract.ts
+import { createHash as createHash3 } from "crypto";
+
+// skills/opendevbrowser-design-agent/assets/templates/canvas-generation-plan.design.v1.json
+var canvas_generation_plan_design_v1_default = {
+  requestId: "req_plan_design_01",
+  canvasSessionId: "<canvas-session-id>",
+  leaseId: "<lease-id>",
+  documentId: "<document-id>",
+  generationPlan: {
+    targetOutcome: {
+      mode: "high-fi-live-edit",
+      summary: "Clarify hierarchy, trust, and action flow"
+    },
+    visualDirection: {
+      profile: "product-story",
+      themeStrategy: "single-theme"
+    },
+    layoutStrategy: {
+      approach: "hero-led-grid",
+      navigationModel: "global-header"
+    },
+    contentStrategy: {
+      source: "real-content-first"
+    },
+    componentStrategy: {
+      mode: "reuse-first",
+      interactionStates: [
+        "default",
+        "hover",
+        "focus",
+        "disabled"
+      ]
+    },
+    motionPosture: {
+      level: "subtle",
+      reducedMotion: "respect-user-preference"
+    },
+    responsivePosture: {
+      primaryViewport: "desktop",
+      requiredViewports: [
+        "desktop",
+        "tablet",
+        "mobile"
+      ]
+    },
+    accessibilityPosture: {
+      target: "WCAG_2_2_AA",
+      keyboardNavigation: "full"
+    },
+    validationTargets: {
+      blockOn: [
+        "contrast-failure",
+        "responsive-mismatch"
+      ],
+      requiredThemes: [
+        "light"
+      ],
+      browserValidation: "required",
+      maxInteractionLatencyMs: 160
+    }
+  }
 };
-var compactShoppingLines = (offers, meta) => {
-  if (offers.length === 0) {
-    const summary = primaryConstraintSummaryFromMeta(meta);
-    return summary ? [
-      "No offers available from the selected providers.",
-      `Primary constraint: ${summary}`
-    ] : ["No offers available from the selected providers."];
+
+// skills/opendevbrowser-design-agent/assets/templates/design-contract.v1.json
+var design_contract_v1_default = {
+  intent: {
+    audience: "Operators evaluating a new OpenDevBrowser design flow",
+    task: "Understand the primary page value and complete the intended action quickly",
+    successCriteria: [
+      "Primary action is obvious within 5 seconds",
+      "Layout remains coherent on desktop, tablet, and mobile"
+    ],
+    trustPosture: "clear and confident"
+  },
+  designLanguage: {
+    direction: "product-led clarity",
+    styleAxes: {
+      contrast: "high",
+      density: "airy",
+      shapeLanguage: "rounded-structured",
+      depth: "subtle",
+      texture: "minimal",
+      motion: "purposeful"
+    },
+    approvedLibraries: {
+      components: [
+        "shadcn"
+      ],
+      icons: [
+        "tabler"
+      ],
+      styling: [
+        "tailwindcss"
+      ]
+    },
+    semanticTokenSource: {
+      owner: "app-shell theme provider",
+      tokens: [
+        "color",
+        "typography",
+        "spacing",
+        "radius",
+        "shadow",
+        "motion"
+      ],
+      rule: "Use semantic tokens in repeated UI; reserve raw values for rare one-off illustration"
+    }
+  },
+  contentModel: {
+    primaryMessage: "Show the core value immediately with real copy",
+    supportingMessages: [
+      "Reinforce trust",
+      "Clarify the primary action",
+      "Reduce ambiguity"
+    ],
+    realContentRequired: true,
+    states: [
+      "default",
+      "hover",
+      "focus",
+      "empty",
+      "loading",
+      "success",
+      "error"
+    ],
+    loadingStrategy: "Preserve the final layout with 3-6 placeholders or one section-level loader when structure cannot be previewed",
+    emptyStateStrategy: "Explain why nothing is shown and provide the next useful action",
+    errorStateStrategy: "Keep retry or recovery actions close to the failed region",
+    transientFeedbackStrategy: "Use short, non-blocking overlays for confirmations instead of reflowing the main layout",
+    avoidPlaceholderCopy: true
+  },
+  navigationModel: {
+    owner: "feature shell route controller",
+    primaryRouteModel: "One canonical route map translates tabs, selected records, and editor modes into URL-backed state",
+    deepLinkPolicy: "Shareable tabs, filters, sort, and selected entities stay in the URL with a safe fallback when params are stale or incomplete",
+    invalidRouteFallback: "Recover to the closest safe baseline view instead of leaving the screen in a partially initialized state",
+    overlayEntryPoints: [
+      "route-owned detail drawer",
+      "feature-owned confirmation modal"
+    ]
+  },
+  asyncModel: {
+    owner: "feature-local controller with URL-owned query state when sharing or refresh matters",
+    loadTrigger: "load-on-enter for the first view; debounced restart on query, scope, or sort change",
+    restartTriggers: [
+      "query",
+      "scope",
+      "sort"
+    ],
+    debounceMs: 250,
+    emptyQueryBehavior: "Reset to the baseline or empty state without a remote fetch unless the product explicitly needs default results",
+    cancellationPolicy: "Treat stale requests as normal and do not surface cancellation as a user-facing error",
+    moveToServiceWhen: [
+      "work must survive dismissal",
+      "caching or retry policy becomes shared",
+      "multiple screens depend on the same in-flight state"
+    ],
+    urlOwnership: "Put query, filter, and sort in the URL when the state should survive refresh, sharing, or handoff"
+  },
+  layoutSystem: {
+    grid: "12-column responsive grid",
+    containers: "max-width sections with asymmetric emphasis",
+    spacingRhythm: "8px base with larger section jumps",
+    alignmentRules: [
+      "Primary content aligns to a consistent reading column",
+      "Actions stay near the message they complete"
+    ]
+  },
+  typographySystem: {
+    families: [
+      "Space Grotesk",
+      "Source Sans 3"
+    ],
+    scale: [
+      "12",
+      "14",
+      "16",
+      "20",
+      "28",
+      "40",
+      "56"
+    ],
+    measure: "60-72 characters for dense reading blocks",
+    fallbackPolicy: "Use repo-native or licensed alternatives when these families are unavailable",
+    loadingStrategy: "Avoid layout shift and keep fallback metrics close"
+  },
+  motionSystem: {
+    timing: "short and decisive",
+    reducedMotionPolicy: "Preserve meaning with reduced movement",
+    interactionMoments: [
+      "page entry",
+      "section reveal",
+      "primary CTA feedback"
+    ],
+    parallaxPolicy: "off unless explicitly justified"
+  },
+  performanceModel: {
+    renderHotspots: [
+      "scan-heavy collection region",
+      "secondary inspector or preview pane"
+    ],
+    stableIdentityPolicy: "Rows, cards, tabs, and overlays use stable domain ids instead of array indexes",
+    listStrategy: "Use the smallest structure that stays fast with realistic data; choose progressive reveal, lazy containers, or virtualization deliberately",
+    secondaryPanelPolicy: "Heavy inspectors, previews, and editors load on demand when they are not required for first paint",
+    measurementPlan: "Validate realistic data volume with browser traces and the framework profiler before claiming the surface is performant"
+  },
+  responsiveSystem: {
+    breakpoints: [
+      "mobile",
+      "tablet",
+      "desktop"
+    ],
+    adaptationRules: [
+      "Collapse multicolumn sections before copy becomes cramped",
+      "Preserve primary CTA prominence on the smallest viewport"
+    ],
+    touchPolicy: "Comfortable targets and low-friction scroll paths",
+    overflowPolicy: "No horizontal scroll for primary content"
+  },
+  accessibilityPolicy: {
+    target: "WCAG 2.2 AA",
+    keyboardRequirements: [
+      "Visible focus",
+      "Logical tab order"
+    ],
+    focusPolicy: "Focus rings must remain visible against every background",
+    semanticRequirements: [
+      "Landmarks are explicit",
+      "Headings remain hierarchical"
+    ]
+  },
+  generationPlan: {
+    targetOutcome: {
+      mode: "high-fi-live-edit",
+      summary: "Improve hierarchy, clarity, and conversion confidence"
+    },
+    visualDirection: {
+      profile: "product-led-clarity",
+      styleAxes: {
+        contrast: "high",
+        density: "airy"
+      }
+    },
+    layoutStrategy: {
+      approach: "hero-led-grid"
+    },
+    contentStrategy: {
+      source: "real-content-first"
+    },
+    componentStrategy: {
+      mode: "reuse-first",
+      approvedLibraries: [
+        "shadcn"
+      ]
+    },
+    motionPosture: {
+      level: "subtle",
+      allow3D: false,
+      allowParallax: false,
+      allowCustomSmoothScroll: false
+    },
+    responsivePosture: {
+      primaryViewport: "desktop",
+      requiredViewports: [
+        "desktop",
+        "tablet",
+        "mobile"
+      ]
+    },
+    accessibilityPosture: {
+      target: "WCAG_2_2_AA",
+      reducedMotion: "required",
+      keyboardParity: true
+    },
+    validationTargets: {
+      blockOn: [
+        "contrast-failure",
+        "keyboard-regression",
+        "stale-search-results",
+        "invalid-route-recovery-failure"
+      ],
+      warnOn: [
+        "responsive-mismatch",
+        "layout-shift",
+        "spinner-stacking",
+        "scan-surface-jank"
+      ]
+    }
   }
-  return offers.slice(0, 10).map((offer, index) => {
-    const total = offer.price.amount + offer.shipping.amount;
-    return `${index + 1}. ${offer.title} - ${toCurrency(total)} (${offer.provider}, deal=${offer.deal_score.toFixed(2)})`;
-  });
 };
-var renderShopping = (args) => {
-  const lines = compactShoppingLines(args.offers, args.meta);
-  const markdown = [
-    `# Shopping: ${args.query}`,
+
+// src/providers/inspiredesign-contract.ts
+var BASE_CONTRACT_TEMPLATE = design_contract_v1_default;
+var BASE_PLAN_REQUEST_TEMPLATE = canvas_generation_plan_design_v1_default;
+var BASE_GENERATION_PLAN = BASE_PLAN_REQUEST_TEMPLATE.generationPlan;
+var PROFILE_MATCHERS = [
+  { profile: "auth-focused", keywords: ["auth", "login", "signin", "sign-in", "signup", "sign-up", "onboarding"] },
+  { profile: "settings-system", keywords: ["settings", "preferences", "account", "profile", "billing"] },
+  { profile: "ops-control", keywords: ["dashboard", "admin", "control", "analytics", "monitor", "reporting"] },
+  { profile: "documentation", keywords: ["docs", "documentation", "knowledge base", "reference", "guide"] },
+  { profile: "commerce-system", keywords: ["shop", "commerce", "pricing", "checkout", "product page", "catalog"] }
+];
+var PROFILE_CONFIG = {
+  "clean-room": {
+    direction: "clean-room execution",
+    visualPersonality: "disciplined, quiet, system-first",
+    brandTone: "neutral and exacting",
+    hierarchyPrinciples: ["Keep one message per section.", "Use spacing, not ornament, to separate priority."],
+    interactionPhilosophy: "Minimal motion, zero ambiguity, strong focus affordances.",
+    navigationModel: "contextual",
+    layoutApproach: "modular-grid",
+    pagePatterns: ["Single-message hero", "Dense decision panel", "Clean spec sheet"],
+    componentSequence: ["Buttons", "Inputs", "Decision cards", "Structured tables"],
+    colors: {
+      primary: "#0F172A",
+      accent: "#0F766E",
+      accentSurface: "#E6FFFB",
+      background: "#F8FAFC",
+      surface: "#FFFFFF",
+      border: "#CBD5E1",
+      text: "#0F172A",
+      mutedText: "#475569",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "cinematic-minimal": {
+    direction: "cinematic restraint",
+    visualPersonality: "dramatic, sparse, image-led",
+    brandTone: "premium and deliberate",
+    hierarchyPrinciples: ["Let the visual plane carry atmosphere.", "Keep copy short and decisive."],
+    interactionPhilosophy: "Use motion for presence, not explanation.",
+    navigationModel: "immersive",
+    layoutApproach: "full-bleed-hero",
+    pagePatterns: ["Full-bleed hero", "Editorial feature strip", "High-contrast CTA block"],
+    componentSequence: ["Hero shell", "CTA buttons", "Image-led sections", "Minimal footer"],
+    colors: {
+      primary: "#111827",
+      accent: "#C2410C",
+      accentSurface: "#FFF7ED",
+      background: "#F8F5F0",
+      surface: "#FFFFFF",
+      border: "#D6D3D1",
+      text: "#111827",
+      mutedText: "#57534E",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "product-story": {
+    direction: "product-led clarity",
+    visualPersonality: "confident, editorial, product-first",
+    brandTone: "clear and ambitious",
+    hierarchyPrinciples: ["Lead with value before proof.", "Keep action close to the message it completes."],
+    interactionPhilosophy: "Short, decisive motion with obvious focus states.",
+    navigationModel: "global-header",
+    layoutApproach: "hero-led-grid",
+    pagePatterns: ["Hero with anchored CTA", "Feature narrative strip", "Proof and conversion band"],
+    componentSequence: ["Hero", "Buttons", "Cards", "Feature sections", "Footer"],
+    colors: {
+      primary: "#0B6BFF",
+      accent: "#F97316",
+      accentSurface: "#FFF7ED",
+      background: "#F5F7FB",
+      surface: "#FFFFFF",
+      border: "#D7E3F4",
+      text: "#111827",
+      mutedText: "#475569",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "commerce-system": {
+    direction: "trust-driven commerce",
+    visualPersonality: "decisive, reassuring, conversion-aware",
+    brandTone: "credible and practical",
+    hierarchyPrinciples: ["Keep purchasing signals scannable.", "Surface trust proof before commitment moments."],
+    interactionPhilosophy: "Fast feedback, strong affordances, no ambiguous states.",
+    navigationModel: "global-header",
+    layoutApproach: "commerce-grid",
+    pagePatterns: ["Merchandising hero", "Offer comparison band", "Decision-support detail section"],
+    componentSequence: ["Hero", "Offer cards", "Buttons", "Trust badges", "Comparison table"],
+    colors: {
+      primary: "#0F766E",
+      accent: "#D97706",
+      accentSurface: "#FFFBEB",
+      background: "#F8FAFC",
+      surface: "#FFFFFF",
+      border: "#D1D5DB",
+      text: "#111827",
+      mutedText: "#4B5563",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "control-room": {
+    direction: "high-signal control room",
+    visualPersonality: "dense, sharp, operational",
+    brandTone: "authoritative and fast",
+    hierarchyPrinciples: ["Use structure to reduce scanning cost.", "Separate primary metrics from diagnostics."],
+    interactionPhilosophy: "Fast updates, explicit states, motion only when it clarifies change.",
+    navigationModel: "sidebar",
+    layoutApproach: "panel-grid",
+    pagePatterns: ["Metric summary rail", "Split-pane workspace", "Diagnostic detail panel"],
+    componentSequence: ["Sidebar", "Stat blocks", "Tables", "Filters", "Panels"],
+    colors: {
+      primary: "#155EEF",
+      accent: "#0F766E",
+      accentSurface: "#ECFDF3",
+      background: "#F8FAFC",
+      surface: "#FFFFFF",
+      border: "#CBD5E1",
+      text: "#0F172A",
+      mutedText: "#475569",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "ops-control": {
+    direction: "operational precision",
+    visualPersonality: "structured, dense, high-confidence",
+    brandTone: "decisive and exact",
+    hierarchyPrinciples: ["Pin the primary metric and action path.", "Separate overview from detail panes."],
+    interactionPhilosophy: "Low-latency controls, strong state contrast, keyboard-friendly flows.",
+    navigationModel: "sidebar",
+    layoutApproach: "workspace-shell",
+    pagePatterns: ["KPI overview bar", "Filterable data shell", "Detail drawer or inspector"],
+    componentSequence: ["Sidebar", "Toolbar", "Data table", "Filters", "Detail panel"],
+    colors: {
+      primary: "#155EEF",
+      accent: "#0891B2",
+      accentSurface: "#ECFEFF",
+      background: "#F8FAFC",
+      surface: "#FFFFFF",
+      border: "#CBD5E1",
+      text: "#0F172A",
+      mutedText: "#475569",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "auth-focused": {
+    direction: "trust-forward entry flow",
+    visualPersonality: "calm, direct, reassuring",
+    brandTone: "safe and premium",
+    hierarchyPrinciples: ["One job per screen.", "Trust and recovery paths must be visible without clutter."],
+    interactionPhilosophy: "Low-friction focus flow with immediate validation feedback.",
+    navigationModel: "contextual",
+    layoutApproach: "two-panel-auth",
+    pagePatterns: ["Auth split layout", "Trust panel", "Recovery and help strip"],
+    componentSequence: ["Auth form", "Inputs", "Buttons", "Alerts", "Trust panel"],
+    colors: {
+      primary: "#1D4ED8",
+      accent: "#0F766E",
+      accentSurface: "#ECFDF5",
+      background: "#F8FAFC",
+      surface: "#FFFFFF",
+      border: "#D1D5DB",
+      text: "#111827",
+      mutedText: "#4B5563",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "settings-system": {
+    direction: "calm settings system",
+    visualPersonality: "ordered, practical, quietly premium",
+    brandTone: "confident and low-friction",
+    hierarchyPrinciples: ["Group related decisions tightly.", "Keep destructive actions isolated and explicit."],
+    interactionPhilosophy: "Prefer clear toggles and inline explanations over hidden complexity.",
+    navigationModel: "tabbed",
+    layoutApproach: "settings-grid",
+    pagePatterns: ["Sectioned settings page", "Inline form groups", "Preference summary rail"],
+    componentSequence: ["Tabs", "Forms", "Inputs", "Alerts", "Confirmation modal"],
+    colors: {
+      primary: "#1D4ED8",
+      accent: "#0F766E",
+      accentSurface: "#ECFDF5",
+      background: "#F8FAFC",
+      surface: "#FFFFFF",
+      border: "#D1D5DB",
+      text: "#111827",
+      mutedText: "#475569",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  },
+  "documentation": {
+    direction: "reference-first documentation",
+    visualPersonality: "legible, calm, highly structured",
+    brandTone: "expert and accessible",
+    hierarchyPrinciples: ["Make scanning effortless.", "Keep code, steps, and warnings visually distinct."],
+    interactionPhilosophy: "Light motion, sticky wayfinding, strong anchor visibility.",
+    navigationModel: "sidebar",
+    layoutApproach: "docs-shell",
+    pagePatterns: ["Docs shell", "Procedure section", "Reference table block"],
+    componentSequence: ["Sidebar", "Search", "Anchored headings", "Code blocks", "Callouts"],
+    colors: {
+      primary: "#1D4ED8",
+      accent: "#0F766E",
+      accentSurface: "#ECFDF5",
+      background: "#F8FAFC",
+      surface: "#FFFFFF",
+      border: "#CBD5E1",
+      text: "#0F172A",
+      mutedText: "#475569",
+      success: "#15803D",
+      warning: "#B45309",
+      danger: "#B91C1C"
+    }
+  }
+};
+var trimText = (value) => {
+  return value.trim().replace(/\s+/g, " ");
+};
+var clipText = (value, maxLength) => {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+};
+var cloneTemplate = (value) => structuredClone(value);
+var referenceFingerprint = (value) => {
+  return createHash3("sha256").update(value).digest("hex").slice(0, 12);
+};
+var hasKeyword = (value, keywords) => {
+  const haystack = value.toLowerCase();
+  return keywords.some((keyword) => haystack.includes(keyword));
+};
+var classifyProfile = (brief, references) => {
+  const combined = [brief, ...references.map((reference) => `${reference.title ?? ""} ${reference.excerpt ?? ""}`)].join(" ").toLowerCase();
+  return PROFILE_MATCHERS.find((matcher) => hasKeyword(combined, matcher.keywords))?.profile ?? "product-story";
+};
+var resolveThemeStrategy = (brief, references) => {
+  const combined = `${brief} ${references.map((reference) => reference.excerpt ?? "").join(" ")}`.toLowerCase();
+  return combined.includes("dark") ? "light-dark-parity" : "single-theme";
+};
+var summarizeBrief = (brief) => {
+  const normalized = trimText(brief);
+  const sentence = normalized.split(/[.!?]/).map((part) => part.trim()).find(Boolean);
+  return clipText(sentence ?? normalized, 140);
+};
+var buildSupportingMessages = (references) => {
+  const messages = references.map((reference) => reference.title ?? reference.excerpt ?? "").map((value) => clipText(trimText(value), 72)).filter((value) => value.length > 0);
+  return messages.slice(0, 3);
+};
+var buildGenerationPlan = (brief, profile, references) => {
+  const plan = cloneTemplate(BASE_GENERATION_PLAN);
+  plan.targetOutcome.summary = summarizeBrief(brief);
+  plan.visualDirection.profile = profile;
+  plan.visualDirection.themeStrategy = resolveThemeStrategy(brief, references);
+  plan.layoutStrategy.approach = PROFILE_CONFIG[profile].layoutApproach;
+  plan.layoutStrategy.navigationModel = PROFILE_CONFIG[profile].navigationModel;
+  plan.componentStrategy.interactionStates = ["default", "hover", "focus", "disabled", "loading"];
+  plan.validationTargets.requiredThemes = plan.visualDirection.themeStrategy === "light-dark-parity" ? ["light", "dark"] : ["light"];
+  return plan;
+};
+var buildIntentBlock = (brief, urls, references) => {
+  const intent = cloneTemplate(BASE_CONTRACT_TEMPLATE.intent);
+  return {
+    ...intent,
+    task: summarizeBrief(brief),
+    brief,
+    briefHash: referenceFingerprint(brief),
+    referenceCount: references.length,
+    referenceUrls: urls,
+    evidenceStatus: {
+      fetched: references.filter((reference) => reference.fetchStatus === "captured").length,
+      captured: references.filter((reference) => reference.captureStatus === "captured").length
+    }
+  };
+};
+var buildDesignLanguageBlock = (profile) => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.designLanguage);
+  const config = PROFILE_CONFIG[profile];
+  return {
+    ...block,
+    direction: config.direction,
+    visualPersonality: config.visualPersonality,
+    brandTone: config.brandTone
+  };
+};
+var buildContentModelBlock = (brief, references) => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.contentModel);
+  return {
+    ...block,
+    primaryMessage: summarizeBrief(brief),
+    supportingMessages: buildSupportingMessages(references)
+  };
+};
+var buildLayoutSystemBlock = (profile) => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.layoutSystem);
+  return {
+    ...block,
+    pagePatterns: PROFILE_CONFIG[profile].pagePatterns
+  };
+};
+var buildTypographySystemBlock = () => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.typographySystem);
+  return {
+    ...block,
+    tokens: {
+      display: "56/1.0",
+      h1: "40/1.05",
+      h2: "28/1.1",
+      h3: "20/1.2",
+      body: "16/1.6",
+      label: "14/1.4",
+      caption: "12/1.4"
+    }
+  };
+};
+var buildColorSystemBlock = (profile) => {
+  const colors = PROFILE_CONFIG[profile].colors;
+  return {
+    paletteName: `${profile}-default`,
+    tokens: colors,
+    contrastRequirements: {
+      bodyText: "4.5:1",
+      largeText: "3:1",
+      focusRing: "3:1"
+    }
+  };
+};
+var buildSurfaceSystemBlock = () => ({
+  radiusScale: {
+    xs: "6px",
+    sm: "10px",
+    md: "16px",
+    lg: "24px"
+  },
+  borderPolicy: "Use 1px neutral strokes before adding elevation.",
+  shadowPolicy: {
+    sm: "0 1px 2px rgba(15, 23, 42, 0.06)",
+    md: "0 10px 30px rgba(15, 23, 42, 0.10)",
+    lg: "0 24px 60px rgba(15, 23, 42, 0.14)"
+  }
+});
+var buildIconSystemBlock = () => ({
+  family: "tabler",
+  strokeWidth: 1.5,
+  style: "rounded-linear",
+  usageRules: [
+    "Use icons to reinforce labels, not replace them.",
+    "Decorative icons should remain visually lighter than primary copy."
+  ]
+});
+var buildMotionSystemBlock = () => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.motionSystem);
+  return {
+    ...block,
+    durations: {
+      quick: "120ms",
+      standard: "180ms",
+      emphasis: "240ms"
+    }
+  };
+};
+var buildResponsiveSystemBlock = () => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.responsiveSystem);
+  return {
+    ...block,
+    breakpoints: {
+      mobile: "0-639px",
+      tablet: "640-1023px",
+      desktop: "1024px+"
+    }
+  };
+};
+var buildAccessibilityBlock = () => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.accessibilityPolicy);
+  return {
+    ...block,
+    reducedMotion: "Respect user preference and preserve information without animation."
+  };
+};
+var buildLibraryPolicyBlock = () => ({
+  components: ["shadcn"],
+  icons: ["tabler"],
+  styling: ["tailwindcss"],
+  motion: ["css"],
+  threeD: []
+});
+var buildRuntimeBudgetsBlock = (plan) => ({
+  maxHeroActions: 2,
+  maxPrimarySections: 8,
+  maxInteractionLatencyMs: plan.validationTargets.maxInteractionLatencyMs,
+  previewBudgetMs: 1500,
+  notes: [
+    "Keep above-the-fold content inside one visual composition.",
+    "Avoid heavyweight decorative animation before interaction clarity is established."
+  ]
+});
+var EMITTED_GOVERNANCE_BLOCKS = [
+  "intent",
+  "generationPlan",
+  "designLanguage",
+  "contentModel",
+  "layoutSystem",
+  "typographySystem",
+  "colorSystem",
+  "surfaceSystem",
+  "iconSystem",
+  "motionSystem",
+  "responsiveSystem",
+  "accessibilityPolicy",
+  "libraryPolicy",
+  "runtimeBudgets"
+];
+var buildNavigationModelBlock = (profile) => {
+  const block = cloneTemplate(BASE_CONTRACT_TEMPLATE.navigationModel);
+  return {
+    ...block,
+    primaryRouteModel: `Use a ${PROFILE_CONFIG[profile].navigationModel} route shell so the primary action remains stable through state changes.`
+  };
+};
+var buildAsyncModelBlock = () => {
+  return cloneTemplate(BASE_CONTRACT_TEMPLATE.asyncModel);
+};
+var buildPerformanceModelBlock = () => {
+  return cloneTemplate(BASE_CONTRACT_TEMPLATE.performanceModel);
+};
+var buildCanvasPlanRequest = (brief, generationPlan) => ({
+  ...cloneTemplate(BASE_PLAN_REQUEST_TEMPLATE),
+  requestId: `req_plan_${referenceFingerprint(brief).slice(0, 12)}`,
+  generationPlan
+});
+var buildContractScope = () => ({
+  emittedContract: "CanvasDesignGovernance",
+  emittedGovernanceBlocks: [...EMITTED_GOVERNANCE_BLOCKS],
+  omittedTemplateBlocks: ["navigationModel", "asyncModel", "performanceModel"],
+  note: `${INSPIREDESIGN_HANDOFF_FILES.designContract} is the narrowed canvas governance contract. Use ${INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff} for navigation, async, and performance context that informs implementation but does not belong in canvas governance patches.`
+});
+var buildFollowthrough = (generationPlan) => ({
+  summary: buildInspiredesignFollowthroughSummary(),
+  nextStep: buildInspiredesignNextStep(),
+  recommendedSkills: [...INSPIREDESIGN_HANDOFF_RECOMMENDED_SKILLS],
+  commandExamples: { ...INSPIREDESIGN_HANDOFF_COMMANDS },
+  deepCaptureRecommendation: INSPIREDESIGN_HANDOFF_GUIDANCE.deepCaptureRecommendation,
+  contractScope: buildContractScope(),
+  implementationContext: {
+    navigationModel: buildNavigationModelBlock(generationPlan.visualDirection.profile),
+    asyncModel: buildAsyncModelBlock(),
+    performanceModel: buildPerformanceModelBlock()
+  }
+});
+var buildDesignContract = (brief, urls, references, plan) => ({
+  intent: buildIntentBlock(brief, urls, references),
+  generationPlan: plan,
+  designLanguage: buildDesignLanguageBlock(plan.visualDirection.profile),
+  contentModel: buildContentModelBlock(brief, references),
+  layoutSystem: buildLayoutSystemBlock(plan.visualDirection.profile),
+  typographySystem: buildTypographySystemBlock(),
+  colorSystem: buildColorSystemBlock(plan.visualDirection.profile),
+  surfaceSystem: buildSurfaceSystemBlock(),
+  iconSystem: buildIconSystemBlock(),
+  motionSystem: buildMotionSystemBlock(),
+  responsiveSystem: buildResponsiveSystemBlock(),
+  accessibilityPolicy: buildAccessibilityBlock(),
+  libraryPolicy: buildLibraryPolicyBlock(),
+  runtimeBudgets: buildRuntimeBudgetsBlock(plan)
+});
+var buildTokenStrategy = (profile) => ({
+  colors: PROFILE_CONFIG[profile].colors,
+  typography: {
+    display: "font-display text-[56px] leading-[1.0]",
+    h1: "font-display text-[40px] leading-[1.05]",
+    h2: "font-display text-[28px] leading-[1.1]",
+    h3: "font-display text-[20px] leading-[1.2]",
+    body: "font-body text-[16px] leading-[1.6]",
+    label: "font-body text-[14px] leading-[1.4]",
+    caption: "font-body text-[12px] leading-[1.4]"
+  },
+  spacing: {
+    xs: "4px",
+    sm: "8px",
+    md: "16px",
+    lg: "24px",
+    xl: "40px",
+    section: "96px"
+  },
+  radius: {
+    xs: "6px",
+    sm: "10px",
+    md: "16px",
+    lg: "24px"
+  },
+  shadow: {
+    sm: "0 1px 2px rgba(15, 23, 42, 0.06)",
+    md: "0 10px 30px rgba(15, 23, 42, 0.10)",
+    lg: "0 24px 60px rgba(15, 23, 42, 0.14)"
+  },
+  motion: {
+    quick: "120ms ease-out",
+    standard: "180ms ease-out",
+    emphasis: "240ms cubic-bezier(0.22, 1, 0.36, 1)"
+  },
+  zIndex: {
+    base: 0,
+    sticky: 20,
+    overlay: 40,
+    modal: 60,
+    toast: 70
+  },
+  breakpoints: {
+    mobile: "640px",
+    tablet: "1024px",
+    desktop: "1280px"
+  }
+});
+var buildComponentBuildPlan = (profile) => {
+  return PROFILE_CONFIG[profile].componentSequence.map((name) => ({
+    name,
+    purpose: `Establish the ${name.toLowerCase()} pattern as a reusable system primitive.`,
+    states: ["default", "hover", "focus", "disabled"],
+    implementationNote: "Use semantic tokens first and keep copy/state logic outside the visual component."
+  }));
+};
+var buildImplementationPlan = (brief, profile, references) => ({
+  architectureRecommendation: "Implement the surface as token-first components using shared semantic CSS variables, then compose page sections from those primitives before adding any page-specific polish.",
+  tokenStrategy: buildTokenStrategy(profile),
+  componentBuildPlan: buildComponentBuildPlan(profile),
+  pageAssemblyPlan: [
+    "Start with the shell and primary navigation pattern.",
+    "Compose the hero or primary decision section before supporting sections.",
+    "Add proof, utility, and footer sections only after the top-level hierarchy is stable."
+  ],
+  stateAndInteractionPlan: [
+    "Keep hover, focus, loading, success, and error states visually distinct.",
+    "Preserve layout during loading and keep transient confirmations out of the main flow.",
+    "Use reduced-motion-safe transitions for reveals and CTA feedback."
+  ],
+  accessibilityChecklist: [
+    "Maintain 4.5:1 body text contrast across all surfaces.",
+    "Preserve visible focus rings on every interactive element.",
+    "Keep landmarks and heading levels explicit and sequential."
+  ],
+  responsiveChecklist: [
+    "Collapse multicolumn layouts before text measure becomes cramped.",
+    "Keep the primary CTA visible without overlap on narrow screens.",
+    "Avoid horizontal scrolling for primary content."
+  ],
+  risksAndAmbiguities: [
+    references.length === 0 ? "No live references were supplied, so visual cues are derived entirely from the written brief." : "Live references were reduced into reusable patterns; unique brand assets should still be recreated, not copied.",
+    "Any missing interaction states must be validated during visual QA."
+  ],
+  buildSequence: [
+    "Define semantic tokens and typography.",
+    "Build the shell, navigation, and primary CTA components.",
+    "Implement section-level patterns and proof blocks.",
+    "Add loading, empty, and error states.",
+    "Run accessibility, responsive, and browser QA before final polish."
+  ]
+});
+var formatBulletList = (items) => items.map((item) => `- ${item}`).join("\n");
+var formatRecordList = (record) => {
+  return Object.entries(record).map(([key, value]) => `- \`${key}\`: ${value}`).join("\n");
+};
+var referenceContribution = (reference) => {
+  if (reference.captureStatus === "captured") return "Live hierarchy and component evidence captured from the page.";
+  if (reference.fetchStatus === "captured") return "Content and structural cues inferred from fetched page data.";
+  return "Only operator brief context was available for this reference.";
+};
+var referenceMotionNote = (reference) => {
+  if (reference.capture?.snapshot?.warnings?.length) {
+    return `Capture warnings: ${reference.capture.snapshot.warnings.join(", ")}`;
+  }
+  if (reference.captureStatus === "captured") return "Motion should remain subtle until validated against the live capture.";
+  return "Motion is inferred from the brief rather than directly observed.";
+};
+var renderReferenceMarkdown = (reference, index) => {
+  const excerpt = reference.excerpt ? clipText(reference.excerpt, 220) : "No fetched excerpt captured.";
+  const title = reference.title ?? reference.url;
+  return [
+    `### Source ${index + 1}: ${title}`,
+    `- what it contributes: ${referenceContribution(reference)}`,
+    `- notable UI patterns: ${reference.capture?.snapshot ? "Primary hierarchy and actionables were captured from the live page." : "Patterns inferred from brief and fetched content."}`,
+    `- typography observations: ${reference.title ? "Headline density and copy hierarchy were inferred from the fetched title and excerpt." : "Typography is inferred."}`,
+    `- color and theme observations: ${reference.captureStatus === "captured" ? "Color posture should be validated against the captured page before cloning brand treatment." : "Color posture remains a synthesis decision."}`,
+    `- layout and hierarchy observations: ${reference.capture?.snapshot ? clipText(reference.capture.snapshot.content, 180) : excerpt}`,
+    `- component patterns: ${reference.capture?.clone ? "Buttons, cards, or layout wrappers can be inferred from the captured clone preview." : "Component families were inferred from available reference text."}`,
+    `- motion/interaction observations: ${referenceMotionNote(reference)}`,
+    `- accessibility/responsiveness notes: ${reference.captureStatus === "captured" ? "Validate focus order, CTA prominence, and stacked layouts during build QA." : "Accessibility and responsiveness are inferred from system defaults."}`,
+    `- what should be adopted, adapted, or avoided: adopt layout hierarchy, adapt it to the new brand tokens, avoid copying proprietary copy or visual assets directly.`
+  ].join("\n");
+};
+var resolveProfileConfigFromGenerationPlan = (generationPlan) => {
+  if (!generationPlan || typeof generationPlan !== "object" || !("visualDirection" in generationPlan)) {
+    throw new Error("Inspiredesign design contract requires a generation plan.");
+  }
+  const visualDirection = generationPlan.visualDirection;
+  if (!visualDirection || typeof visualDirection !== "object" || !("profile" in visualDirection)) {
+    throw new Error("Inspiredesign design contract requires a visual direction profile.");
+  }
+  const profile = visualDirection.profile;
+  if (typeof profile !== "string" || !(profile in PROFILE_CONFIG)) {
+    throw new Error("Inspiredesign design contract profile is invalid.");
+  }
+  return PROFILE_CONFIG[profile];
+};
+var renderGovernanceMarkdown = (designContract, implementationPlan) => {
+  const profileConfig = resolveProfileConfigFromGenerationPlan(designContract.generationPlan);
+  return [
+    "## 4.1 Design Intent",
+    formatBulletList([
+      `Purpose: ${designContract.intent.task || ""}`,
+      "Capture the reusable visual logic from the references without cloning proprietary brand assets.",
+      "Keep the resulting system executable for downstream build agents."
+    ]),
+    "",
+    "## 4.2 Core UX Principles",
+    formatBulletList(profileConfig.hierarchyPrinciples),
+    "",
+    "## 4.3 Visual Identity",
+    formatBulletList([
+      `Aesthetic style: ${profileConfig.visualPersonality}`,
+      `Brand tone: ${profileConfig.brandTone}`,
+      `Quality posture: ${profileConfig.direction}`,
+      "Direction: modern, system-led, and implementation-aware."
+    ]),
+    "",
+    "## 4.4 Color System",
+    formatRecordList(implementationPlan.tokenStrategy.colors),
+    "",
+    "## 4.5 Typography System",
+    formatRecordList(implementationPlan.tokenStrategy.typography),
+    "",
+    "## 4.6 Spacing and Layout System",
+    formatRecordList(implementationPlan.tokenStrategy.spacing),
+    "",
+    "## 4.7 Shape, Border, and Elevation Rules",
+    [
+      formatRecordList(implementationPlan.tokenStrategy.radius),
+      formatRecordList(implementationPlan.tokenStrategy.shadow)
+    ].join("\n"),
+    "",
+    "## 4.8 Motion and Interaction Rules",
+    formatRecordList(implementationPlan.tokenStrategy.motion),
+    "",
+    "## 4.9 Component System",
+    implementationPlan.componentBuildPlan.map((component) => [
+      `### ${component.name}`,
+      formatBulletList([
+        `purpose: ${component.purpose}`,
+        `structure: build from semantic tokens and keep state visuals explicit`,
+        `visual style: ${profileConfig.direction}`,
+        `states: ${component.states.join(", ")}`,
+        "spacing: keep internal padding on the 8px rhythm",
+        "accessibility notes: preserve focus visibility and keyboard parity",
+        "responsive behavior: stack content before line length becomes cramped",
+        `implementation notes: ${component.implementationNote}`
+      ])
+    ].join("\n")).join("\n\n"),
+    "",
+    "## 4.10 Page or Section Patterns",
+    formatBulletList(profileConfig.pagePatterns),
+    "",
+    "## 4.11 Accessibility Requirements",
+    formatBulletList(implementationPlan.accessibilityChecklist),
+    "",
+    "## 4.12 Responsiveness Requirements",
+    formatBulletList(implementationPlan.responsiveChecklist),
+    "",
+    "## 4.13 Content and Microcopy Guidance",
+    formatBulletList([
+      "Use direct, confident labels and short CTA copy.",
+      "Keep error and success messages specific to the affected region.",
+      "Prefer descriptive button copy over generic verbs."
+    ]),
+    "",
+    "## 4.14 Do / Don't Rules",
+    formatBulletList([
+      "Do preserve one dominant message per section.",
+      "Do encode repeated visual rules into semantic tokens.",
+      "Don't copy proprietary logos, screenshots, or brand-only illustrations.",
+      "Don't hide important actions inside ambiguous hover-only affordances."
+    ]),
+    "",
+    "## 4.15 Acceptance Criteria",
+    formatBulletList([
+      "Primary action is obvious within one viewport.",
+      "Color, typography, spacing, and elevation all resolve through named tokens.",
+      "Keyboard, focus, and reduced-motion behavior remain intact across breakpoints."
+    ])
+  ].join("\n");
+};
+var renderImplementationMarkdown = (implementationPlan) => {
+  return [
+    "# 5. Implementation Plan",
+    "",
+    "## 5.1 Architecture Recommendation",
+    implementationPlan.architectureRecommendation,
+    "",
+    "## 5.2 Design Token Strategy",
+    formatRecordList(implementationPlan.tokenStrategy.colors),
+    "",
+    formatRecordList(implementationPlan.tokenStrategy.typography),
+    "",
+    "## 5.3 Component Build Plan",
+    implementationPlan.componentBuildPlan.map((component, index) => `${index + 1}. ${component.name}: ${component.purpose}`).join("\n"),
+    "",
+    "## 5.4 Page Assembly Plan",
+    formatBulletList(implementationPlan.pageAssemblyPlan),
+    "",
+    "## 5.5 State and Interaction Plan",
+    formatBulletList(implementationPlan.stateAndInteractionPlan),
+    "",
+    "## 5.6 Accessibility Implementation Checklist",
+    formatBulletList(implementationPlan.accessibilityChecklist),
+    "",
+    "## 5.7 Responsive Implementation Checklist",
+    formatBulletList(implementationPlan.responsiveChecklist),
+    "",
+    "## 5.8 Risks and Ambiguities",
+    formatBulletList(implementationPlan.risksAndAmbiguities),
+    "",
+    "## 5.9 Recommended Build Sequence",
+    implementationPlan.buildSequence.map((step, index) => `${index + 1}. ${step}`).join("\n")
+  ].join("\n");
+};
+var renderPrototypeGuidance = (profile) => {
+  return [
+    "# 6. Optional Prototype Plan",
+    "",
+    "- page structure: establish the shell, hero or primary action zone, proof sections, and footer in that order.",
+    `- section order: ${PROFILE_CONFIG[profile].pagePatterns.join(" -> ")}`,
+    "- component composition: reuse button, card, input, and navigation primitives before page-specific wrappers.",
+    "- interaction expectations: provide visible focus, compact hover feedback, and reduced-motion-safe entry transitions.",
+    "- HTML skeleton guidance: start with one main landmark, one primary CTA group, and semantic sections for proof or detail bands.",
+    "- styling approach: define CSS variables first, then map components to semantic tokens rather than raw values.",
+    "- first prototype should include vs omit: include shell, hero, CTA, one proof section, and one form or action cluster; omit analytics, heavy animation, and tertiary content until hierarchy is proven."
+  ].join("\n");
+};
+var renderDeliverablesSummary = (includePrototypeGuidance) => {
+  const deliverables = [
+    "Structured `designContract` JSON aligned to canvas governance",
+    "Valid `generationPlan` JSON aligned to the canvas generation plan contract",
+    "Ready-to-fill `canvasPlanRequest` JSON for `canvas.plan.set`",
+    "Design-agent handoff JSON with contract scope, skill nudges, and richer implementation context",
+    "Human-readable `design.md` design specification",
+    "Engineering implementation plan in JSON and Markdown"
+  ];
+  if (includePrototypeGuidance) {
+    deliverables.push("Prototype guidance Markdown for the first HTML pass");
+  }
+  deliverables.push("Evidence digest describing brief, references, fetch outcomes, and capture outcomes");
+  return formatBulletList(deliverables);
+};
+var buildEvidencePayload = (brief, urls, references) => ({
+  brief,
+  briefHash: referenceFingerprint(brief),
+  urls,
+  referenceCount: references.length,
+  references: references.map((reference) => toReferenceEvidenceJson(reference))
+});
+var toCaptureEvidenceJson = (capture) => {
+  if (!capture) return null;
+  return {
+    ...capture.title ? { title: capture.title } : {},
+    ...capture.snapshot ? { snapshot: capture.snapshot } : {},
+    ...capture.dom ? { dom: capture.dom } : {},
+    ...capture.clone ? { clone: capture.clone } : {}
+  };
+};
+var toReferenceEvidenceJson = (reference) => ({
+  id: reference.id,
+  url: reference.url,
+  ...reference.title ? { title: reference.title } : {},
+  ...reference.excerpt ? { excerpt: reference.excerpt } : {},
+  fetchStatus: reference.fetchStatus,
+  captureStatus: reference.captureStatus,
+  ...reference.fetchFailure ? { fetchFailure: reference.fetchFailure } : {},
+  ...reference.captureFailure ? { captureFailure: reference.captureFailure } : {},
+  capture: toCaptureEvidenceJson(reference.capture)
+});
+var buildInspiredesignPacket = (input) => {
+  const brief = trimText(input.brief);
+  const urls = [...new Set(input.urls.map((url) => trimText(url)).filter(Boolean))];
+  const references = input.references.map((reference) => ({
+    ...reference,
+    title: reference.title ? trimText(reference.title) : void 0,
+    excerpt: reference.excerpt ? trimText(reference.excerpt) : void 0
+  }));
+  const profile = classifyProfile(brief, references);
+  const generationPlan = buildGenerationPlan(brief, profile, references);
+  const canvasPlanRequest = buildCanvasPlanRequest(brief, generationPlan);
+  const designContract = buildDesignContract(brief, urls, references, generationPlan);
+  const followthrough = buildFollowthrough(generationPlan);
+  const implementationPlan = buildImplementationPlan(brief, profile, references);
+  const governanceMarkdown = renderGovernanceMarkdown(designContract, implementationPlan);
+  const implementationPlanMarkdown = renderImplementationMarkdown(implementationPlan);
+  const prototypeGuidanceMarkdown = input.includePrototypeGuidance ? renderPrototypeGuidance(profile) : null;
+  const designMarkdown = [
+    "# 1. Executive Summary",
     "",
-    ...lines,
+    formatBulletList([
+      `Analyzed brief plus ${references.length || 0} inspiration reference(s).`,
+      `Chosen design direction: ${PROFILE_CONFIG[profile].direction}.`,
+      "Final outcome: a reusable design contract, engineering plan, and optional prototype guidance.",
+      `Scope mode: ${references.length > 1 ? "full-site synthesis" : "single-surface synthesis"}.`
+    ]),
     "",
-    "## Metadata",
-    "```json",
-    JSON.stringify(args.meta, null, 2),
-    "```"
+    "# 2. Inspiration Analysis",
+    "",
+    references.length > 0 ? references.map(renderReferenceMarkdown).join("\n\n") : "- No live inspiration source was provided. The system is derived entirely from the brief.",
+    "",
+    "# 3. Unified Design Direction",
+    "",
+    formatBulletList([
+      `visual personality: ${PROFILE_CONFIG[profile].visualPersonality}`,
+      `tone: ${PROFILE_CONFIG[profile].brandTone}`,
+      `UX principles: ${PROFILE_CONFIG[profile].hierarchyPrinciples.join(" ")}`,
+      `interaction philosophy: ${PROFILE_CONFIG[profile].interactionPhilosophy}`,
+      "branding posture: preserve the intent of the references without cloning brand-only assets.",
+      "system coherence rules: encode tokens first, keep one dominant idea per section, and keep states explicit."
+    ]),
+    "",
+    "# 4. Design Governance (`design.md`)",
+    "",
+    renderGovernanceMarkdown(designContract, implementationPlan),
+    "",
+    renderImplementationMarkdown(implementationPlan),
+    "",
+    prototypeGuidanceMarkdown ?? "# 6. Optional Prototype Plan\n\n- Prototype guidance omitted for this run.",
+    "",
+    "# 7. Deliverables Summary",
+    "",
+    renderDeliverablesSummary(Boolean(input.includePrototypeGuidance))
   ].join("\n");
-  const comparisonCsv = toComparisonCsv(args.offers);
-  const contextPayload = {
-    query: args.query,
-    highlights: lines,
-    offers: args.offers,
-    meta: args.meta
-  };
-  const files = [
-    { path: "deals.md", content: markdown },
-    { path: "offers.json", content: { offers: args.offers } },
-    { path: "comparison.csv", content: comparisonCsv },
-    { path: "meta.json", content: args.meta },
-    { path: "deals-context.json", content: contextPayload }
-  ];
-  if (args.mode === "compact") {
-    return {
-      response: {
-        mode: args.mode,
-        summary: lines.join("\n"),
-        meta: args.meta
-      },
-      files
-    };
-  }
-  if (args.mode === "json") {
-    return {
-      response: {
-        mode: args.mode,
-        offers: args.offers,
-        meta: args.meta
-      },
-      files
-    };
-  }
-  if (args.mode === "md") {
-    return {
-      response: {
-        mode: args.mode,
-        markdown,
-        meta: args.meta
-      },
-      files
-    };
-  }
-  if (args.mode === "context") {
-    return {
-      response: {
-        mode: args.mode,
-        context: contextPayload,
-        meta: args.meta
-      },
-      files
-    };
-  }
   return {
-    response: {
-      mode: "path",
-      meta: args.meta
-    },
-    files
+    designContract,
+    generationPlan,
+    canvasPlanRequest,
+    followthrough,
+    designMarkdown,
+    implementationPlan,
+    implementationPlanMarkdown,
+    prototypeGuidanceMarkdown,
+    evidence: buildEvidencePayload(brief, urls, references)
   };
 };
 
+// src/providers/workflow-handoff.ts
+var PRODUCT_VIDEO_BRIEF_HELPER_PATH = "./skills/opendevbrowser-product-presentation-asset/scripts/render-video-brief.sh";
+var PRODUCT_VIDEO_BRIEF_HELPER_COMMAND = `${PRODUCT_VIDEO_BRIEF_HELPER_PATH} <pack>/manifest.json`;
+var createSuccessHandoff = (followthroughSummary, suggestedNextAction, suggestedSteps) => ({
+  followthroughSummary,
+  suggestedNextAction,
+  suggestedSteps
+});
+var buildResearchSuccessHandoff = () => {
+  return createSuccessHandoff(
+    "Review the ranked records and artifact bundle before turning the result into a publishable claim.",
+    "Open the returned artifact path, inspect the supporting records, and rerun with explicit --sources or a tighter timebox if you need stronger evidence.",
+    [
+      { reason: "Check which records actually support the final claim." },
+      { reason: "Rerun with explicit sources or a narrower timebox if the evidence set is still too broad." }
+    ]
+  );
+};
+var buildShoppingSuccessHandoff = () => {
+  return createSuccessHandoff(
+    "Review the offer set and diagnostics before calling any result a strong deal.",
+    "Inspect the offers and meta.offerFilterDiagnostics, then rerun with explicit providers or budget and region adjustments if you need a tighter comparison.",
+    [
+      { reason: "Check which offers survived the workflow filters and why." },
+      { reason: "Rerun with explicit providers or updated budget and region inputs if the comparison is still noisy." }
+    ]
+  );
+};
+var buildProductVideoSuccessHandoff = () => {
+  return createSuccessHandoff(
+    "Review the generated asset pack to confirm whether it is visual-ready or metadata-first before briefing production.",
+    `Open the returned pack path, inspect manifest.json plus copy and features, then run ${PRODUCT_VIDEO_BRIEF_HELPER_COMMAND} to generate production briefs and sourcing notes.`,
+    [
+      { reason: "Confirm whether the pack already includes enough images or screenshots for production." },
+      {
+        reason: "Run the product-presentation-asset brief helper on manifest.json to generate the production brief files.",
+        command: PRODUCT_VIDEO_BRIEF_HELPER_COMMAND
+      },
+      { reason: "Source or capture visuals before final handoff if the pack is metadata-first." }
+    ]
+  );
+};
+
 // src/providers/shopping-postprocess.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var LOOKS_LIKE_URL_RE = /^https?:\/\/\S+$/i;
 var PRICE_TOKEN_RE = /((?:US\$|CA\$|C\$|USD|CAD|EUR|GBP|[$€£]))\s*([0-9]{1,4}(?:[.,][0-9]{3})*(?:[.,][0-9]{1,2})?)/gi;
 var CONTEXTUAL_PRICE_TOKEN_RE = /(?:connect to any carrier later|starting at|starts at|starting from|from|buy now for|buy for)\s*((?:US\$|CA\$|C\$|USD|CAD|EUR|GBP|[$€£]))\s*([0-9]{1,4}(?:[.,][0-9]{3})*(?:[.,][0-9]{1,2})?)/gi;
@@ -9766,7 +11374,7 @@ var REGION_CURRENCY_BY_REGION = {
   uk: "GBP",
   eu: "EUR"
 };
-var hash = (value) => createHash3("sha1").update(value).digest("hex").slice(0, 16);
+var hash = (value) => createHash4("sha1").update(value).digest("hex").slice(0, 16);
 var normalizePlainText = (value) => {
   if (!value) return "";
   return extractText(value).replace(/[\u0000-\u001F\u007F-\u009F]+/g, " ").replace(/\s+/g, " ").trim();
@@ -10395,7 +12003,7 @@ var compileShoppingWorkflow = (input, options = {}) => {
 };
 
 // src/providers/shopping-compiler.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var DEFAULT_SHOPPING_SEARCH_LIMIT = 8;
 var SHOPPING_FETCH_RECOVERY_LIMIT = 2;
 var SEARCH_INDEX_RETRIEVAL_PATHS = /* @__PURE__ */ new Set(["shopping:search:index", "shopping:search:link"]);
@@ -10412,7 +12020,7 @@ var emptyCheckpointState = () => ({
   step_results_by_id: {}
 });
 var createShoppingSearchStepId = (providerId) => `search:${providerId}`;
-var createShoppingFetchStepId = (providerId, url) => `fetch:${providerId}:${createHash4("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
+var createShoppingFetchStepId = (providerId, url) => `fetch:${providerId}:${createHash5("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
 var serializeShoppingCheckpointState = (state) => ({
   completed_step_ids: [...state.completed_step_ids],
   step_results_by_id: state.step_results_by_id
@@ -10898,7 +12506,7 @@ var compileProductVideoExecutionPlan = (args) => {
 };
 
 // src/providers/research-compiler.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var RESEARCH_AUTO_SOURCES = ["web", "community", "social"];
 var RESEARCH_ALL_SOURCES = [...RESEARCH_AUTO_SOURCES];
 var DEFAULT_RESEARCH_SEARCH_LIMIT = 10;
@@ -10923,7 +12531,7 @@ var toProviderSource = (providerId) => {
   return null;
 };
 var createResearchSearchStepId = (source) => `search:${source}`;
-var createResearchFetchStepId = (url) => `fetch:web:${createHash5("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
+var createResearchFetchStepId = (url) => `fetch:web:${createHash6("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
 var serializeResearchCheckpointState = (state) => ({
   completed_step_ids: [...state.completed_step_ids],
   step_results_by_id: state.step_results_by_id
@@ -11266,6 +12874,10 @@ var SIGNAL_WINDOW = 50;
 var RECOVERY_WINDOWS_REQUIRED = 2;
 var providerSignalMap = /* @__PURE__ */ new Map();
 var workflowLogger = createLogger("provider-workflows");
+var withFollowthroughMeta = (meta, handoff) => ({
+  ...meta,
+  followthroughSummary: handoff.followthroughSummary
+});
 var detectSignal = (error) => {
   const reasonCode = error.reasonCode ?? normalizeProviderReasonCode({
     code: error.code,
@@ -11509,24 +13121,54 @@ var withPrimaryConstraintMeta = (meta, failures) => {
   const primaryIssue = summarizePrimaryProviderIssue(failures);
   return primaryIssue ? {
     ...meta,
-    primary_constraint: primaryIssue,
     primaryConstraint: primaryIssue,
     primaryConstraintSummary: primaryIssue.summary
   } : meta;
 };
-var withPrimaryConstraintSummaryOverride = (meta, summary) => {
+var withCamelCasePrimaryConstraintMeta = withPrimaryConstraintMeta;
+var readPrimaryConstraintGuidance = (constraint) => {
+  const guidance = constraint.guidance;
+  return guidance && typeof guidance === "object" && !Array.isArray(guidance) ? guidance : void 0;
+};
+var withPrimaryConstraintSummaryOverride = (meta, summary, guidance) => {
   const currentPrimaryConstraint = meta.primaryConstraint;
-  const nextPrimaryConstraint = currentPrimaryConstraint && typeof currentPrimaryConstraint === "object" && !Array.isArray(currentPrimaryConstraint) ? {
-    ...currentPrimaryConstraint,
+  const baseConstraint = currentPrimaryConstraint && typeof currentPrimaryConstraint === "object" && !Array.isArray(currentPrimaryConstraint) ? currentPrimaryConstraint : { reasonCode: "env_limited" };
+  const existingGuidance = readPrimaryConstraintGuidance(baseConstraint);
+  const { guidance: _existingGuidance, ...nextPrimaryConstraintBase } = baseConstraint;
+  const nextGuidance = guidance ?? existingGuidance;
+  const nextPrimaryConstraint = nextGuidance ? {
+    ...nextPrimaryConstraintBase,
+    summary,
+    guidance: nextGuidance
+  } : {
+    ...nextPrimaryConstraintBase,
     summary
-  } : { summary, reasonCode: "env_limited" };
+  };
   return {
     ...meta,
-    primary_constraint: nextPrimaryConstraint,
     primaryConstraint: nextPrimaryConstraint,
     primaryConstraintSummary: summary
   };
 };
+var withReasonCodeDistributionMeta = (meta, reasonCodeDistribution) => {
+  const metrics = meta.metrics;
+  const nextMetrics = metrics && typeof metrics === "object" && !Array.isArray(metrics) ? {
+    ...metrics,
+    reasonCodeDistribution
+  } : { reasonCodeDistribution };
+  return {
+    ...meta,
+    metrics: nextMetrics,
+    reasonCodeDistribution
+  };
+};
+var incrementReasonCodeDistribution = (reasonCodeDistribution, reasonCode, count) => {
+  if (count <= 0) return reasonCodeDistribution;
+  return Object.fromEntries(Object.entries({
+    ...reasonCodeDistribution,
+    [reasonCode]: (reasonCodeDistribution[reasonCode] ?? 0) + count
+  }).sort(([left], [right]) => left.localeCompare(right)));
+};
 var summarizeShoppingOfferFilterConstraint = (args) => {
   const primaryIssue = summarizePrimaryProviderIssue(args.failures);
   if (primaryIssue && (primaryIssue.reasonCode !== "env_limited" || primaryIssue.constraint || primaryIssue.blockerType === "anti_bot_challenge")) {
@@ -11586,6 +13228,7 @@ var withBrowserModeOverride = (options, input) => {
 var WORKFLOW_KIND_BY_SUSPENDED_INTENT_KIND = {
   "workflow.research": "research",
   "workflow.shopping": "shopping",
+  "workflow.inspiredesign": "inspiredesign",
   "workflow.product_video": "product_video"
 };
 var buildWorkflowResumePayload = (kind, input) => ({
@@ -11837,7 +13480,7 @@ var rankResearchRecords = (records) => {
     return left.id.localeCompare(right.id);
   });
 };
-var hash2 = (value) => createHash6("sha1").update(value).digest("hex").slice(0, 16);
+var hash2 = (value) => createHash7("sha1").update(value).digest("hex").slice(0, 16);
 var RESEARCH_ALWAYS_SANITIZED_PATHS = /* @__PURE__ */ new Set([
   "community:search:index",
   "social:search:index"
@@ -11956,6 +13599,235 @@ var createRemainingTimeoutResolver = (timeoutMs) => {
   const startedAtMs = Date.now();
   return () => Math.max(1, timeoutMs - Math.max(0, Date.now() - startedAtMs));
 };
+var INSPIREDESIGN_RENDER_MODES = /* @__PURE__ */ new Set(["compact", "json", "md", "context", "path"]);
+var INSPIREDESIGN_CAPTURE_MODES = /* @__PURE__ */ new Set(["off", "deep"]);
+var INSPIREDESIGN_COOKIE_POLICIES = /* @__PURE__ */ new Set(["off", "auto", "required"]);
+var serializeInspiredesignRunInput = (input) => ({
+  brief: input.brief,
+  urls: input.urls,
+  captureMode: input.captureMode,
+  mode: input.mode,
+  ...input.includePrototypeGuidance !== void 0 ? { includePrototypeGuidance: input.includePrototypeGuidance } : {},
+  ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
+  ...input.outputDir ? { outputDir: input.outputDir } : {},
+  ...typeof input.ttlHours === "number" ? { ttlHours: input.ttlHours } : {},
+  ...typeof input.useCookies === "boolean" ? { useCookies: input.useCookies } : {},
+  ...input.challengeAutomationMode ? { challengeAutomationMode: input.challengeAutomationMode } : {},
+  ...input.cookiePolicyOverride ? { cookiePolicyOverride: input.cookiePolicyOverride } : {}
+});
+var parseInspiredesignEnvelopeInput = (input) => ({
+  brief: typeof input.brief === "string" ? input.brief : "",
+  mode: typeof input.mode === "string" && INSPIREDESIGN_RENDER_MODES.has(input.mode) ? input.mode : "compact",
+  ...Array.isArray(input.urls) ? { urls: input.urls.filter((url) => typeof url === "string") } : {},
+  ...typeof input.captureMode === "string" && INSPIREDESIGN_CAPTURE_MODES.has(input.captureMode) ? { captureMode: input.captureMode } : {},
+  ...typeof input.includePrototypeGuidance === "boolean" ? { includePrototypeGuidance: input.includePrototypeGuidance } : {},
+  ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
+  ...typeof input.outputDir === "string" && input.outputDir.length > 0 ? { outputDir: input.outputDir } : {},
+  ...typeof input.ttlHours === "number" ? { ttlHours: input.ttlHours } : {},
+  ...typeof input.useCookies === "boolean" ? { useCookies: input.useCookies } : {},
+  ...isChallengeAutomationMode(input.challengeAutomationMode) ? { challengeAutomationMode: input.challengeAutomationMode } : {},
+  ...typeof input.cookiePolicyOverride === "string" && INSPIREDESIGN_COOKIE_POLICIES.has(input.cookiePolicyOverride) ? { cookiePolicyOverride: input.cookiePolicyOverride } : {}
+});
+var normalizeInspiredesignUrls = (urls) => {
+  if (!urls || urls.length === 0) return [];
+  const normalized = urls.map((url) => url.trim()).filter(Boolean);
+  const invalid = normalized.find((url) => !LOOKS_LIKE_URL_RE.test(url));
+  if (invalid) {
+    throw new Error(`Inspiredesign workflow received an invalid URL: ${invalid}`);
+  }
+  return [...new Set(normalized.map((url) => canonicalizeUrl(url)))];
+};
+var normalizeInspiredesignInput = (input) => {
+  const brief = input.brief.trim();
+  if (!brief) {
+    throw new Error("Inspiredesign workflow requires a non-empty brief.");
+  }
+  return {
+    ...input,
+    brief,
+    urls: normalizeInspiredesignUrls(input.urls),
+    captureMode: input.captureMode ?? "off",
+    mode: input.mode ?? "compact"
+  };
+};
+var isInspiredesignWorkflowEnvelopeInput = (input) => {
+  return "kind" in input && "input" in input;
+};
+var buildInspiredesignEnvelope = (input) => {
+  if (isInspiredesignWorkflowEnvelopeInput(input)) {
+    if (!isWorkflowResumeEnvelope(input)) {
+      throw new Error("Inspiredesign workflow envelope is invalid.");
+    }
+    if (input.kind !== "inspiredesign") {
+      throw new Error(`Inspiredesign workflow envelope kind mismatch. Expected inspiredesign but received ${input.kind}.`);
+    }
+    return {
+      envelope: input,
+      workflowInput: normalizeInspiredesignInput(parseInspiredesignEnvelopeInput(input.input))
+    };
+  }
+  const workflowInput = normalizeInspiredesignInput(input);
+  return {
+    envelope: buildWorkflowResumeEnvelope("inspiredesign", serializeInspiredesignRunInput(workflowInput)),
+    workflowInput
+  };
+};
+var appendWorkflowTrace = (trace, stage, event, details) => [
+  ...trace,
+  {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    stage,
+    event,
+    details
+  }
+];
+var buildInspiredesignStepEnvelope = (workflowInput, trace, stepIndex, url) => buildWorkflowResumeEnvelope(
+  "inspiredesign",
+  serializeInspiredesignRunInput(workflowInput),
+  {
+    checkpoint: {
+      stage: "execute",
+      stepId: "fetch_reference",
+      stepIndex,
+      state: { url },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    trace
+  }
+);
+var buildInspiredesignFetchOptions = (workflowInput, envelope, timeoutMs) => withWorkflowResumeEnvelopeIntent(
+  withChallengeAutomationOverride(
+    withCookieOverrides({
+      ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+    }, workflowInput),
+    workflowInput
+  ),
+  "workflow.inspiredesign",
+  envelope
+);
+var hasInspiredesignCaptureEvidence = (capture) => {
+  if (!capture) return false;
+  return Boolean(capture.title || capture.snapshot || capture.dom || capture.clone);
+};
+var captureInspiredesignReference = async (url, captureMode, workflowInput, captureReference, timeoutMs) => {
+  if (captureMode === "off") {
+    return { captureStatus: "off" };
+  }
+  if (!captureReference) {
+    return {
+      captureStatus: "failed",
+      captureFailure: "Deep capture requested, but no browser capture callback was available."
+    };
+  }
+  try {
+    const capture = await captureReference(url, {
+      timeoutMs,
+      useCookies: workflowInput.useCookies,
+      challengeAutomationMode: workflowInput.challengeAutomationMode,
+      cookiePolicyOverride: workflowInput.cookiePolicyOverride
+    });
+    if (!hasInspiredesignCaptureEvidence(capture)) {
+      return {
+        captureStatus: "failed",
+        captureFailure: "Deep capture did not return usable snapshot, DOM, or clone evidence."
+      };
+    }
+    return {
+      captureStatus: "captured",
+      capture
+    };
+  } catch (error) {
+    return {
+      captureStatus: "failed",
+      captureFailure: error instanceof Error ? error.message : "Deep capture failed."
+    };
+  }
+};
+var getInspiredesignPrimaryRecord = (result, url) => {
+  const canonicalUrl = canonicalizeUrl(url);
+  return result.records.find((record) => record.url && canonicalizeUrl(record.url) === canonicalUrl) ?? result.records[0];
+};
+var summarizeInspiredesignFetchFailure = (result) => {
+  return summarizePrimaryProviderIssue(result.failures)?.summary ?? result.error?.message;
+};
+var excerptFromInspiredesignRecord = (record) => {
+  const content = normalizePlainText(record?.content);
+  if (!content) return void 0;
+  return toSnippet(content, 240);
+};
+var buildInspiredesignReference = (url, result, capture) => {
+  const primary = getInspiredesignPrimaryRecord(result, url);
+  const title = primary?.title ?? capture.capture?.title;
+  const excerpt = excerptFromInspiredesignRecord(primary);
+  const fetchStatus = result.records.length > 0 ? "captured" : "failed";
+  return {
+    id: createHash7("sha256").update(url).digest("hex").slice(0, 12),
+    url,
+    ...title ? { title } : {},
+    ...excerpt ? { excerpt } : {},
+    fetchStatus,
+    captureStatus: capture.captureStatus,
+    ...fetchStatus === "failed" && summarizeInspiredesignFetchFailure(result) ? { fetchFailure: summarizeInspiredesignFetchFailure(result) } : {},
+    ...capture.captureFailure ? { captureFailure: capture.captureFailure } : {},
+    ...capture.capture ? { capture: capture.capture } : {}
+  };
+};
+var summarizeInspiredesignCaptureConstraint = (references) => {
+  const failedReferences = references.filter((reference) => reference.captureStatus === "failed");
+  if (failedReferences.length === 0) {
+    return void 0;
+  }
+  const summary = `Deep capture failed for ${failedReferences.length} ${failedReferences.length === 1 ? "reference" : "references"}.`;
+  const retryUrls = failedReferences.slice(0, 2).map((reference) => `Retry deep capture for ${reference.url} after restoring the required browser session state.`);
+  return {
+    summary,
+    guidance: {
+      reason: summary,
+      recommendedNextCommands: [
+        "Rerun inspiredesign after configuring providers.cookieSource for the protected references you need to capture.",
+        ...retryUrls
+      ]
+    }
+  };
+};
+var buildInspiredesignMeta = (runtime, workflowInput, references, failures, followthrough) => {
+  const failedCaptures = references.filter((reference) => reference.captureStatus === "failed");
+  let reasonCodeDistribution = summarizeReasonCodeDistribution(failures);
+  let meta = withCamelCasePrimaryConstraintMeta(withReasonCodeDistributionMeta({
+    selection: {
+      urls: workflowInput.urls,
+      capture_mode: workflowInput.captureMode,
+      include_prototype_guidance: Boolean(workflowInput.includePrototypeGuidance)
+    },
+    metrics: {
+      reference_count: references.length,
+      fetched_references: references.filter((reference) => reference.fetchStatus === "captured").length,
+      captured_references: references.filter((reference) => reference.captureStatus === "captured").length,
+      failed_fetches: references.filter((reference) => reference.fetchStatus === "failed").length,
+      failed_captures: failedCaptures.length
+    },
+    alerts: buildWorkflowAlerts(runtime, failures)
+  }, reasonCodeDistribution), failures);
+  if (!meta.primaryConstraint) {
+    const captureConstraint = summarizeInspiredesignCaptureConstraint(references);
+    if (captureConstraint) {
+      reasonCodeDistribution = incrementReasonCodeDistribution(
+        reasonCodeDistribution,
+        "env_limited",
+        failedCaptures.length
+      );
+      meta = withReasonCodeDistributionMeta(meta, reasonCodeDistribution);
+      meta = withPrimaryConstraintSummaryOverride(meta, captureConstraint.summary, captureConstraint.guidance);
+    }
+  }
+  return {
+    ...meta,
+    followthroughSummary: followthrough.summary,
+    recommendedSkills: followthrough.recommendedSkills,
+    deepCaptureRecommendation: followthrough.deepCaptureRecommendation,
+    contractScope: followthrough.contractScope
+  };
+};
 var inferBrandFromContent = (content) => {
   const normalized = normalizePlainText(content);
   if (!normalized) return void 0;
@@ -12551,11 +14423,13 @@ var runResearchWorkflow = async (runtime, input) => {
     failures: mergedFailures,
     alerts: buildWorkflowAlerts(runtime, mergedFailures)
   }, primaryConstraintFailures);
+  const handoff = buildResearchSuccessHandoff();
+  const responseMeta = withFollowthroughMeta(meta, handoff);
   const rendered = renderResearch({
     mode: workflowInput.mode,
     topic: plan.compiled.topic,
     records: ranked,
-    meta
+    meta: responseMeta
   });
   const bundle = await createArtifactBundle({
     namespace: "research",
@@ -12566,20 +14440,22 @@ var runResearchWorkflow = async (runtime, input) => {
   if (workflowInput.mode === "path") {
     return {
       ...rendered.response,
+      ...handoff,
       path: bundle.basePath,
       records: ranked,
       meta: {
-        ...meta,
+        ...responseMeta,
         artifact_manifest: bundle.manifest
       }
     };
   }
   return {
     ...rendered.response,
+    ...handoff,
     artifact_path: bundle.basePath,
     records: ranked,
     meta: {
-      ...meta,
+      ...responseMeta,
       artifact_manifest: bundle.manifest
     }
   };
@@ -12726,11 +14602,13 @@ var runShoppingWorkflow = async (runtime, input) => {
   if (typeof filterConstraintSummary === "string") {
     meta = withPrimaryConstraintSummaryOverride(meta, filterConstraintSummary);
   }
+  const handoff = buildShoppingSuccessHandoff();
+  const responseMeta = withFollowthroughMeta(meta, handoff);
   const rendered = renderShopping({
     mode: workflowInput.mode,
     query: plan.compiled.query,
     offers,
-    meta
+    meta: responseMeta
   });
   const bundle = await createArtifactBundle({
     namespace: "shopping",
@@ -12741,18 +14619,112 @@ var runShoppingWorkflow = async (runtime, input) => {
   if (workflowInput.mode === "path") {
     return {
       ...rendered.response,
+      ...handoff,
       path: bundle.basePath,
       offers,
       meta: {
-        ...meta,
+        ...responseMeta,
         artifact_manifest: bundle.manifest
       }
     };
   }
   return {
     ...rendered.response,
+    ...handoff,
     offers,
     artifact_path: bundle.basePath,
+    meta: {
+      ...responseMeta,
+      artifact_manifest: bundle.manifest
+    }
+  };
+};
+var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
+  const { envelope, workflowInput } = buildInspiredesignEnvelope(input);
+  const remainingTimeoutMs = createRemainingTimeoutResolver(workflowInput.timeoutMs);
+  let trace = appendWorkflowTrace(envelope.trace ?? [], "compile", "compile_started", {
+    kind: "inspiredesign"
+  });
+  trace = appendWorkflowTrace(trace, "compile", "compile_completed", {
+    kind: "inspiredesign",
+    urlCount: workflowInput.urls.length,
+    captureMode: workflowInput.captureMode
+  });
+  const references = [];
+  const failures = [];
+  for (const [index, url] of workflowInput.urls.entries()) {
+    const stepTrace = appendWorkflowTrace(trace, "execute", "reference_started", {
+      stepIndex: index,
+      url
+    });
+    const fetchTimeoutMs = remainingTimeoutMs();
+    const result = await runtime.fetch(
+      { url },
+      buildInspiredesignFetchOptions(
+        workflowInput,
+        buildInspiredesignStepEnvelope(workflowInput, stepTrace, index, url),
+        fetchTimeoutMs
+      )
+    );
+    observeWorkflowSignals(runtime, result);
+    failures.push(...result.failures);
+    const captureTimeoutMs = remainingTimeoutMs();
+    const capture = await captureInspiredesignReference(
+      url,
+      workflowInput.captureMode,
+      workflowInput,
+      options.captureReference,
+      captureTimeoutMs
+    );
+    references.push(buildInspiredesignReference(url, result, capture));
+    trace = appendWorkflowTrace(stepTrace, "execute", "reference_completed", {
+      stepIndex: index,
+      url,
+      fetchStatus: result.records.length > 0 ? "captured" : "failed",
+      captureStatus: capture.captureStatus
+    });
+  }
+  const packet = buildInspiredesignPacket({
+    brief: workflowInput.brief,
+    urls: workflowInput.urls,
+    references,
+    includePrototypeGuidance: workflowInput.includePrototypeGuidance
+  });
+  const meta = buildInspiredesignMeta(runtime, workflowInput, references, failures, packet.followthrough);
+  const rendered = renderInspiredesign({
+    mode: workflowInput.mode,
+    brief: workflowInput.brief,
+    urls: workflowInput.urls,
+    designContract: packet.designContract,
+    canvasPlanRequest: packet.canvasPlanRequest,
+    designAgentHandoff: packet.followthrough,
+    generationPlan: packet.generationPlan,
+    implementationPlan: packet.implementationPlan,
+    designMarkdown: packet.designMarkdown,
+    implementationPlanMarkdown: packet.implementationPlanMarkdown,
+    prototypeGuidanceMarkdown: packet.prototypeGuidanceMarkdown,
+    evidence: packet.evidence,
+    meta
+  });
+  const bundle = await createArtifactBundle({
+    namespace: "inspiredesign",
+    outputDir: workflowInput.outputDir,
+    ttlHours: workflowInput.ttlHours,
+    files: rendered.files
+  });
+  if (workflowInput.mode === "path") {
+    return {
+      ...rendered.response,
+      path: bundle.basePath,
+      meta: {
+        ...meta,
+        artifact_manifest: bundle.manifest
+      }
+    };
+  }
+  return {
+    ...rendered.response,
+    artifact_path: bundle.basePath,
     meta: {
       ...meta,
       artifact_manifest: bundle.manifest
@@ -13101,32 +15073,35 @@ var runProductVideoWorkflow = async (runtime, input, options = {}) => {
   const cookieDiagnostics = summarizeCookieDiagnostics(details.failures, details.records);
   const antiBotPressure = summarizeAntiBotPressure(details.failures);
   const primaryIssue = summarizePrimaryProviderIssue(details.failures);
+  const handoff = buildProductVideoSuccessHandoff();
+  const meta = withFollowthroughMeta({
+    alerts: buildWorkflowAlerts(runtime, details.failures),
+    failures: details.failures,
+    ...primaryIssue ? { primaryConstraintSummary: primaryIssue.summary } : {},
+    reasonCodeDistribution,
+    transcript_strategy_failures: transcriptStrategyFailures,
+    transcriptStrategyFailures,
+    transcript_strategy_detail_failures: transcriptStrategyFailures,
+    transcriptStrategyDetailFailures: transcriptStrategyFailures,
+    transcript_strategy_detail_distribution: transcriptStrategyDetailDistribution,
+    transcriptStrategyDetailDistribution,
+    transcript_durability: transcriptDurability,
+    transcriptDurability,
+    cookie_diagnostics: cookieDiagnostics,
+    cookieDiagnostics,
+    anti_bot_pressure: antiBotPressure,
+    antiBotPressure,
+    artifact_manifest: bundle.manifest
+  }, handoff);
   return {
+    ...handoff,
     path: bundle.basePath,
     manifest: manifestPayload,
     product: productPayload,
     pricing,
     screenshots: screenshotPaths,
     images: imagePaths,
-    meta: {
-      alerts: buildWorkflowAlerts(runtime, details.failures),
-      failures: details.failures,
-      ...primaryIssue ? { primaryConstraintSummary: primaryIssue.summary } : {},
-      reasonCodeDistribution,
-      transcript_strategy_failures: transcriptStrategyFailures,
-      transcriptStrategyFailures,
-      transcript_strategy_detail_failures: transcriptStrategyFailures,
-      transcriptStrategyDetailFailures: transcriptStrategyFailures,
-      transcript_strategy_detail_distribution: transcriptStrategyDetailDistribution,
-      transcriptStrategyDetailDistribution,
-      transcript_durability: transcriptDurability,
-      transcriptDurability,
-      cookie_diagnostics: cookieDiagnostics,
-      cookieDiagnostics,
-      anti_bot_pressure: antiBotPressure,
-      antiBotPressure,
-      artifact_manifest: bundle.manifest
-    }
+    meta
   };
 };
 
@@ -13140,6 +15115,7 @@ var DEFAULT_PROVIDER_SUSPENDED_INTENT_KIND = {
 var WORKFLOW_KIND_BY_SUSPENDED_INTENT_KIND2 = {
   "workflow.research": "research",
   "workflow.shopping": "shopping",
+  "workflow.inspiredesign": "inspiredesign",
   "workflow.product_video": "product_video"
 };
 var EXTENSION_FIRST_SOCIAL_FALLBACK_PLATFORMS = /* @__PURE__ */ new Set(["x", "reddit", "bluesky", "linkedin"]);
@@ -14586,6 +16562,14 @@ var ProviderRuntime = class {
             input
           )
         );
+      case "workflow.inspiredesign":
+        return runInspiredesignWorkflow(
+          this,
+          unwrapWorkflowResumeEnvelope(
+            WORKFLOW_KIND_BY_SUSPENDED_INTENT_KIND2[intent.kind],
+            input
+          )
+        );
       case "workflow.product_video":
         return runProductVideoWorkflow(
           this,
@@ -14743,25 +16727,38 @@ var ProviderRuntime = class {
   }
   async withTimeout(timeoutMs, task) {
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort("timeout");
-    }, timeoutMs);
+    const createTimeoutError = (cause) => {
+      return new ProviderRuntimeError("timeout", `Provider request timed out after ${timeoutMs}ms`, {
+        retryable: true,
+        ...cause !== void 0 ? { cause } : {}
+      });
+    };
+    const taskPromise = Promise.resolve().then(() => task(controller.signal));
+    const timeoutPromise = new Promise((_, reject) => {
+      const timeoutId = setTimeout(() => {
+        controller.abort("timeout");
+        reject(createTimeoutError());
+      }, timeoutMs);
+      controller.signal.addEventListener("abort", () => clearTimeout(timeoutId), { once: true });
+    });
     try {
-      const result = await task(controller.signal);
-      if (controller.signal.aborted) {
-        throw new ProviderRuntimeError("timeout", `Provider request timed out after ${timeoutMs}ms`);
-      }
-      return result;
+      return await Promise.race([
+        taskPromise.catch((error) => {
+          if (controller.signal.aborted) {
+            throw createTimeoutError(error);
+          }
+          throw error;
+        }),
+        timeoutPromise
+      ]);
     } catch (error) {
+      if (isProviderRuntimeError(error) && error.code === "timeout") {
+        throw error;
+      }
       if (controller.signal.aborted) {
-        throw new ProviderRuntimeError("timeout", `Provider request timed out after ${timeoutMs}ms`, {
-          retryable: true,
-          cause: error
-        });
+        throw createTimeoutError(error);
       }
       throw error;
-    } finally {
-      clearTimeout(timeoutId);
     }
   }
 };
@@ -15189,6 +17186,7 @@ var mergeBudgets = (base, partial) => {
 };
 
 export {
+  redactSensitive,
   createRequestId,
   stderrSink,
   setDefaultLogSink,
@@ -15204,6 +17202,7 @@ export {
   CHALLENGE_AUTOMATION_MODES,
   isChallengeAutomationMode,
   resolveChallengeAutomationPolicy,
+  inspectChallengePlanFromRuntime,
   ChallengeOrchestrator,
   summarizePrimaryProviderIssue,
   createTraceContext,
@@ -15242,15 +17241,19 @@ export {
   filterByTimebox,
   toResearchRecord,
   enrichResearchRecords,
+  INSPIREDESIGN_HANDOFF_COMMANDS,
+  INSPIREDESIGN_HANDOFF_GUIDANCE,
   renderResearch,
   renderShopping,
+  renderInspiredesign,
   workflowTestUtils,
   runResearchWorkflow,
   runShoppingWorkflow,
+  runInspiredesignWorkflow,
   runProductVideoWorkflow,
   DEFAULT_PROVIDER_BUDGETS,
   ProviderRuntime,
   createProviderRuntime,
   createDefaultRuntime
 };
-//# sourceMappingURL=chunk-5FZQJRBQ.js.map
+//# sourceMappingURL=chunk-ZE2E7ZGH.js.map