@spotpatch/runtime 1.12.0 → 1.14.0

package/dist/contextual-ask-panel.js

@@ -0,0 +1,1593 @@
+import {
+  getContextualAskExtension,
+  registerContextualAskExtension
+} from "./chunk-KIDHJQRG.js";
+import {
+  createButton,
+  createMarkedElement
+} from "./chunk-P6X75LO5.js";
+
+// src/controller/contextual-ask-workflow.ts
+import {
+  CONTEXTUAL_ASK_SCHEMA_VERSION as CONTEXTUAL_ASK_SCHEMA_VERSION2
+} from "@spotpatch/shared/contextual-ask-browser";
+
+// src/api/contextual-ask-api.ts
+import {
+  SPOTPATCH_ENDPOINTS,
+  SPOTPATCH_TOKEN_HEADER,
+  getAskJobEndpoint,
+  isErrorCode as isErrorCode2
+} from "@spotpatch/shared/contextual-ask-browser";
+
+// src/api/contextual-ask-response-validation.ts
+import {
+  ASK_ANSWER_WARNING_CODES,
+  ASK_FILE_COUNT_BUCKETS,
+  ASK_JOB_STATUSES,
+  ASK_READ_ACTIVITY_STATES,
+  ASK_SOURCE_CONFIDENCES,
+  CONTEXTUAL_ASK_EXECUTOR_KINDS,
+  CONTEXTUAL_ASK_EXECUTOR_STATES,
+  CONTEXTUAL_ASK_SCHEMA_VERSION,
+  isErrorCode
+} from "@spotpatch/shared/contextual-ask-browser";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, required, optional = []) {
+  const keys = Object.keys(value);
+  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+  return required.every((key) => key in value) && keys.every((key) => allowed.has(key));
+}
+function isEnum(value, values) {
+  return typeof value === "string" && values.includes(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isOpaqueId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 128 && /^[A-Za-z0-9_-]+$/u.test(value);
+}
+function isTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function isPositiveInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function isAskDomainError(value) {
+  return isErrorCode(value) && value.startsWith("ASK_");
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => isOpaqueId(item));
+}
+function unique(values) {
+  return new Set(values).size === values.length;
+}
+function isExecutorCapability(value) {
+  if (!isRecord(value) || !hasOnlyKeys(
+    value,
+    [
+      "executorId",
+      "kind",
+      "label",
+      "requestedModelLabel",
+      "effectiveModelLabel",
+      "state",
+      "providerDataConsentRequired",
+      "readOnlyProven"
+    ],
+    ["errorCode"]
+  ) || !isOpaqueId(value.executorId) || !isEnum(value.kind, CONTEXTUAL_ASK_EXECUTOR_KINDS) || !isNonEmptyString(value.label) || !isNonEmptyString(value.requestedModelLabel) || !isNonEmptyString(value.effectiveModelLabel) || !isEnum(value.state, CONTEXTUAL_ASK_EXECUTOR_STATES) || typeof value.providerDataConsentRequired !== "boolean" || typeof value.readOnlyProven !== "boolean" || value.errorCode !== void 0 && !isAskDomainError(value.errorCode)) {
+    return false;
+  }
+  return value.state === "ready" ? value.readOnlyProven && value.errorCode === void 0 : value.errorCode !== void 0;
+}
+function isContextualAskCapability(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "schemaVersion",
+    "enabled",
+    "executors",
+    "safety",
+    "checkedAt"
+  ]) || value.schemaVersion !== CONTEXTUAL_ASK_SCHEMA_VERSION || typeof value.enabled !== "boolean" || !Array.isArray(value.executors) || !value.executors.every(isExecutorCapability) || !isRecord(value.safety) || !hasOnlyKeys(value.safety, [
+    "selectionRequired",
+    "singleTurn",
+    "writesAllowed",
+    "historyStored"
+  ]) || value.safety.selectionRequired !== true || value.safety.singleTurn !== true || value.safety.writesAllowed !== false || value.safety.historyStored !== false || !isTimestamp(value.checkedAt)) {
+    return false;
+  }
+  const ids = value.executors.map((executor) => executor.executorId);
+  return (value.enabled || value.executors.length === 0) && unique(ids);
+}
+function isExecutorSnapshot(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["executorId", "kind", "label", "modelLabel"]) && isOpaqueId(value.executorId) && isEnum(value.kind, CONTEXTUAL_ASK_EXECUTOR_KINDS) && isNonEmptyString(value.label) && isNonEmptyString(value.modelLabel);
+}
+function isAskJobSnapshot(value) {
+  if (!isRecord(value) || !hasOnlyKeys(
+    value,
+    [
+      "schemaVersion",
+      "jobId",
+      "selectionId",
+      "status",
+      "executor",
+      "createdAt",
+      "updatedAt",
+      "canCancel"
+    ],
+    ["phaseMessage", "errorCode"]
+  ) || value.schemaVersion !== CONTEXTUAL_ASK_SCHEMA_VERSION || !isOpaqueId(value.jobId) || !isOpaqueId(value.selectionId) || !isEnum(value.status, ASK_JOB_STATUSES) || !isExecutorSnapshot(value.executor) || !isTimestamp(value.createdAt) || !isTimestamp(value.updatedAt) || Date.parse(value.updatedAt) < Date.parse(value.createdAt) || typeof value.canCancel !== "boolean" || value.phaseMessage !== void 0 && !isNonEmptyString(value.phaseMessage) || value.errorCode !== void 0 && !isAskDomainError(value.errorCode)) {
+    return false;
+  }
+  const cancellable = ["queued", "authorizing", "running"].includes(value.status);
+  if (value.canCancel !== cancellable) return false;
+  if (value.status === "cancelled") return value.errorCode === "ASK_CANCELLED";
+  if (value.status === "failed") {
+    return value.errorCode !== void 0 && value.errorCode !== "ASK_CANCELLED";
+  }
+  return value.errorCode === void 0;
+}
+function isSourceReference(value) {
+  if (!isRecord(value) || !hasOnlyKeys(
+    value,
+    [
+      "sourceId",
+      "label",
+      "relativePath",
+      "fileId",
+      "startLine",
+      "endLine",
+      "confidence",
+      "targetIds",
+      "contentHash"
+    ],
+    ["sourceVersion"]
+  ) || !isOpaqueId(value.sourceId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.relativePath) || value.relativePath.startsWith("/") || value.relativePath.includes("\\") || value.relativePath.split("/").some((part) => part === "" || part === "." || part === "..") || !isOpaqueId(value.fileId) || !isPositiveInteger(value.startLine) || !isPositiveInteger(value.endLine) || value.endLine < value.startLine || !isEnum(value.confidence, ASK_SOURCE_CONFIDENCES) || !isStringArray(value.targetIds) || value.targetIds.length === 0 || !unique(value.targetIds) || value.sourceVersion !== void 0 && !isNonEmptyString(value.sourceVersion) || typeof value.contentHash !== "string" || !/^[a-f0-9]{64}$/u.test(value.contentHash)) {
+    return false;
+  }
+  return true;
+}
+function isAnswerWarning(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["code"]) && isEnum(value.code, ASK_ANSWER_WARNING_CODES);
+}
+function isAnswerBlock(value) {
+  if (!isRecord(value) || typeof value.kind !== "string") return false;
+  if (value.kind === "paragraph") {
+    return hasOnlyKeys(value, ["kind", "text", "sourceIds"]) && isNonEmptyString(value.text) && isStringArray(value.sourceIds);
+  }
+  if (value.kind === "code") {
+    return hasOnlyKeys(value, ["kind", "code", "sourceIds"], ["language"]) && typeof value.code === "string" && value.code.length > 0 && isStringArray(value.sourceIds) && (value.language === void 0 || isNonEmptyString(value.language));
+  }
+  if (value.kind !== "list" || !hasOnlyKeys(value, ["kind", "items"])) return false;
+  return Array.isArray(value.items) && value.items.length > 0 && value.items.every(
+    (item) => isRecord(item) && hasOnlyKeys(item, ["text", "sourceIds"]) && isNonEmptyString(item.text) && isStringArray(item.sourceIds)
+  );
+}
+function isAnswerResult(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "schemaVersion",
+    "jobId",
+    "selectionId",
+    "contextHash",
+    "executor",
+    "blocks",
+    "sources",
+    "warnings",
+    "createdAt",
+    "expiresAt"
+  ]) || value.schemaVersion !== CONTEXTUAL_ASK_SCHEMA_VERSION || !isOpaqueId(value.jobId) || !isOpaqueId(value.selectionId) || typeof value.contextHash !== "string" || !/^[a-f0-9]{64}$/u.test(value.contextHash) || !isExecutorSnapshot(value.executor) || !Array.isArray(value.blocks) || value.blocks.length === 0 || !value.blocks.every(isAnswerBlock) || !Array.isArray(value.sources) || !value.sources.every(isSourceReference) || !Array.isArray(value.warnings) || !value.warnings.every(isAnswerWarning) || !isTimestamp(value.createdAt) || !isTimestamp(value.expiresAt) || Date.parse(value.expiresAt) <= Date.parse(value.createdAt)) {
+    return false;
+  }
+  const sources = value.sources.filter(isSourceReference);
+  const blocks = value.blocks.filter(isAnswerBlock);
+  const answerWarnings = value.warnings.filter(isAnswerWarning);
+  const sourceIds = sources.map((source) => source.sourceId);
+  if (!unique(sourceIds)) return false;
+  const available = new Set(sourceIds);
+  const references = blocks.flatMap(
+    (block) => block.kind === "list" ? block.items.flatMap((item) => item.sourceIds) : block.sourceIds
+  );
+  return references.every((sourceId) => available.has(sourceId)) && sourceIds.every((sourceId) => references.includes(sourceId)) && (references.length > 0 || answerWarnings.some((warning) => warning.code === "insufficient-evidence"));
+}
+function isAskJobResultResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["snapshot"], ["result"]) || !isAskJobSnapshot(value.snapshot) || value.result !== void 0 && !isAnswerResult(value.result)) {
+    return false;
+  }
+  const answered = value.snapshot.status === "answered";
+  return answered === (value.result !== void 0) && (value.result === void 0 || value.result.jobId === value.snapshot.jobId && value.result.selectionId === value.snapshot.selectionId && value.result.executor.executorId === value.snapshot.executor.executorId);
+}
+function isAskJobEvent(value) {
+  if (!isRecord(value) || !hasOnlyKeys(
+    value,
+    ["schemaVersion", "sequence", "jobId", "status", "timestamp", "type"],
+    ["snapshot", "message", "activity", "state", "errorCode"]
+  ) || value.schemaVersion !== CONTEXTUAL_ASK_SCHEMA_VERSION || !isPositiveInteger(value.sequence) || !isOpaqueId(value.jobId) || !isEnum(value.status, ASK_JOB_STATUSES) || !isTimestamp(value.timestamp)) {
+    return false;
+  }
+  if (value.type === "snapshot") {
+    return hasOnlyKeys(value, [
+      "schemaVersion",
+      "sequence",
+      "jobId",
+      "status",
+      "timestamp",
+      "type",
+      "snapshot"
+    ]) && isAskJobSnapshot(value.snapshot) && value.snapshot.jobId === value.jobId && value.snapshot.status === value.status;
+  }
+  if (value.type === "phase") {
+    return hasOnlyKeys(value, [
+      "schemaVersion",
+      "sequence",
+      "jobId",
+      "status",
+      "timestamp",
+      "type",
+      "message"
+    ]) && isNonEmptyString(value.message) && !["answered", "cancelled", "failed"].includes(value.status);
+  }
+  if (value.type === "answer-ready")
+    return hasOnlyKeys(value, [
+      "schemaVersion",
+      "sequence",
+      "jobId",
+      "status",
+      "timestamp",
+      "type"
+    ]) && value.status === "answered";
+  if (value.type === "error") {
+    return hasOnlyKeys(value, [
+      "schemaVersion",
+      "sequence",
+      "jobId",
+      "status",
+      "timestamp",
+      "type",
+      "errorCode"
+    ]) && isAskDomainError(value.errorCode) && (value.status === "cancelled" && value.errorCode === "ASK_CANCELLED" || value.status === "failed" && value.errorCode !== "ASK_CANCELLED");
+  }
+  if (value.type !== "read-activity" || !hasOnlyKeys(value, [
+    "schemaVersion",
+    "sequence",
+    "jobId",
+    "status",
+    "timestamp",
+    "type",
+    "activity",
+    "state"
+  ]) || value.status !== "running" || !isRecord(value.activity) || !isEnum(value.state, ASK_READ_ACTIVITY_STATES))
+    return false;
+  return value.activity.kind === "source" ? hasOnlyKeys(value.activity, ["kind", "sourceId", "relativePath"]) && isOpaqueId(value.activity.sourceId) && isNonEmptyString(value.activity.relativePath) : value.activity.kind === "file-count" && hasOnlyKeys(value.activity, ["kind", "bucket"]) && isEnum(value.activity.bucket, ASK_FILE_COUNT_BUCKETS);
+}
+
+// src/api/contextual-ask-api.ts
+var MAX_JSON_RESPONSE_BYTES = 2e6;
+var MAX_EVENT_LINE_BYTES = 1e5;
+var MAX_EVENT_STREAM_BYTES = 4e6;
+var ContextualAskApiError = class extends Error {
+  constructor(code) {
+    super("SpotPatch Contextual Ask request failed.");
+    this.code = code;
+    this.name = "ContextualAskApiError";
+  }
+  code;
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepFreezeUnknown(value) {
+  if (!isRecord2(value) && !Array.isArray(value) || Object.isFrozen(value)) return;
+  for (const nested of Object.values(value)) deepFreezeUnknown(nested);
+  Object.freeze(value);
+}
+function deepFreeze(value) {
+  deepFreezeUnknown(value);
+  return value;
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ContextualAskApiError();
+  }
+}
+async function readBoundedText(response, maximumBytes) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > maximumBytes) {
+    await response.body?.cancel();
+    throw new ContextualAskApiError();
+  }
+  if (response.body === null) throw new ContextualAskApiError();
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let bytes = 0;
+  let output = "";
+  try {
+    for (; ; ) {
+      const chunk = await reader.read();
+      if (chunk.done) return output + decoder.decode();
+      bytes += chunk.value.byteLength;
+      if (bytes > maximumBytes) {
+        await reader.cancel();
+        throw new ContextualAskApiError();
+      }
+      output += decoder.decode(chunk.value, { stream: true });
+    }
+  } catch (error) {
+    if (error instanceof ContextualAskApiError || error instanceof DOMException && error.name === "AbortError") {
+      throw error;
+    }
+    throw new ContextualAskApiError();
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function readEnvelope(response) {
+  const payload = parseJson(await readBoundedText(response, MAX_JSON_RESPONSE_BYTES));
+  if (!isRecord2(payload)) throw new ContextualAskApiError();
+  if (!response.ok) {
+    const code = payload.ok === false && isRecord2(payload.error) && isErrorCode2(payload.error.code) ? payload.error.code : void 0;
+    throw new ContextualAskApiError(code);
+  }
+  if (payload.ok !== true || !("data" in payload)) throw new ContextualAskApiError();
+  return payload.data;
+}
+function contextualAskApiErrorCode(error) {
+  return error instanceof ContextualAskApiError ? error.code : void 0;
+}
+function createContextualAskApi(options) {
+  const pending = /* @__PURE__ */ new Set();
+  function cancelPending() {
+    for (const controller of pending) controller.abort();
+    pending.clear();
+  }
+  async function request(endpoint, method, body) {
+    const controller = new AbortController();
+    pending.add(controller);
+    try {
+      const response = await options.fetch(endpoint, {
+        method,
+        headers: {
+          ...body === void 0 ? {} : { "Content-Type": "application/json" },
+          [SPOTPATCH_TOKEN_HEADER]: options.sessionToken
+        },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) },
+        signal: controller.signal
+      });
+      return await readEnvelope(response);
+    } finally {
+      pending.delete(controller);
+    }
+  }
+  async function events(jobId, afterSequence, onEvent) {
+    const controller = new AbortController();
+    pending.add(controller);
+    try {
+      const response = await options.fetch(
+        getAskJobEndpoint(jobId, "events", { afterSequence }),
+        {
+          method: "GET",
+          headers: { [SPOTPATCH_TOKEN_HEADER]: options.sessionToken },
+          signal: controller.signal
+        }
+      );
+      if (!response.ok) {
+        await readEnvelope(response);
+        return;
+      }
+      if (response.body === null) throw new ContextualAskApiError();
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder("utf-8", { fatal: true });
+      let buffer = "";
+      let totalBytes = 0;
+      let previousSequence = afterSequence;
+      const consumeLine = (line) => {
+        if (line.trim().length === 0) return;
+        if (new TextEncoder().encode(line).byteLength > MAX_EVENT_LINE_BYTES) {
+          throw new ContextualAskApiError();
+        }
+        const event = parseJson(line);
+        if (!isAskJobEvent(event) || event.jobId !== jobId || event.sequence <= previousSequence) {
+          throw new ContextualAskApiError();
+        }
+        previousSequence = event.sequence;
+        onEvent(deepFreeze(event));
+      };
+      try {
+        for (; ; ) {
+          const chunk = await reader.read();
+          if (chunk.done) {
+            consumeLine(buffer + decoder.decode());
+            return;
+          }
+          totalBytes += chunk.value.byteLength;
+          if (totalBytes > MAX_EVENT_STREAM_BYTES) {
+            await reader.cancel();
+            throw new ContextualAskApiError();
+          }
+          buffer += decoder.decode(chunk.value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          if (new TextEncoder().encode(buffer).byteLength > MAX_EVENT_LINE_BYTES) {
+            await reader.cancel();
+            throw new ContextualAskApiError();
+          }
+          for (const line of lines) consumeLine(line);
+        }
+      } catch (error) {
+        if (error instanceof ContextualAskApiError || error instanceof DOMException && error.name === "AbortError") {
+          throw error;
+        }
+        throw new ContextualAskApiError();
+      } finally {
+        reader.releaseLock();
+      }
+    } finally {
+      pending.delete(controller);
+    }
+  }
+  return Object.freeze({
+    async capability() {
+      const data = await request(SPOTPATCH_ENDPOINTS.askCapability, "GET");
+      if (!isContextualAskCapability(data)) throw new ContextualAskApiError();
+      return deepFreeze(data);
+    },
+    async cancelJob(jobId) {
+      const data = await request(getAskJobEndpoint(jobId, "cancel"), "POST", {});
+      if (!isAskJobSnapshot(data) || data.jobId !== jobId) {
+        throw new ContextualAskApiError();
+      }
+      return deepFreeze(data);
+    },
+    cancelPending,
+    async createJob(requestBody) {
+      const data = await request(SPOTPATCH_ENDPOINTS.askJobs, "POST", requestBody);
+      if (!isAskJobSnapshot(data) || data.selectionId !== requestBody.envelope.selection.selectionId || data.executor.executorId !== requestBody.executorId) {
+        throw new ContextualAskApiError();
+      }
+      return deepFreeze(data);
+    },
+    dispose: cancelPending,
+    events,
+    async result(jobId) {
+      const data = await request(getAskJobEndpoint(jobId, "result"), "GET");
+      if (!isAskJobResultResponse(data) || data.snapshot.jobId !== jobId) {
+        throw new ContextualAskApiError();
+      }
+      return deepFreeze(data);
+    }
+  });
+}
+
+// src/controller/contextual-ask-workflow.ts
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function createContextualAskWorkflow(input) {
+  let mounted = false;
+  let revision = 0;
+  let busy = false;
+  let currentSnapshot;
+  let currentResult;
+  let currentQuestion = "";
+  let capabilityLoaded = false;
+  let composing = false;
+  const consentByExecutor = /* @__PURE__ */ new Map();
+  const api = input.api ?? createContextualAskApi({
+    fetch: input.fetch,
+    sessionToken: input.sessionToken
+  });
+  function isCurrent(requestRevision) {
+    return mounted && revision === requestRevision;
+  }
+  function createEnvelope(question) {
+    const selection = input.getSelection();
+    if (question.length === 0 || question.length > 4e3 || selection === void 0) {
+      return void 0;
+    }
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      schemaVersion: CONTEXTUAL_ASK_SCHEMA_VERSION2,
+      taskId: input.createId(),
+      selection: {
+        schemaVersion: CONTEXTUAL_ASK_SCHEMA_VERSION2,
+        selectionId: input.createId(),
+        locale: selection.locale,
+        targets: selection.targets.map((snapshot) => ({
+          targetId: snapshot.id,
+          page: snapshot.page,
+          source: snapshot.source,
+          react: {
+            ...snapshot.react,
+            componentStack: [...snapshot.react.componentStack]
+          },
+          element: snapshot.element,
+          styles: {
+            ...snapshot.styles,
+            classNames: [...snapshot.styles.classNames],
+            matchedRules: snapshot.styles.matchedRules.map((rule) => ({ ...rule })),
+            computed: { ...snapshot.styles.computed },
+            warnings: [...snapshot.styles.warnings]
+          },
+          ...snapshot.code === void 0 ? {} : { code: snapshot.code },
+          warnings: []
+        })),
+        createdAt
+      },
+      task: { kind: "ask", question },
+      createdAt
+    };
+  }
+  async function loadCapability() {
+    if (capabilityLoaded) return;
+    const requestRevision = revision;
+    input.panel.renderCapability(void 0);
+    try {
+      const capability = await api.capability();
+      if (!isCurrent(requestRevision)) return;
+      capabilityLoaded = true;
+      input.panel.renderCapability(capability);
+      const executorId = input.panel.readExecutorId();
+      input.panel.setConsent(
+        executorId !== void 0 && consentByExecutor.get(executorId) === true
+      );
+    } catch (error) {
+      if (!isCurrent(requestRevision) || isAbortError(error)) return;
+      input.panel.renderError(contextualAskApiErrorCode(error));
+    }
+  }
+  function handleEvent(event, requestRevision) {
+    if (!isCurrent(requestRevision)) return;
+    input.panel.renderEvent(event);
+    if (event.type === "snapshot") currentSnapshot = event.snapshot;
+  }
+  async function submit() {
+    if (busy) return;
+    const question = input.panel.readQuestion();
+    const executorId = input.panel.readExecutorId();
+    const envelope = createEnvelope(question);
+    if (question.length === 0 || executorId === void 0 || !input.panel.readConsent() || envelope === void 0) {
+      return;
+    }
+    const requestRevision = ++revision;
+    currentQuestion = question;
+    busy = true;
+    input.onBusyChange(true);
+    currentResult = void 0;
+    currentSnapshot = void 0;
+    input.panel.setBusy(true);
+    try {
+      const snapshot = await api.createJob({
+        schemaVersion: CONTEXTUAL_ASK_SCHEMA_VERSION2,
+        requestId: input.createId(),
+        envelope,
+        executorId,
+        providerDataConsent: true
+      });
+      if (!isCurrent(requestRevision)) return;
+      currentSnapshot = snapshot;
+      input.panel.renderJob(snapshot);
+      await api.events(snapshot.jobId, 0, (event) => {
+        handleEvent(event, requestRevision);
+      });
+      if (!isCurrent(requestRevision)) return;
+      const response = await api.result(snapshot.jobId);
+      if (!isCurrent(requestRevision)) return;
+      currentSnapshot = response.snapshot;
+      busy = false;
+      input.onBusyChange(false);
+      if (response.result === void 0) {
+        input.panel.renderJob(response.snapshot);
+        if (response.snapshot.status === "failed") {
+          input.panel.renderError(response.snapshot.errorCode);
+        }
+        return;
+      }
+      currentResult = response.result;
+      input.panel.renderAnswer(response.result, false);
+    } catch (error) {
+      if (!isCurrent(requestRevision) || isAbortError(error)) return;
+      busy = false;
+      input.onBusyChange(false);
+      input.panel.renderError(contextualAskApiErrorCode(error));
+    } finally {
+      if (isCurrent(requestRevision)) {
+        busy = false;
+        input.panel.setBusy(false);
+      }
+    }
+  }
+  async function cancel() {
+    if (!busy || currentSnapshot?.canCancel !== true) return;
+    const requestRevision = revision;
+    try {
+      const snapshot = await api.cancelJob(currentSnapshot.jobId);
+      if (!isCurrent(requestRevision)) return;
+      currentSnapshot = snapshot;
+      busy = false;
+      input.onBusyChange(false);
+      input.panel.renderJob(snapshot);
+      input.panel.setBusy(false);
+    } catch (error) {
+      if (!isCurrent(requestRevision) || isAbortError(error)) return;
+      busy = false;
+      input.onBusyChange(false);
+      input.panel.renderError(contextualAskApiErrorCode(error));
+    }
+  }
+  function cancelPending() {
+    revision += 1;
+    const snapshot = currentSnapshot;
+    busy = false;
+    input.onBusyChange(false);
+    currentSnapshot = void 0;
+    api.cancelPending();
+    if (snapshot?.canCancel === true) {
+      void api.cancelJob(snapshot.jobId).catch(() => void 0);
+    }
+    input.panel.setBusy(false);
+  }
+  function newQuestion() {
+    if (busy) cancelPending();
+    revision += 1;
+    currentSnapshot = void 0;
+    currentResult = void 0;
+    currentQuestion = "";
+    input.panel.clear();
+    input.panel.focusQuestion();
+  }
+  function copyAnswer() {
+    const text = input.panel.answerPlainText();
+    if (text.length === 0 || input.clipboard === void 0) return;
+    void input.clipboard.writeText(text).then(() => {
+      input.panel.notify("copied");
+    }).catch(() => {
+      input.panel.notify("copy-failed");
+    });
+  }
+  function convert() {
+    if (currentResult === void 0 || busy) return;
+    const answerDigest = input.panel.answerPlainText().trim().slice(0, 4e3);
+    if (answerDigest.length === 0) return;
+    const origin = Object.freeze({
+      kind: "contextual-ask",
+      askJobId: currentResult.jobId,
+      question: currentQuestion,
+      answerDigest,
+      sourceIds: currentResult.sources.map((source) => source.sourceId)
+    });
+    input.onConvert(origin);
+    input.panel.setOrigin(origin);
+    input.panel.setMode("change");
+    input.panel.notify("converted");
+  }
+  function openSource(event) {
+    const sourceId = input.panel.selectedSourceId(event.target);
+    if (sourceId === void 0) return;
+    const source = input.panel.sourceById(sourceId);
+    if (source !== void 0) {
+      void input.onOpenSource(source).catch(() => {
+        input.panel.notify("source-open-failed");
+      });
+    }
+  }
+  function keydown(event) {
+    if (event.target !== input.panel.questionInput || event.key !== "Enter" || composing || event.isComposing || !event.metaKey && !event.ctrlKey) {
+      return;
+    }
+    event.preventDefault();
+    void submit();
+  }
+  function executorChanged() {
+    const executorId = input.panel.readExecutorId();
+    input.panel.setConsent(
+      executorId !== void 0 && consentByExecutor.get(executorId) === true
+    );
+  }
+  function compositionStart() {
+    composing = true;
+  }
+  function compositionEnd() {
+    composing = false;
+  }
+  function consentChanged() {
+    const executorId = input.panel.readExecutorId();
+    if (executorId !== void 0) {
+      consentByExecutor.set(executorId, input.panel.readConsent());
+    }
+  }
+  function submitClick() {
+    void submit();
+  }
+  function cancelClick() {
+    void cancel();
+  }
+  function mount() {
+    if (mounted) return;
+    mounted = true;
+    input.panel.submitButton.addEventListener("click", submitClick);
+    input.panel.cancelButton.addEventListener("click", cancelClick);
+    input.panel.newQuestionButton.addEventListener("click", newQuestion);
+    input.panel.copyButton.addEventListener("click", copyAnswer);
+    input.panel.convertButton.addEventListener("click", convert);
+    input.panel.executorSelect.addEventListener("change", executorChanged);
+    input.panel.consentCheckbox.addEventListener("change", consentChanged);
+    input.panel.questionInput.addEventListener("keydown", keydown);
+    input.panel.questionInput.addEventListener("compositionstart", compositionStart);
+    input.panel.questionInput.addEventListener("compositionend", compositionEnd);
+    input.panel.root.addEventListener("click", openSource);
+    void loadCapability();
+  }
+  function dispose() {
+    if (!mounted) return;
+    cancelPending();
+    mounted = false;
+    input.panel.submitButton.removeEventListener("click", submitClick);
+    input.panel.cancelButton.removeEventListener("click", cancelClick);
+    input.panel.newQuestionButton.removeEventListener("click", newQuestion);
+    input.panel.copyButton.removeEventListener("click", copyAnswer);
+    input.panel.convertButton.removeEventListener("click", convert);
+    input.panel.executorSelect.removeEventListener("change", executorChanged);
+    input.panel.consentCheckbox.removeEventListener("change", consentChanged);
+    input.panel.questionInput.removeEventListener("keydown", keydown);
+    input.panel.questionInput.removeEventListener("compositionstart", compositionStart);
+    input.panel.questionInput.removeEventListener("compositionend", compositionEnd);
+    input.panel.root.removeEventListener("click", openSource);
+    api.dispose();
+  }
+  return Object.freeze({
+    beginSelection() {
+      revision += 1;
+      busy = false;
+      input.onBusyChange(false);
+      currentSnapshot = void 0;
+      currentResult = void 0;
+      currentQuestion = "";
+      input.panel.clear();
+      void loadCapability();
+    },
+    cancelPending,
+    dispose,
+    isBusy: () => busy,
+    mount,
+    selectionChanged() {
+      if (currentResult !== void 0) input.panel.renderAnswer(currentResult, true);
+    }
+  });
+}
+
+// src/ui/contextual-ask-localization.ts
+var EN = Object.freeze({
+  mode: Object.freeze({ ask: "Ask", change: "Change", label: "Task mode" }),
+  title: "Ask about this selection",
+  subtitle: "One question, one sourced answer. SpotPatch will not write code.",
+  questionLabel: "Question",
+  questionPlaceholder: "What does this component do?",
+  suggestionsLabel: "Suggested questions",
+  suggestions: Object.freeze([
+    "What does this component do?",
+    "Where does its data come from?",
+    "Why is it implemented this way?"
+  ]),
+  executorLabel: "Read-only executor",
+  loadingExecutors: "Checking available executors\u2026",
+  noExecutor: "No verified read-only executor is available.",
+  unavailable: "unavailable",
+  consent: "Allow the selected source snapshot to be sent to this provider for this answer.",
+  dataSummary: (targets, sources) => `${String(targets)} selected element${targets === 1 ? "" : "s"} \xB7 ${String(sources)} source-backed`,
+  safety: "Single turn \xB7 read-only \xB7 no history",
+  submit: "Ask",
+  cancel: "Cancel",
+  newQuestion: "Start over",
+  copy: "Copy answer",
+  convert: "Turn into change request",
+  answerTitle: "Answer",
+  sourcesTitle: "Sources",
+  stale: "The selection changed after this answer. Ask again before relying on it.",
+  convertedTitle: "From contextual answer",
+  convertedBody: "The answer and source references remain local and have not started a change.",
+  status: Object.freeze({
+    queued: "Queued",
+    authorizing: "Verifying read-only access",
+    running: "Analyzing selected source",
+    cancelling: "Cancelling",
+    answered: "Answer ready",
+    cancelled: "Cancelled",
+    failed: "Could not answer"
+  }),
+  sourceLabel: (path, start, end) => `${path}:${String(start)}${end === start ? "" : `\u2013${String(end)}`}`,
+  readSource: (path) => `Reading ${path}`,
+  readFiles: (bucket) => `Reading ${bucket} files`,
+  copied: "Answer copied.",
+  copyFailed: "The answer could not be copied.",
+  sourceOpenFailed: "The source could not be opened.",
+  converted: "Switched to Change with the answer attached as local context.",
+  error: (code) => {
+    const errors = {
+      INVALID_TOKEN: "The local SpotPatch session expired. Refresh the page.",
+      ORIGIN_NOT_ALLOWED: "The local request failed its same-origin security check. Refresh or restart the dev server.",
+      ASK_DISABLED: "Contextual Ask is disabled.",
+      ASK_SELECTION_REQUIRED: "Select at least one element first.",
+      ASK_SELECTION_STALE: "The selected source changed. Refresh the selection and ask again.",
+      ASK_QUESTION_INVALID: "Enter one valid question.",
+      ASK_EXECUTOR_UNAVAILABLE: "The selected read-only executor is unavailable.",
+      ASK_TIMEOUT: "The read-only executor took too long to answer. Try the question again.",
+      ASK_CONSENT_REQUIRED: "Confirm provider data access for this answer.",
+      ASK_BUSY: "Another workspace task is active. Try again when it finishes.",
+      ASK_CANCELLED: "The question was cancelled.",
+      ASK_RESULT_EXPIRED: "This answer has expired. Ask again.",
+      ASK_WRITE_ATTEMPTED: "The executor attempted a write and was stopped.",
+      ASK_ANSWER_INVALID: "The executor returned an invalid sourced answer.",
+      ASK_PROTOCOL_INCOMPATIBLE: "The executor protocol is incompatible.",
+      ASK_LIMIT_EXCEEDED: "The selected context is too large.",
+      ASK_SOURCE_SCOPE_DENIED: "A requested source was outside the granted snapshot."
+    };
+    return code === void 0 ? "SpotPatch could not complete this question." : errors[code] ?? "SpotPatch could not complete this question.";
+  },
+  warning: (code) => code === "insufficient-evidence" ? "The selected source did not contain enough evidence for a complete answer." : "Some source references were omitted because they could not be verified."
+});
+var ZH = Object.freeze({
+  mode: Object.freeze({ ask: "\u95EE\u7B54", change: "\u4FEE\u6539", label: "\u4EFB\u52A1\u6A21\u5F0F" }),
+  title: "\u8BE2\u95EE\u6240\u9009\u5143\u7D20",
+  subtitle: "\u4E00\u6B21\u63D0\u95EE\uFF0C\u4E00\u6B21\u5E26\u6E90\u7801\u5F15\u7528\u7684\u56DE\u7B54\uFF1BSpotPatch \u4E0D\u4F1A\u5199\u5165\u4EE3\u7801\u3002",
+  questionLabel: "\u95EE\u9898",
+  questionPlaceholder: "\u8FD9\u4E2A\u7EC4\u4EF6\u662F\u505A\u4EC0\u4E48\u7684\uFF1F",
+  suggestionsLabel: "\u63A8\u8350\u95EE\u9898",
+  suggestions: Object.freeze([
+    "\u8FD9\u4E2A\u7EC4\u4EF6\u662F\u505A\u4EC0\u4E48\u7684\uFF1F",
+    "\u5B83\u7684\u6570\u636E\u4ECE\u54EA\u91CC\u6765\uFF1F",
+    "\u4E3A\u4EC0\u4E48\u8981\u8FD9\u6837\u5B9E\u73B0\uFF1F"
+  ]),
+  executorLabel: "\u53EA\u8BFB\u6267\u884C\u5668",
+  loadingExecutors: "\u6B63\u5728\u68C0\u67E5\u53EF\u7528\u6267\u884C\u5668\u2026",
+  noExecutor: "\u76EE\u524D\u6CA1\u6709\u901A\u8FC7\u53EA\u8BFB\u9A8C\u8BC1\u7684\u6267\u884C\u5668\u3002",
+  unavailable: "\u4E0D\u53EF\u7528",
+  consent: "\u5141\u8BB8\u672C\u6B21\u56DE\u7B54\u5C06\u6240\u9009\u6E90\u7801\u5FEB\u7167\u53D1\u9001\u7ED9\u8BE5\u63D0\u4F9B\u5546\u3002",
+  dataSummary: (targets, sources) => `${String(targets)} \u4E2A\u5DF2\u9009\u5143\u7D20 \xB7 ${String(sources)} \u4E2A\u5177\u5907\u6E90\u7801\u4E0A\u4E0B\u6587`,
+  safety: "\u5355\u8F6E \xB7 \u53EA\u8BFB \xB7 \u4E0D\u4FDD\u5B58\u5386\u53F2",
+  submit: "\u63D0\u95EE",
+  cancel: "\u53D6\u6D88",
+  newQuestion: "\u91CD\u65B0\u5F00\u59CB",
+  copy: "\u590D\u5236\u56DE\u7B54",
+  convert: "\u8F6C\u6210\u4FEE\u6539\u8BF7\u6C42",
+  answerTitle: "\u56DE\u7B54",
+  sourcesTitle: "\u6E90\u7801\u5F15\u7528",
+  stale: "\u56DE\u7B54\u540E\u9009\u62E9\u5DF2\u53D1\u751F\u53D8\u5316\u3002\u8BF7\u91CD\u65B0\u63D0\u95EE\u540E\u518D\u91C7\u4FE1\u6B64\u56DE\u7B54\u3002",
+  convertedTitle: "\u6765\u81EA\u4E0A\u4E0B\u6587\u95EE\u7B54",
+  convertedBody: "\u56DE\u7B54\u4E0E\u6E90\u7801\u5F15\u7528\u4EC5\u4F5C\u4E3A\u672C\u5730\u4E0A\u4E0B\u6587\u4FDD\u7559\uFF0C\u5C1A\u672A\u53D1\u8D77\u4EFB\u4F55\u4FEE\u6539\u3002",
+  status: Object.freeze({
+    queued: "\u5DF2\u6392\u961F",
+    authorizing: "\u6B63\u5728\u9A8C\u8BC1\u53EA\u8BFB\u6743\u9650",
+    running: "\u6B63\u5728\u5206\u6790\u6240\u9009\u6E90\u7801",
+    cancelling: "\u6B63\u5728\u53D6\u6D88",
+    answered: "\u56DE\u7B54\u5DF2\u5C31\u7EEA",
+    cancelled: "\u5DF2\u53D6\u6D88",
+    failed: "\u65E0\u6CD5\u56DE\u7B54"
+  }),
+  sourceLabel: (path, start, end) => `${path}:${String(start)}${end === start ? "" : `\u2013${String(end)}`}`,
+  readSource: (path) => `\u6B63\u5728\u8BFB\u53D6 ${path}`,
+  readFiles: (bucket) => `\u6B63\u5728\u8BFB\u53D6 ${bucket} \u4E2A\u6587\u4EF6`,
+  copied: "\u56DE\u7B54\u5DF2\u590D\u5236\u3002",
+  copyFailed: "\u65E0\u6CD5\u590D\u5236\u56DE\u7B54\u3002",
+  sourceOpenFailed: "\u65E0\u6CD5\u6253\u5F00\u6E90\u7801\u3002",
+  converted: "\u5DF2\u5207\u6362\u5230\u4FEE\u6539\u6A21\u5F0F\uFF0C\u5E76\u628A\u56DE\u7B54\u4F5C\u4E3A\u672C\u5730\u4E0A\u4E0B\u6587\u9644\u5E26\u3002",
+  error: (code) => {
+    const errors = {
+      INVALID_TOKEN: "\u672C\u5730 SpotPatch \u4F1A\u8BDD\u5DF2\u5931\u6548\uFF0C\u8BF7\u5237\u65B0\u9875\u9762\u3002",
+      ORIGIN_NOT_ALLOWED: "\u672C\u5730\u8BF7\u6C42\u672A\u901A\u8FC7\u540C\u6E90\u5B89\u5168\u6821\u9A8C\uFF0C\u8BF7\u5237\u65B0\u9875\u9762\u6216\u91CD\u542F\u5F00\u53D1\u670D\u52A1\u3002",
+      ASK_DISABLED: "\u4E0A\u4E0B\u6587\u95EE\u7B54\u672A\u542F\u7528\u3002",
+      ASK_SELECTION_REQUIRED: "\u8BF7\u5148\u9009\u62E9\u81F3\u5C11\u4E00\u4E2A\u5143\u7D20\u3002",
+      ASK_SELECTION_STALE: "\u6240\u9009\u6E90\u7801\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u5237\u65B0\u9009\u62E9\u540E\u91CD\u65B0\u63D0\u95EE\u3002",
+      ASK_QUESTION_INVALID: "\u8BF7\u8F93\u5165\u4E00\u4E2A\u6709\u6548\u7684\u95EE\u9898\u3002",
+      ASK_EXECUTOR_UNAVAILABLE: "\u6240\u9009\u53EA\u8BFB\u6267\u884C\u5668\u5F53\u524D\u4E0D\u53EF\u7528\u3002",
+      ASK_TIMEOUT: "\u53EA\u8BFB\u6267\u884C\u5668\u672A\u80FD\u5728\u9650\u5B9A\u65F6\u95F4\u5185\u8FD4\u56DE\u56DE\u7B54\uFF0C\u8BF7\u91CD\u65B0\u63D0\u95EE\u3002",
+      ASK_CONSENT_REQUIRED: "\u8BF7\u786E\u8BA4\u672C\u6B21\u56DE\u7B54\u7684\u63D0\u4F9B\u5546\u6570\u636E\u8BBF\u95EE\u3002",
+      ASK_BUSY: "\u5DE5\u4F5C\u533A\u6B63\u5728\u6267\u884C\u5176\u4ED6\u4EFB\u52A1\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002",
+      ASK_CANCELLED: "\u672C\u6B21\u63D0\u95EE\u5DF2\u53D6\u6D88\u3002",
+      ASK_RESULT_EXPIRED: "\u56DE\u7B54\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u63D0\u95EE\u3002",
+      ASK_WRITE_ATTEMPTED: "\u6267\u884C\u5668\u5C1D\u8BD5\u5199\u5165\uFF0C\u5DF2\u88AB\u963B\u6B62\u3002",
+      ASK_ANSWER_INVALID: "\u6267\u884C\u5668\u8FD4\u56DE\u7684\u5E26\u5F15\u7528\u56DE\u7B54\u65E0\u6548\u3002",
+      ASK_PROTOCOL_INCOMPATIBLE: "\u6267\u884C\u5668\u534F\u8BAE\u4E0D\u517C\u5BB9\u3002",
+      ASK_LIMIT_EXCEEDED: "\u6240\u9009\u4E0A\u4E0B\u6587\u8FC7\u5927\u3002",
+      ASK_SOURCE_SCOPE_DENIED: "\u8BF7\u6C42\u7684\u6E90\u7801\u8D85\u51FA\u4E86\u6388\u6743\u5FEB\u7167\u8303\u56F4\u3002"
+    };
+    return code === void 0 ? "SpotPatch \u672A\u80FD\u5B8C\u6210\u672C\u6B21\u63D0\u95EE\u3002" : errors[code] ?? "SpotPatch \u672A\u80FD\u5B8C\u6210\u672C\u6B21\u63D0\u95EE\u3002";
+  },
+  warning: (code) => code === "insufficient-evidence" ? "\u6240\u9009\u6E90\u7801\u4E0D\u8DB3\u4EE5\u652F\u6301\u5B8C\u6574\u56DE\u7B54\u3002" : "\u90E8\u5206\u6E90\u7801\u5F15\u7528\u56E0\u65E0\u6CD5\u9A8C\u8BC1\u800C\u88AB\u7701\u7565\u3002"
+});
+function contextualAskMessages(locale) {
+  return locale === "zh-CN" ? ZH : EN;
+}
+
+// src/ui/contextual-ask-panel.ts
+function createStyles(document) {
+  const style = document.createElement("style");
+  style.textContent = `
+    .spotpatch-ask-mode { display: grid; grid-template-columns: 1fr 1fr; gap: 4px; margin-bottom: 14px; padding: 4px; border: 1px solid var(--spotpatch-border-subtle); border-radius: 10px; background: #0a0a0e; }
+    .spotpatch-ask-mode button { min-height: 34px; border: 0; border-radius: 7px; color: var(--spotpatch-text-secondary); background: transparent; cursor: pointer; font-size: 12px; font-weight: 700; }
+    .spotpatch-ask-mode button[aria-selected="true"] { color: #f7f7ff; background: linear-gradient(135deg, rgb(139 123 255 / 25%), rgb(82 168 255 / 14%)); box-shadow: inset 0 0 0 1px rgb(139 123 255 / 24%); }
+    .spotpatch-ask-panel { display: grid; gap: 14px; }
+    .spotpatch-ask-field { display: grid; gap: 7px; }
+    .spotpatch-ask-field > label, .spotpatch-ask-label { color: #c9cad2; font-size: 11px; font-weight: 680; }
+    .spotpatch-ask-question { box-sizing: border-box; width: 100%; min-height: 92px; resize: vertical; border: 1px solid var(--spotpatch-border); border-radius: 10px; padding: 11px 12px; outline: none; color: var(--spotpatch-text); background: var(--spotpatch-bg-input); line-height: 1.55; }
+    .spotpatch-ask-question:focus { border-color: rgb(139 123 255 / 68%); box-shadow: 0 0 0 3px rgb(139 123 255 / 12%); }
+    .spotpatch-ask-suggestions { display: flex; flex-wrap: wrap; gap: 6px; }
+    .spotpatch-ask-suggestions button { border: 1px solid var(--spotpatch-border-subtle); border-radius: 999px; padding: 5px 9px; color: var(--spotpatch-text-secondary); background: rgb(255 255 255 / 2%); cursor: pointer; font-size: 10.5px; }
+    .spotpatch-ask-suggestions button:hover { border-color: rgb(139 123 255 / 42%); color: #fff; }
+    .spotpatch-ask-executor-picker { display: grid; gap: 5px; min-width: 0; }
+    .spotpatch-ask-executor { box-sizing: border-box; display: flex; width: 100%; min-height: 38px; align-items: center; justify-content: space-between; gap: 10px; border: 1px solid var(--spotpatch-border); border-radius: 9px; padding: 0 11px; overflow: hidden; color: var(--spotpatch-text); background: var(--spotpatch-bg-input); cursor: pointer; font: inherit; outline: none; text-align: left; }
+    .spotpatch-ask-executor > span { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .spotpatch-ask-executor[data-expandable="true"]::after { width: 7px; height: 7px; flex: 0 0 auto; border-right: 1.5px solid #8f96a3; border-bottom: 1.5px solid #8f96a3; content: ""; transform: translateY(-2px) rotate(45deg); }
+    .spotpatch-ask-executor[aria-expanded="true"]::after { transform: translateY(2px) rotate(225deg); }
+    .spotpatch-ask-executor:focus-visible { border-color: rgb(139 123 255 / 68%); box-shadow: 0 0 0 3px rgb(139 123 255 / 12%); }
+    .spotpatch-ask-executor:disabled { color: var(--spotpatch-text); background: rgb(255 255 255 / 3%); cursor: default; opacity: 1; }
+    .spotpatch-ask-executor[data-empty="true"]:disabled { color: var(--spotpatch-text-muted); }
+    .spotpatch-ask-executor-menu { display: grid; gap: 3px; border: 1px solid var(--spotpatch-border); border-radius: 9px; padding: 4px; background: #101116; box-shadow: 0 10px 28px rgb(0 0 0 / 28%); }
+    .spotpatch-ask-executor-menu[hidden] { display: none; }
+    .spotpatch-ask-executor-option { box-sizing: border-box; min-height: 34px; border: 0; border-radius: 6px; padding: 7px 9px; color: var(--spotpatch-text-secondary); background: transparent; cursor: pointer; font: inherit; text-align: left; }
+    .spotpatch-ask-executor-option:hover, .spotpatch-ask-executor-option:focus-visible { color: #fff; background: rgb(139 123 255 / 13%); outline: none; }
+    .spotpatch-ask-executor-option[aria-selected="true"] { color: #f4f1ff; background: rgb(139 123 255 / 20%); }
+    .spotpatch-ask-executor-native { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; border: 0; clip: rect(0 0 0 0); clip-path: inset(50%); white-space: nowrap; }
+    .spotpatch-ask-executor-status { margin: 0; border-left: 2px solid var(--spotpatch-warning); padding-left: 8px; color: #d8b66c; font-size: 10.5px; line-height: 1.45; }
+    .spotpatch-ask-safety { display: grid; gap: 8px; border: 1px solid rgb(82 168 255 / 16%); border-radius: 10px; padding: 10px 11px; background: rgb(82 168 255 / 4%); }
+    .spotpatch-ask-data { display: flex; justify-content: space-between; gap: 10px; color: #aab3c2; font-size: 10.5px; }
+    .spotpatch-ask-data strong { color: #9fe3c4; font-weight: 650; white-space: nowrap; }
+    .spotpatch-ask-consent { display: grid; grid-template-columns: 16px 1fr; gap: 8px; align-items: start; color: var(--spotpatch-text-secondary); cursor: pointer; font-size: 10.5px; line-height: 1.45; }
+    .spotpatch-ask-consent input { margin: 2px 0 0; accent-color: var(--spotpatch-accent); }
+    .spotpatch-ask-actions, .spotpatch-ask-answer-actions { display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 7px; }
+    .spotpatch-ask-actions button, .spotpatch-ask-answer-actions button { min-height: 34px; border: 1px solid var(--spotpatch-border); border-radius: 8px; padding: 0 12px; color: #d6d6de; background: var(--spotpatch-bg-raised); cursor: pointer; font-size: 11px; font-weight: 680; }
+    .spotpatch-ask-actions .spotpatch-primary, .spotpatch-ask-answer-actions .spotpatch-primary { border-color: transparent; color: var(--spotpatch-text-on-accent); background: linear-gradient(135deg, #a99cff, #65b7ff); }
+    .spotpatch-ask-actions button:disabled, .spotpatch-ask-answer-actions button:disabled { opacity: .45; cursor: not-allowed; }
+    .spotpatch-ask-status { display: grid; gap: 7px; border-left: 2px solid var(--spotpatch-accent); padding: 2px 0 2px 10px; color: #c8c9d2; font-size: 11px; }
+    .spotpatch-ask-activity { display: grid; gap: 4px; color: var(--spotpatch-text-muted); font: 500 10px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace; }
+    .spotpatch-ask-error, .spotpatch-ask-stale, .spotpatch-ask-warning { border-radius: 8px; padding: 9px 10px; font-size: 10.5px; }
+    .spotpatch-ask-error { color: #fecaca; background: rgb(251 113 133 / 9%); }
+    .spotpatch-ask-stale, .spotpatch-ask-warning { color: #f9d68a; background: rgb(245 158 11 / 8%); }
+    .spotpatch-ask-answer { display: grid; gap: 12px; border: 1px solid var(--spotpatch-border-subtle); border-radius: 11px; padding: 12px; background: var(--spotpatch-bg); box-shadow: 0 12px 30px rgb(0 0 0 / 18%); }
+    .spotpatch-ask-answer h3, .spotpatch-ask-sources h4 { margin: 0; color: var(--spotpatch-text); font-size: 13px; }
+    .spotpatch-ask-blocks { display: grid; gap: 10px; color: #d9dae2; font-size: 12px; line-height: 1.65; overflow-wrap: anywhere; }
+    .spotpatch-ask-blocks p, .spotpatch-ask-blocks ul { margin: 0; }
+    .spotpatch-ask-blocks ul { padding-left: 18px; }
+    .spotpatch-ask-blocks pre { max-width: 100%; overflow: auto; margin: 0; border: 1px solid var(--spotpatch-border-subtle); border-radius: 9px; padding: 10px; color: #dbeafe; background: #08090d; font: 500 10.5px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace; }
+    .spotpatch-ask-citations, .spotpatch-ask-source-list { display: flex; flex-wrap: wrap; gap: 5px; }
+    .spotpatch-ask-source { max-width: 100%; overflow: hidden; border: 1px solid rgb(82 168 255 / 22%); border-radius: 999px; padding: 4px 8px; color: #b8dcff; background: rgb(82 168 255 / 7%); cursor: pointer; font: 550 9.5px/1.3 ui-monospace, SFMono-Regular, Menlo, monospace; text-overflow: ellipsis; white-space: nowrap; }
+    .spotpatch-ask-sources { display: grid; gap: 7px; }
+    .spotpatch-ask-origin { margin-bottom: 12px; border: 1px solid rgb(139 123 255 / 22%); border-radius: 10px; padding: 10px 11px; color: var(--spotpatch-text-secondary); background: rgb(139 123 255 / 6%); font-size: 10.5px; }
+    .spotpatch-ask-origin strong { display: block; margin-bottom: 2px; color: #d9d4ff; font-size: 11px; }
+    @media (max-width: 420px) { .spotpatch-ask-data { display: grid; } .spotpatch-ask-actions, .spotpatch-ask-answer-actions { justify-content: stretch; } .spotpatch-ask-actions button, .spotpatch-ask-answer-actions button { flex: 1 1 auto; } }
+    @media (prefers-reduced-motion: reduce) { .spotpatch-ask-panel *, .spotpatch-ask-mode * { scroll-behavior: auto !important; transition: none !important; } }
+  `;
+  return style;
+}
+function appendSourceChips(document, root, sourceIds, sources, messages) {
+  if (sourceIds.length === 0) return;
+  const chips = createMarkedElement(document, "div");
+  chips.className = "spotpatch-ask-citations";
+  for (const sourceId of sourceIds) {
+    const source = sources.get(sourceId);
+    if (source === void 0) continue;
+    const chip = createButton(
+      document,
+      messages.sourceLabel(source.relativePath, source.startLine, source.endLine),
+      "spotpatch-ask-source"
+    );
+    chip.dataset.askSourceId = source.sourceId;
+    chip.title = source.label;
+    chips.append(chip);
+  }
+  root.append(chips);
+}
+function createContextualAskPanel(input) {
+  const { document } = input;
+  let messages = contextualAskMessages(input.locale());
+  let currentMode = "change";
+  let currentCapability;
+  let currentResult;
+  let currentJob;
+  let reportedMode;
+  let reportedTitle = "";
+  let reportedSubtitle = "";
+  let currentPreview = Object.freeze({
+    contextReady: false,
+    targetCount: 0,
+    sourceCount: 0
+  });
+  let busy = false;
+  const root = createMarkedElement(document, "section");
+  const modeSwitch = createMarkedElement(document, "div");
+  modeSwitch.className = "spotpatch-ask-mode";
+  modeSwitch.setAttribute("role", "tablist");
+  const askTab = createButton(document, "");
+  const changeTab = createButton(document, "");
+  askTab.setAttribute("role", "tab");
+  changeTab.setAttribute("role", "tab");
+  modeSwitch.append(askTab, changeTab);
+  const origin = createMarkedElement(document, "aside");
+  origin.className = "spotpatch-ask-origin";
+  origin.hidden = true;
+  const originTitle = createMarkedElement(document, "strong");
+  const originBody = createMarkedElement(document, "span");
+  origin.append(originTitle, originBody);
+  const askPanel = createMarkedElement(document, "div");
+  askPanel.className = "spotpatch-ask-panel";
+  const questionField = createMarkedElement(document, "div");
+  questionField.className = "spotpatch-ask-field";
+  const questionLabel = createMarkedElement(document, "label");
+  const questionId = `spotpatch-ask-question-${Math.random().toString(36).slice(2)}`;
+  questionLabel.htmlFor = questionId;
+  const questionInput = createMarkedElement(document, "textarea");
+  questionInput.id = questionId;
+  questionInput.className = "spotpatch-ask-question";
+  questionInput.maxLength = 4e3;
+  const suggestions = createMarkedElement(document, "div");
+  suggestions.className = "spotpatch-ask-suggestions";
+  suggestions.setAttribute("aria-label", "");
+  questionField.append(questionLabel, questionInput, suggestions);
+  const executorField = createMarkedElement(document, "div");
+  executorField.className = "spotpatch-ask-field";
+  const executorLabel = createMarkedElement(document, "label");
+  const executorPicker = createMarkedElement(document, "div");
+  executorPicker.className = "spotpatch-ask-executor-picker";
+  const executorTrigger = createButton(document, "", "spotpatch-ask-executor");
+  const executorSelect = createMarkedElement(document, "select");
+  const executorId = `spotpatch-ask-executor-${Math.random().toString(36).slice(2)}`;
+  const executorMenuId = `${executorId}-menu`;
+  executorTrigger.id = executorId;
+  executorTrigger.setAttribute("role", "combobox");
+  executorTrigger.setAttribute("aria-controls", executorMenuId);
+  executorTrigger.setAttribute("aria-expanded", "false");
+  const executorText = createMarkedElement(document, "span");
+  executorTrigger.append(executorText);
+  const executorMenu = createMarkedElement(document, "div");
+  executorMenu.id = executorMenuId;
+  executorMenu.className = "spotpatch-ask-executor-menu";
+  executorMenu.setAttribute("role", "listbox");
+  executorMenu.hidden = true;
+  executorSelect.className = "spotpatch-ask-executor-native";
+  executorSelect.tabIndex = -1;
+  executorSelect.setAttribute("aria-hidden", "true");
+  executorLabel.htmlFor = executorId;
+  const executorStatus = createMarkedElement(document, "p");
+  executorStatus.className = "spotpatch-ask-executor-status";
+  executorStatus.setAttribute("role", "status");
+  executorStatus.hidden = true;
+  executorPicker.append(executorTrigger, executorMenu, executorSelect);
+  executorField.append(executorLabel, executorPicker, executorStatus);
+  const safety = createMarkedElement(document, "div");
+  safety.className = "spotpatch-ask-safety";
+  const dataSummary = createMarkedElement(document, "div");
+  dataSummary.className = "spotpatch-ask-data";
+  const dataText = createMarkedElement(document, "span");
+  const safetyText = createMarkedElement(document, "strong");
+  dataSummary.append(dataText, safetyText);
+  const consentLabel = createMarkedElement(document, "label");
+  consentLabel.className = "spotpatch-ask-consent";
+  const consentCheckbox = createMarkedElement(document, "input");
+  consentCheckbox.type = "checkbox";
+  const consentText = createMarkedElement(document, "span");
+  consentLabel.append(consentCheckbox, consentText);
+  safety.append(dataSummary, consentLabel);
+  const status = createMarkedElement(document, "div");
+  status.className = "spotpatch-ask-status";
+  status.setAttribute("role", "status");
+  status.setAttribute("aria-live", "polite");
+  status.hidden = true;
+  const statusText = createMarkedElement(document, "strong");
+  const activities = createMarkedElement(document, "div");
+  activities.className = "spotpatch-ask-activity";
+  status.append(statusText, activities);
+  const error = createMarkedElement(document, "div");
+  error.className = "spotpatch-ask-error";
+  error.setAttribute("role", "alert");
+  error.hidden = true;
+  const actions = createMarkedElement(document, "div");
+  actions.className = "spotpatch-ask-actions";
+  const newQuestionButton = createButton(document, "");
+  const cancelButton = createButton(document, "");
+  const submitButton = createButton(document, "", "spotpatch-primary");
+  cancelButton.hidden = true;
+  actions.append(newQuestionButton, cancelButton, submitButton);
+  const answer = createMarkedElement(document, "article");
+  answer.className = "spotpatch-ask-answer";
+  answer.hidden = true;
+  const stale = createMarkedElement(document, "div");
+  stale.className = "spotpatch-ask-stale";
+  stale.hidden = true;
+  const answerTitle = createMarkedElement(document, "h3");
+  const warnings = createMarkedElement(document, "div");
+  const blocks = createMarkedElement(document, "div");
+  blocks.className = "spotpatch-ask-blocks";
+  const sourcesSection = createMarkedElement(document, "section");
+  sourcesSection.className = "spotpatch-ask-sources";
+  const sourcesTitle = createMarkedElement(document, "h4");
+  const sourceList = createMarkedElement(document, "div");
+  sourceList.className = "spotpatch-ask-source-list";
+  sourcesSection.append(sourcesTitle, sourceList);
+  const answerActions = createMarkedElement(document, "div");
+  answerActions.className = "spotpatch-ask-answer-actions";
+  const copyButton = createButton(document, "");
+  const convertButton = createButton(document, "", "spotpatch-primary");
+  answerActions.append(copyButton, convertButton);
+  answer.append(stale, answerTitle, warnings, blocks, sourcesSection, answerActions);
+  askPanel.append(questionField, executorField, safety, status, error, actions, answer);
+  root.append(modeSwitch, origin, askPanel);
+  function hasReadyExecutor() {
+    const selected = currentCapability?.executors.find(
+      (candidate) => candidate.executorId === executorSelect.value
+    );
+    return selected?.state === "ready" && selected.readOnlyProven;
+  }
+  function hasAnyReadyExecutor() {
+    return currentCapability?.executors.some(
+      (candidate) => candidate.state === "ready" && candidate.readOnlyProven
+    ) === true;
+  }
+  function readyExecutorCount() {
+    return currentCapability?.executors.filter(
+      (candidate) => candidate.state === "ready" && candidate.readOnlyProven
+    ).length ?? 0;
+  }
+  function closeExecutorMenu(focusTrigger = false) {
+    if (executorMenu.hidden) return;
+    executorMenu.hidden = true;
+    executorTrigger.setAttribute("aria-expanded", "false");
+    if (focusTrigger) executorTrigger.focus({ preventScroll: true });
+    input.onViewChange();
+  }
+  function openExecutorMenu(focusSelected = false) {
+    if (executorTrigger.disabled || !executorMenu.hidden) return;
+    executorMenu.hidden = false;
+    executorTrigger.setAttribute("aria-expanded", "true");
+    if (focusSelected) {
+      const selected = executorMenu.querySelector(
+        '.spotpatch-ask-executor-option[aria-selected="true"]'
+      );
+      const first = executorMenu.firstElementChild;
+      const focusTarget = selected ?? (first instanceof HTMLElement ? first : null);
+      focusTarget?.focus({ preventScroll: true });
+    }
+    input.onViewChange();
+  }
+  function syncExecutorControl() {
+    const selectedOption = [...executorSelect.options].find(
+      (option) => option.value === executorSelect.value
+    );
+    executorText.textContent = selectedOption?.textContent ?? messages.noExecutor;
+    executorTrigger.dataset.empty = String(executorSelect.value.length === 0);
+    for (const option of executorMenu.querySelectorAll(
+      ".spotpatch-ask-executor-option"
+    )) {
+      option.setAttribute(
+        "aria-selected",
+        String(option.dataset.executorId === executorSelect.value)
+      );
+    }
+  }
+  function refreshSubmitState() {
+    submitButton.disabled = busy || questionInput.value.trim().length === 0 || !hasReadyExecutor() || !consentCheckbox.checked || currentPreview.targetCount === 0;
+    if (!currentPreview.contextReady) submitButton.disabled = true;
+    questionInput.disabled = busy;
+    const readyCount = readyExecutorCount();
+    const executorUnavailable = busy || currentCapability === void 0 || !hasAnyReadyExecutor();
+    executorSelect.disabled = executorUnavailable;
+    executorTrigger.disabled = executorUnavailable || readyCount < 2;
+    executorTrigger.dataset.expandable = String(!executorUnavailable && readyCount > 1);
+    if (executorTrigger.disabled) closeExecutorMenu();
+    consentCheckbox.disabled = busy || !hasReadyExecutor();
+    newQuestionButton.hidden = busy || currentResult === void 0;
+    cancelButton.hidden = !busy;
+  }
+  function applyMode() {
+    const asking = currentMode === "ask";
+    askTab.setAttribute("aria-selected", String(asking));
+    changeTab.setAttribute("aria-selected", String(!asking));
+    askPanel.hidden = !asking;
+    input.changeRoot.hidden = asking;
+    input.changeActions.hidden = asking;
+    origin.hidden = asking || origin.dataset.active !== "true";
+    if (reportedMode !== currentMode || reportedTitle !== messages.title || reportedSubtitle !== messages.subtitle) {
+      reportedMode = currentMode;
+      reportedTitle = messages.title;
+      reportedSubtitle = messages.subtitle;
+      input.onModeChange(currentMode, messages.title, messages.subtitle);
+    }
+    input.onViewChange();
+  }
+  function renderSuggestions() {
+    suggestions.replaceChildren();
+    for (const suggestion of messages.suggestions) {
+      const button = createButton(document, suggestion);
+      button.type = "button";
+      button.addEventListener("click", () => {
+        questionInput.value = suggestion;
+        refreshSubmitState();
+        questionInput.focus();
+      });
+      suggestions.append(button);
+    }
+  }
+  function applyMessages() {
+    messages = contextualAskMessages(input.locale());
+    modeSwitch.setAttribute("aria-label", messages.mode.label);
+    askTab.textContent = messages.mode.ask;
+    changeTab.textContent = messages.mode.change;
+    questionLabel.textContent = messages.questionLabel;
+    questionInput.placeholder = messages.questionPlaceholder;
+    suggestions.setAttribute("aria-label", messages.suggestionsLabel);
+    executorLabel.textContent = messages.executorLabel;
+    consentText.textContent = messages.consent;
+    safetyText.textContent = messages.safety;
+    submitButton.textContent = messages.submit;
+    cancelButton.textContent = messages.cancel;
+    newQuestionButton.textContent = messages.newQuestion;
+    copyButton.textContent = messages.copy;
+    convertButton.textContent = messages.convert;
+    answerTitle.textContent = messages.answerTitle;
+    sourcesTitle.textContent = messages.sourcesTitle;
+    stale.textContent = messages.stale;
+    originTitle.textContent = messages.convertedTitle;
+    originBody.textContent = messages.convertedBody;
+    dataText.textContent = messages.dataSummary(
+      currentPreview.targetCount,
+      currentPreview.sourceCount
+    );
+    renderSuggestions();
+    renderCapability(currentCapability);
+    if (currentResult !== void 0) renderAnswer(currentResult, !stale.hidden);
+  }
+  function renderCapability(capability) {
+    currentCapability = capability;
+    const previous = executorSelect.value;
+    executorSelect.replaceChildren();
+    executorMenu.replaceChildren();
+    closeExecutorMenu();
+    executorStatus.hidden = true;
+    executorStatus.textContent = "";
+    if (capability === void 0) {
+      const option = document.createElement("option");
+      option.textContent = messages.loadingExecutors;
+      option.value = "";
+      executorSelect.append(option);
+    } else if (!capability.enabled || capability.executors.length === 0) {
+      const option = document.createElement("option");
+      option.textContent = messages.noExecutor;
+      option.value = "";
+      executorSelect.append(option);
+    } else {
+      const readyExecutors = capability.executors.filter(
+        (executor) => executor.state === "ready" && executor.readOnlyProven
+      );
+      const unavailableExecutors = capability.executors.filter(
+        (executor) => executor.state !== "ready" || !executor.readOnlyProven
+      );
+      for (const executor of readyExecutors) {
+        const option = document.createElement("option");
+        option.value = executor.executorId;
+        option.textContent = `${executor.label} \xB7 ${executor.effectiveModelLabel}`;
+        executorSelect.append(option);
+        const menuOption = createButton(
+          document,
+          option.textContent,
+          "spotpatch-ask-executor-option"
+        );
+        menuOption.dataset.executorId = executor.executorId;
+        menuOption.setAttribute("role", "option");
+        menuOption.addEventListener("click", () => {
+          executorSelect.value = executor.executorId;
+          syncExecutorControl();
+          closeExecutorMenu(true);
+          executorSelect.dispatchEvent(new Event("change", { bubbles: true }));
+        });
+        executorMenu.append(menuOption);
+      }
+      if (readyExecutors.length === 0) {
+        const option = document.createElement("option");
+        option.textContent = messages.noExecutor;
+        option.value = "";
+        executorSelect.append(option);
+      }
+      executorSelect.value = readyExecutors.some(
+        (executor) => executor.executorId === previous
+      ) ? previous : readyExecutors[0]?.executorId ?? "";
+      if (unavailableExecutors.length > 0) {
+        executorStatus.textContent = unavailableExecutors.map((executor) => `${executor.label}: ${messages.error(executor.errorCode)}`).join(" ");
+        executorStatus.hidden = false;
+      }
+    }
+    syncExecutorControl();
+    refreshSubmitState();
+  }
+  function renderJob(snapshot) {
+    currentJob = snapshot;
+    status.hidden = false;
+    error.hidden = true;
+    statusText.textContent = messages.status[snapshot.status];
+    if (["answered", "cancelled", "failed"].includes(snapshot.status)) {
+      busy = false;
+      input.onExecutionChange();
+    } else {
+      input.onExecutionChange({
+        scene: "running",
+        tone: "running",
+        headline: messages.status[snapshot.status],
+        expandedHeadline: messages.status[snapshot.status],
+        action: messages.safety,
+        expandedAction: messages.safety,
+        meta: `${snapshot.executor.label} \xB7 ${snapshot.executor.modelLabel}`,
+        recentActivities: Object.freeze([]),
+        startedAt: snapshot.createdAt
+      });
+    }
+    refreshSubmitState();
+  }
+  function renderEvent(event) {
+    if (event.type === "snapshot") {
+      renderJob(event.snapshot);
+      return;
+    }
+    if (event.type === "phase") statusText.textContent = messages.status[event.status];
+    if (event.type === "read-activity" && event.state === "started") {
+      const line = createMarkedElement(document, "span");
+      line.textContent = event.activity.kind === "source" ? messages.readSource(event.activity.relativePath) : messages.readFiles(event.activity.bucket);
+      activities.append(line);
+      while (activities.childElementCount > 5) activities.firstElementChild?.remove();
+      if (currentJob !== void 0) {
+        const activityLabel = line.textContent;
+        input.onExecutionChange({
+          scene: "running",
+          tone: "running",
+          headline: messages.status.running,
+          expandedHeadline: messages.status.running,
+          action: activityLabel,
+          expandedAction: activityLabel,
+          meta: `${currentJob.executor.label} \xB7 ${currentJob.executor.modelLabel}`,
+          activity: {
+            key: `ask:${String(event.sequence)}`,
+            kind: "read",
+            label: activityLabel,
+            state: "active"
+          },
+          recentActivities: Object.freeze([]),
+          startedAt: currentJob.createdAt
+        });
+      }
+    }
+  }
+  function renderAnswer(result, isStale) {
+    currentResult = result;
+    currentJob = void 0;
+    input.onExecutionChange();
+    const sourceMap = new Map(
+      result.sources.map((source) => [source.sourceId, source])
+    );
+    blocks.replaceChildren();
+    warnings.replaceChildren();
+    sourceList.replaceChildren();
+    stale.hidden = !isStale;
+    for (const warning of result.warnings) {
+      const warningNode = createMarkedElement(document, "div");
+      warningNode.className = "spotpatch-ask-warning";
+      warningNode.textContent = messages.warning(warning.code);
+      warnings.append(warningNode);
+    }
+    for (const block of result.blocks) {
+      if (block.kind === "paragraph") {
+        const paragraph = createMarkedElement(document, "p");
+        paragraph.textContent = block.text;
+        blocks.append(paragraph);
+        appendSourceChips(document, blocks, block.sourceIds, sourceMap, messages);
+      } else if (block.kind === "code") {
+        const pre = createMarkedElement(document, "pre");
+        const code = createMarkedElement(document, "code");
+        if (block.language !== void 0) code.dataset.language = block.language;
+        code.textContent = block.code;
+        pre.append(code);
+        blocks.append(pre);
+        appendSourceChips(document, blocks, block.sourceIds, sourceMap, messages);
+      } else {
+        const list = createMarkedElement(document, "ul");
+        for (const item of block.items) {
+          const listItem = createMarkedElement(document, "li");
+          listItem.textContent = item.text;
+          appendSourceChips(document, listItem, item.sourceIds, sourceMap, messages);
+          list.append(listItem);
+        }
+        blocks.append(list);
+      }
+    }
+    for (const source of result.sources) {
+      const button = createButton(
+        document,
+        messages.sourceLabel(source.relativePath, source.startLine, source.endLine),
+        "spotpatch-ask-source"
+      );
+      button.dataset.askSourceId = source.sourceId;
+      button.title = source.label;
+      sourceList.append(button);
+    }
+    sourcesSection.hidden = result.sources.length === 0;
+    answer.hidden = false;
+    status.hidden = true;
+    busy = false;
+    refreshSubmitState();
+    input.onViewChange();
+  }
+  function answerPlainText() {
+    if (currentResult === void 0) return "";
+    const body = currentResult.blocks.flatMap(
+      (block) => block.kind === "paragraph" ? [block.text] : block.kind === "code" ? [block.code] : block.items.map((item) => `- ${item.text}`)
+    ).join("\n\n");
+    const sourceText = currentResult.sources.map(
+      (source) => messages.sourceLabel(source.relativePath, source.startLine, source.endLine)
+    ).join("\n");
+    return sourceText.length === 0 ? body : `${body}
+
+${messages.sourcesTitle}
+${sourceText}`;
+  }
+  function clear() {
+    currentResult = void 0;
+    currentJob = void 0;
+    input.onExecutionChange();
+    questionInput.value = "";
+    answer.hidden = true;
+    status.hidden = true;
+    error.hidden = true;
+    activities.replaceChildren();
+    stale.hidden = true;
+    busy = false;
+    refreshSubmitState();
+    input.onViewChange();
+  }
+  askTab.addEventListener("click", () => {
+    currentMode = "ask";
+    applyMode();
+    questionInput.focus({ preventScroll: true });
+  });
+  changeTab.addEventListener("click", () => {
+    currentMode = "change";
+    applyMode();
+  });
+  questionInput.addEventListener("input", refreshSubmitState);
+  executorSelect.addEventListener("change", refreshSubmitState);
+  executorTrigger.addEventListener("click", () => {
+    if (executorMenu.hidden) openExecutorMenu();
+    else closeExecutorMenu();
+  });
+  executorTrigger.addEventListener("keydown", (event) => {
+    if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+    event.preventDefault();
+    openExecutorMenu(true);
+  });
+  executorMenu.addEventListener("keydown", (event) => {
+    const options = [
+      ...executorMenu.querySelectorAll(
+        ".spotpatch-ask-executor-option"
+      )
+    ];
+    if (event.key === "Escape") {
+      event.preventDefault();
+      closeExecutorMenu(true);
+      return;
+    }
+    if (!["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key)) return;
+    event.preventDefault();
+    const currentIndex = options.indexOf(document.activeElement);
+    const nextIndex = event.key === "Home" ? 0 : event.key === "End" ? options.length - 1 : event.key === "ArrowDown" ? (currentIndex + 1 + options.length) % options.length : (currentIndex - 1 + options.length) % options.length;
+    options[nextIndex]?.focus({ preventScroll: true });
+  });
+  executorPicker.addEventListener("focusout", (event) => {
+    if (!(event.relatedTarget instanceof Node) || !executorPicker.contains(event.relatedTarget)) {
+      closeExecutorMenu();
+    }
+  });
+  const closeExecutorMenuOutside = (event) => {
+    if (!event.composedPath().includes(executorPicker)) closeExecutorMenu();
+  };
+  document.addEventListener("pointerdown", closeExecutorMenuOutside);
+  consentCheckbox.addEventListener("change", refreshSubmitState);
+  const unsubscribeLocale = input.subscribeLocale(applyMessages);
+  applyMessages();
+  applyMode();
+  return Object.freeze({
+    root,
+    styles: createStyles(document),
+    questionInput,
+    executorSelect,
+    consentCheckbox,
+    submitButton,
+    cancelButton,
+    newQuestionButton,
+    copyButton,
+    convertButton,
+    clear,
+    dispose: () => {
+      unsubscribeLocale();
+      document.removeEventListener("pointerdown", closeExecutorMenuOutside);
+    },
+    focusQuestion: () => {
+      questionInput.focus({ preventScroll: true });
+    },
+    mode: () => currentMode,
+    notify(event) {
+      const message = event === "copied" ? messages.copied : event === "copy-failed" ? messages.copyFailed : event === "converted" ? messages.converted : messages.sourceOpenFailed;
+      input.announce(message);
+    },
+    readConsent: () => consentCheckbox.checked,
+    readExecutorId: () => executorSelect.value || void 0,
+    readQuestion: () => questionInput.value.trim(),
+    renderAnswer,
+    renderCapability,
+    renderError(code) {
+      currentJob = void 0;
+      input.onExecutionChange();
+      error.textContent = messages.error(code);
+      error.hidden = false;
+      status.hidden = true;
+      busy = false;
+      refreshSubmitState();
+      input.onViewChange();
+    },
+    renderEvent,
+    renderJob,
+    selectedSourceId(target) {
+      return target instanceof Element ? target.closest("[data-ask-source-id]")?.dataset.askSourceId : void 0;
+    },
+    setBusy(nextBusy) {
+      busy = nextBusy;
+      if (nextBusy) {
+        status.hidden = false;
+        error.hidden = true;
+        answer.hidden = true;
+        activities.replaceChildren();
+      }
+      refreshSubmitState();
+    },
+    setConsent(granted) {
+      consentCheckbox.checked = granted;
+      refreshSubmitState();
+    },
+    setMode(mode) {
+      currentMode = mode;
+      applyMode();
+    },
+    setOrigin(nextOrigin) {
+      origin.dataset.active = String(nextOrigin !== void 0);
+      origin.hidden = currentMode === "ask" || nextOrigin === void 0;
+      input.onViewChange();
+    },
+    setSelectionPreview(preview) {
+      currentPreview = preview;
+      dataText.textContent = messages.dataSummary(
+        preview.targetCount,
+        preview.sourceCount
+      );
+      refreshSubmitState();
+    },
+    setSelectionVisible(visible) {
+      root.hidden = !visible;
+      if (visible) applyMode();
+    },
+    sourceById: (sourceId) => currentResult?.sources.find((source) => source.sourceId === sourceId),
+    answerPlainText
+  });
+}
+
+// src/contextual-ask-panel-entry.ts
+var EXTENSION = Object.freeze({
+  createPanel: createContextualAskPanel,
+  createWorkflow: createContextualAskWorkflow
+});
+function installContextualAskExtension() {
+  registerContextualAskExtension(EXTENSION);
+}
+export {
+  createContextualAskPanel,
+  createContextualAskWorkflow,
+  getContextualAskExtension,
+  installContextualAskExtension,
+  registerContextualAskExtension
+};
+//# sourceMappingURL=contextual-ask-panel.js.map