@spotpatch/shared 1.12.0 → 1.13.0

package/dist/index.cjs

@@ -27,6 +27,18 @@ __export(index_exports, {
   AGENT_JOB_STATUSES: () => AGENT_JOB_STATUSES,
   AGENT_WORKSPACE_SNAPSHOT_LIMITS: () => AGENT_WORKSPACE_SNAPSHOT_LIMITS,
   AGENT_WORKSPACE_STATES: () => AGENT_WORKSPACE_STATES,
+  ASK_ANSWER_WARNING_CODES: () => ASK_ANSWER_WARNING_CODES,
+  ASK_EXECUTOR_ANSWER_WARNING_CODES: () => ASK_EXECUTOR_ANSWER_WARNING_CODES,
+  ASK_FILE_COUNT_BUCKETS: () => ASK_FILE_COUNT_BUCKETS,
+  ASK_JOB_STATUSES: () => ASK_JOB_STATUSES,
+  ASK_READ_ACTIVITY_STATES: () => ASK_READ_ACTIVITY_STATES,
+  ASK_SOURCE_CONFIDENCES: () => ASK_SOURCE_CONFIDENCES,
+  CONTEXTUAL_ASK_ERROR_CODES: () => CONTEXTUAL_ASK_ERROR_CODES,
+  CONTEXTUAL_ASK_EXECUTOR_KINDS: () => CONTEXTUAL_ASK_EXECUTOR_KINDS,
+  CONTEXTUAL_ASK_EXECUTOR_STATES: () => CONTEXTUAL_ASK_EXECUTOR_STATES,
+  CONTEXTUAL_ASK_LIMITS: () => CONTEXTUAL_ASK_LIMITS,
+  CONTEXTUAL_ASK_PERMISSION_PROFILE: () => CONTEXTUAL_ASK_PERMISSION_PROFILE,
+  CONTEXTUAL_ASK_SCHEMA_VERSION: () => CONTEXTUAL_ASK_SCHEMA_VERSION,
   DATA_FLOW_ASSOCIATION_KINDS: () => DATA_FLOW_ASSOCIATION_KINDS,
   DATA_FLOW_DIAGNOSTIC_CODES: () => DATA_FLOW_DIAGNOSTIC_CODES,
   DATA_FLOW_EXECUTION_STATES: () => DATA_FLOW_EXECUTION_STATES,
@@ -97,7 +109,26 @@ __export(index_exports, {
   agentJobSnapshotSchema: () => agentJobSnapshotSchema,
   agentWorkspaceHealthRequestSchema: () => agentWorkspaceHealthRequestSchema,
   agentWorkspaceHealthSnapshotSchema: () => agentWorkspaceHealthSnapshotSchema,
+  askAnswerBlockSchema: () => askAnswerBlockSchema,
+  askAnswerDraftBlockSchema: () => askAnswerDraftBlockSchema,
+  askAnswerDraftSchema: () => askAnswerDraftSchema,
+  askAnswerResultSchema: () => askAnswerResultSchema,
+  askAnswerWarningSchema: () => askAnswerWarningSchema,
+  askDraftCitationSchema: () => askDraftCitationSchema,
+  askDraftOriginSchema: () => askDraftOriginSchema,
+  askJobActionRequestSchema: () => askJobActionRequestSchema,
+  askJobCreateRequestSchema: () => askJobCreateRequestSchema,
+  askJobEventSchema: () => askJobEventSchema,
+  askJobEventsRequestSchema: () => askJobEventsRequestSchema,
+  askJobResultResponseSchema: () => askJobResultResponseSchema,
+  askJobSnapshotSchema: () => askJobSnapshotSchema,
+  askSourceReferenceSchema: () => askSourceReferenceSchema,
   componentDataFlowReportSchema: () => componentDataFlowReportSchema,
+  contextualAskCapabilityRequestSchema: () => contextualAskCapabilityRequestSchema,
+  contextualAskCapabilitySchema: () => contextualAskCapabilitySchema,
+  contextualAskExecutorCapabilitySchema: () => contextualAskExecutorCapabilitySchema,
+  contextualAskExecutorPreferenceSchema: () => contextualAskExecutorPreferenceSchema,
+  contextualAskOptionsSchema: () => contextualAskOptionsSchema,
   dataDependencySchema: () => dataDependencySchema,
   dataFlowComponentReportRequestSchema: () => dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema: () => dataFlowPageReportRequestSchema,
@@ -125,6 +156,7 @@ __export(index_exports, {
   externalHandoffSummarySchema: () => externalHandoffSummarySchema,
   formatSourceMarker: () => formatSourceMarker,
   getAgentJobEndpoint: () => getAgentJobEndpoint,
+  getAskJobEndpoint: () => getAskJobEndpoint,
   isErrorCode: () => isErrorCode,
   isSensitiveName: () => isSensitiveName,
   limitDataFlowReportCollections: () => limitDataFlowReportCollections,
@@ -142,8 +174,13 @@ __export(index_exports, {
   runtimeDataFlowConfigSchema: () => runtimeDataFlowConfigSchema,
   sanitizeUrl: () => sanitizeUrl,
   sourceContextRequestSchema: () => sourceContextRequestSchema,
-  spotAnnotationRequestSchema: () => spotAnnotationRequestSchema,
-  spotTargetContextRequestSchema: () => spotTargetContextRequestSchema
+  spotAnnotationRequestSchema: () => spotAnnotationSchema,
+  spotAskTaskEnvelopeSchema: () => spotAskTaskEnvelopeSchema,
+  spotChangeTaskEnvelopeSchema: () => spotChangeTaskEnvelopeSchema,
+  spotSelectionContextSchema: () => spotSelectionContextSchema,
+  spotSelectionTargetSchema: () => spotSelectionTargetSchema,
+  spotTargetContextRequestSchema: () => spotTargetContextSchema,
+  spotTaskEnvelopeSchema: () => spotTaskEnvelopeSchema
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -214,6 +251,24 @@ var ERROR_CODES = {
   APPLY_CONFLICT: "APPLY_CONFLICT",
   INTERNAL_ERROR: "INTERNAL_ERROR"
 };
+var CONTEXTUAL_ASK_ERROR_CODES = Object.freeze([
+  "ASK_DISABLED",
+  "ASK_SELECTION_REQUIRED",
+  "ASK_SELECTION_STALE",
+  "ASK_QUESTION_INVALID",
+  "ASK_EXECUTOR_UNAVAILABLE",
+  "ASK_TIMEOUT",
+  "ASK_CONSENT_REQUIRED",
+  "ASK_BUSY",
+  "ASK_IDEMPOTENCY_CONFLICT",
+  "ASK_SOURCE_SCOPE_DENIED",
+  "ASK_LIMIT_EXCEEDED",
+  "ASK_ANSWER_INVALID",
+  "ASK_WRITE_ATTEMPTED",
+  "ASK_CANCELLED",
+  "ASK_RESULT_EXPIRED",
+  "ASK_PROTOCOL_INCOMPATIBLE"
+]);
 var ERROR_CODE_VALUES = Object.freeze(Object.values(ERROR_CODES));
 function isErrorCode(value) {
   return typeof value === "string" && ERROR_CODE_VALUES.includes(value);
@@ -298,6 +353,534 @@ var SPOTPATCH_LOCALE_PREFERENCES = Object.freeze([
   ...SPOTPATCH_LOCALES
 ]);
 
+// src/model/contextual-ask.ts
+var import_zod2 = require("zod");
+
+// src/protocol/contextual-ask-constants.ts
+var CONTEXTUAL_ASK_SCHEMA_VERSION = 1;
+var CONTEXTUAL_ASK_LIMITS = Object.freeze({
+  maximumTargets: 20,
+  maximumQuestionCharacters: 4e3,
+  maximumAnswerCharacters: 4e4,
+  maximumAnswerBlocks: 40,
+  maximumSources: 64,
+  maximumReadFiles: 32,
+  maximumReadBytesPerFile: 64 * 1024,
+  maximumReadBytesTotal: 512 * 1024,
+  maximumToolCalls: 48,
+  maximumModelTurns: 12,
+  jobTimeoutMs: 3e5,
+  resultTtlMs: 9e5,
+  maximumActiveJobsPerSession: 1,
+  maximumRetainedResultsPerSession: 1,
+  maximumRetainedEvents: 256,
+  maximumEventSubscribers: 4,
+  eventHeartbeatMs: 15e3,
+  maximumRequestBodyBytes: 256 * 1024,
+  maximumSearchQueryCharacters: 256,
+  maximumSearchResults: 64,
+  maximumSearchPreviewCharacters: 500,
+  capabilityTimeoutMs: 3e4,
+  maximumIdCharacters: 128,
+  maximumProfileIdCharacters: 64,
+  maximumLabelCharacters: 256,
+  maximumRelativePathCharacters: 1024,
+  maximumLanguageCharacters: 64,
+  maximumPhaseMessageCharacters: 1024,
+  maximumExecutors: 32,
+  contentHashHexCharacters: 64
+});
+var CONTEXTUAL_ASK_EXECUTOR_KINDS = Object.freeze([
+  "configured-key",
+  "managed-codex"
+]);
+var CONTEXTUAL_ASK_EXECUTOR_STATES = Object.freeze([
+  "ready",
+  "degraded",
+  "unavailable"
+]);
+var ASK_JOB_STATUSES = Object.freeze([
+  "queued",
+  "authorizing",
+  "running",
+  "cancelling",
+  "answered",
+  "cancelled",
+  "failed"
+]);
+var ASK_ANSWER_WARNING_CODES = Object.freeze([
+  "insufficient-evidence",
+  "partial-context",
+  "source-truncated",
+  "source-stale"
+]);
+var ASK_EXECUTOR_ANSWER_WARNING_CODES = Object.freeze([
+  "insufficient-evidence",
+  "partial-context"
+]);
+var ASK_READ_ACTIVITY_STATES = Object.freeze([
+  "started",
+  "succeeded",
+  "failed"
+]);
+var ASK_FILE_COUNT_BUCKETS = Object.freeze(["one", "few", "many"]);
+var ASK_SOURCE_CONFIDENCES = Object.freeze([
+  "exact",
+  "probable",
+  "approximate"
+]);
+var CONTEXTUAL_ASK_PERMISSION_PROFILE = "spotpatch-ask-readonly";
+
+// src/model/context-schema.ts
+var import_zod = require("zod");
+var boundedString = (maximum) => import_zod.z.string().max(maximum);
+var sourceRefSchema = import_zod.z.strictObject({
+  fileId: boundedString(128).optional(),
+  relativePath: boundedString(1024).optional(),
+  line: import_zod.z.number().int().positive().optional(),
+  column: import_zod.z.number().int().positive().optional(),
+  origin: import_zod.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  confidence: import_zod.z.enum(["exact", "probable", "approximate", "unknown"])
+});
+var matchedStyleRuleSchema = import_zod.z.strictObject({
+  selector: boundedString(2048),
+  declarations: boundedString(8192),
+  source: boundedString(1024).optional(),
+  media: boundedString(1024).optional()
+});
+var codeContextSchema = import_zod.z.strictObject({
+  relativePath: boundedString(1024),
+  language: import_zod.z.enum(["tsx", "jsx"]),
+  startLine: import_zod.z.number().int().positive(),
+  endLine: import_zod.z.number().int().positive(),
+  excerpt: boundedString(16e3),
+  boundary: import_zod.z.enum(["component", "nearby-lines"])
+});
+var pageContextSchema = import_zod.z.strictObject({
+  url: boundedString(2048),
+  pathname: boundedString(2048),
+  title: boundedString(1024),
+  viewportWidth: import_zod.z.number().nonnegative(),
+  viewportHeight: import_zod.z.number().nonnegative(),
+  devicePixelRatio: import_zod.z.number().positive()
+});
+var spotTargetContextSchema = import_zod.z.strictObject({
+  instruction: import_zod.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+  page: pageContextSchema.optional(),
+  source: sourceRefSchema,
+  react: import_zod.z.strictObject({
+    supported: import_zod.z.boolean(),
+    version: boundedString(64).optional(),
+    componentName: boundedString(256).optional(),
+    componentSourceId: boundedString(128).optional(),
+    sourceVersion: boundedString(128).optional(),
+    componentStack: import_zod.z.array(boundedString(256)).max(64),
+    source: sourceRefSchema.optional()
+  }),
+  element: import_zod.z.strictObject({
+    tagName: boundedString(128),
+    selector: boundedString(2048),
+    sanitizedHtml: boundedString(8192),
+    textPreview: boundedString(2048).optional(),
+    role: boundedString(256).optional(),
+    rect: import_zod.z.strictObject({
+      x: import_zod.z.number(),
+      y: import_zod.z.number(),
+      width: import_zod.z.number().nonnegative(),
+      height: import_zod.z.number().nonnegative()
+    })
+  }),
+  styles: import_zod.z.strictObject({
+    classNames: import_zod.z.array(boundedString(512)).max(256),
+    inlineStyle: boundedString(8192).optional(),
+    matchedRules: import_zod.z.array(matchedStyleRuleSchema).max(256),
+    computed: import_zod.z.record(boundedString(256), boundedString(2048)),
+    warnings: import_zod.z.array(boundedString(1024)).max(64)
+  }),
+  code: codeContextSchema.optional(),
+  warnings: import_zod.z.array(boundedString(1024)).max(64)
+});
+var spotAnnotationSchema = import_zod.z.strictObject({
+  schemaVersion: import_zod.z.literal(3),
+  id: boundedString(128),
+  locale: import_zod.z.enum(SPOTPATCH_LOCALES),
+  page: pageContextSchema,
+  targets: import_zod.z.array(spotTargetContextSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  createdAt: import_zod.z.iso.datetime()
+}).superRefine((annotation, context) => {
+  const total = annotation.targets.reduce(
+    (characters, target) => characters + target.instruction.length,
+    0
+  );
+  if (total > MAX_ANNOTATION_INSTRUCTION_CHARACTERS) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined target instructions exceed the annotation limit.",
+      path: ["targets"]
+    });
+  }
+});
+
+// src/model/contextual-ask.ts
+var limits = CONTEXTUAL_ASK_LIMITS;
+var contextualAskBoundedText = (maximum) => import_zod2.z.string().trim().min(1).max(maximum);
+var contextualAskOpaqueIdSchema = import_zod2.z.string().min(1).max(limits.maximumIdCharacters).regex(/^[A-Za-z0-9_-]+$/u);
+var profileIdSchema = import_zod2.z.string().min(1).max(limits.maximumProfileIdCharacters).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+var contentHashSchema = import_zod2.z.string().length(limits.contentHashHexCharacters).regex(/^[a-f0-9]+$/u);
+var contextualAskRelativePathSchema = import_zod2.z.string().min(1).max(limits.maximumRelativePathCharacters).refine(
+  (value) => !value.startsWith("/") && !value.includes("\\") && !Array.from(value).some((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== void 0 && (codePoint <= 31 || codePoint === 127);
+  }) && !/^[A-Za-z]:/u.test(value) && value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".."),
+  { message: "Expected a safe project-relative POSIX path." }
+);
+var contextualAskExecutorPreferenceSchema = import_zod2.z.discriminatedUnion("kind", [
+  import_zod2.z.strictObject({
+    kind: import_zod2.z.literal("configured-key"),
+    providerProfileId: profileIdSchema,
+    modelProfileId: profileIdSchema
+  }),
+  import_zod2.z.strictObject({ kind: import_zod2.z.literal("managed-codex") })
+]);
+var contextualAskOptionsSchema = import_zod2.z.union([
+  import_zod2.z.boolean(),
+  import_zod2.z.strictObject({
+    defaultExecutor: contextualAskExecutorPreferenceSchema.optional()
+  })
+]);
+var spotSelectionTargetSchema = spotTargetContextSchema.omit({ instruction: true, page: true }).extend({
+  targetId: contextualAskOpaqueIdSchema,
+  page: pageContextSchema
+}).strict();
+var spotSelectionContextSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  selectionId: contextualAskOpaqueIdSchema,
+  locale: import_zod2.z.enum(SPOTPATCH_LOCALES),
+  targets: import_zod2.z.array(spotSelectionTargetSchema).min(1).max(limits.maximumTargets),
+  createdAt: import_zod2.z.iso.datetime()
+}).superRefine((selection, context) => {
+  const targetIds = selection.targets.map((target) => target.targetId);
+  if (new Set(targetIds).size !== targetIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Selection target IDs must be unique.",
+      path: ["targets"]
+    });
+  }
+});
+var askDraftOriginSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("contextual-ask"),
+  askJobId: contextualAskOpaqueIdSchema,
+  question: contextualAskBoundedText(limits.maximumQuestionCharacters),
+  answerDigest: contextualAskBoundedText(limits.maximumQuestionCharacters),
+  sourceIds: import_zod2.z.array(contextualAskOpaqueIdSchema).max(limits.maximumSources)
+}).superRefine((origin, context) => {
+  if (new Set(origin.sourceIds).size !== origin.sourceIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Ask origin source IDs must be unique.",
+      path: ["sourceIds"]
+    });
+  }
+});
+var askTaskSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("ask"),
+  question: contextualAskBoundedText(limits.maximumQuestionCharacters)
+});
+var changeInstructionSchema = import_zod2.z.strictObject({
+  targetId: contextualAskOpaqueIdSchema,
+  instruction: contextualAskBoundedText(MAX_TARGET_INSTRUCTION_CHARACTERS)
+});
+var changeTaskSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("change"),
+  instructions: import_zod2.z.array(changeInstructionSchema).min(1).max(limits.maximumTargets),
+  origin: askDraftOriginSchema.optional()
+});
+var envelopeBaseShape = {
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  taskId: contextualAskOpaqueIdSchema,
+  selection: spotSelectionContextSchema,
+  createdAt: import_zod2.z.iso.datetime()
+};
+var spotAskTaskEnvelopeSchema = import_zod2.z.strictObject({
+  ...envelopeBaseShape,
+  task: askTaskSchema
+});
+var spotChangeTaskEnvelopeSchema = import_zod2.z.strictObject({
+  ...envelopeBaseShape,
+  task: changeTaskSchema
+}).superRefine((envelope, context) => {
+  const targetIds = envelope.selection.targets.map((target) => target.targetId);
+  const instructionIds = envelope.task.instructions.map(
+    (instruction) => instruction.targetId
+  );
+  if (new Set(instructionIds).size !== instructionIds.length || instructionIds.length !== targetIds.length || targetIds.some((targetId) => !instructionIds.includes(targetId))) {
+    context.addIssue({
+      code: "custom",
+      message: "Change instructions must map one-to-one to selection targets.",
+      path: ["task", "instructions"]
+    });
+  }
+  const total = envelope.task.instructions.reduce(
+    (characters, instruction) => characters + instruction.instruction.length,
+    0
+  );
+  if (total > MAX_ANNOTATION_INSTRUCTION_CHARACTERS) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined change instructions exceed the task limit.",
+      path: ["task", "instructions"]
+    });
+  }
+});
+var spotTaskEnvelopeSchema = import_zod2.z.union([
+  spotAskTaskEnvelopeSchema,
+  spotChangeTaskEnvelopeSchema
+]);
+var askAnswerWarningSchema = import_zod2.z.strictObject({
+  code: import_zod2.z.enum(ASK_ANSWER_WARNING_CODES)
+});
+var askExecutorAnswerWarningSchema = import_zod2.z.strictObject({
+  code: import_zod2.z.enum(ASK_EXECUTOR_ANSWER_WARNING_CODES)
+});
+var askDraftCitationSchema = import_zod2.z.strictObject({
+  handleId: contextualAskOpaqueIdSchema,
+  startLine: import_zod2.z.number().int().positive(),
+  endLine: import_zod2.z.number().int().positive()
+}).refine((citation) => citation.endLine >= citation.startLine, {
+  message: "Citation endLine must not precede startLine."
+});
+var draftCitationListSchema = import_zod2.z.array(askDraftCitationSchema).max(limits.maximumSources);
+var draftParagraphBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("paragraph"),
+  text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+  citations: draftCitationListSchema
+});
+var draftListBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("list"),
+  items: import_zod2.z.array(
+    import_zod2.z.strictObject({
+      text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+      citations: draftCitationListSchema
+    })
+  ).min(1).max(limits.maximumAnswerBlocks)
+});
+var draftCodeBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("code"),
+  code: import_zod2.z.string().min(1).max(limits.maximumAnswerCharacters),
+  language: contextualAskBoundedText(limits.maximumLanguageCharacters).optional(),
+  citations: draftCitationListSchema
+});
+var askAnswerDraftBlockSchema = import_zod2.z.discriminatedUnion("kind", [
+  draftParagraphBlockSchema,
+  draftListBlockSchema,
+  draftCodeBlockSchema
+]);
+function draftCharacters(blocks) {
+  return blocks.reduce((total, block) => {
+    if (block.kind === "paragraph") return total + block.text.length;
+    if (block.kind === "code") return total + block.code.length;
+    return total + block.items.reduce((itemTotal, item) => itemTotal + item.text.length, 0);
+  }, 0);
+}
+var askAnswerDraftSchema = import_zod2.z.strictObject({
+  blocks: import_zod2.z.array(askAnswerDraftBlockSchema).min(1).max(limits.maximumAnswerBlocks),
+  warnings: import_zod2.z.array(askExecutorAnswerWarningSchema).max(limits.maximumAnswerBlocks)
+}).superRefine((answer, context) => {
+  if (draftCharacters(answer.blocks) > limits.maximumAnswerCharacters) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined answer text exceeds the answer limit.",
+      path: ["blocks"]
+    });
+  }
+  const citations = answer.blocks.flatMap(
+    (block) => block.kind === "list" ? block.items.flatMap((item) => item.citations) : block.citations
+  );
+  if (citations.length === 0 && !answer.warnings.some((warning) => warning.code === "insufficient-evidence")) {
+    context.addIssue({
+      code: "custom",
+      message: "An uncited answer draft must declare insufficient evidence.",
+      path: ["warnings"]
+    });
+  }
+  const distinct = new Set(
+    citations.map(
+      (citation) => `${citation.handleId}:${String(citation.startLine)}:${String(citation.endLine)}`
+    )
+  );
+  if (distinct.size > limits.maximumSources) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer references exceed the source limit.",
+      path: ["blocks"]
+    });
+  }
+});
+var sourceIdListSchema = import_zod2.z.array(contextualAskOpaqueIdSchema).max(limits.maximumSources);
+var paragraphBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("paragraph"),
+  text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+  sourceIds: sourceIdListSchema
+});
+var listBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("list"),
+  items: import_zod2.z.array(
+    import_zod2.z.strictObject({
+      text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+      sourceIds: sourceIdListSchema
+    })
+  ).min(1).max(limits.maximumAnswerBlocks)
+});
+var codeBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("code"),
+  code: import_zod2.z.string().min(1).max(limits.maximumAnswerCharacters),
+  language: contextualAskBoundedText(limits.maximumLanguageCharacters).optional(),
+  sourceIds: sourceIdListSchema
+});
+var askAnswerBlockSchema = import_zod2.z.discriminatedUnion("kind", [
+  paragraphBlockSchema,
+  listBlockSchema,
+  codeBlockSchema
+]);
+var askSourceReferenceSchema = import_zod2.z.strictObject({
+  sourceId: contextualAskOpaqueIdSchema,
+  label: contextualAskBoundedText(limits.maximumLabelCharacters),
+  relativePath: contextualAskRelativePathSchema,
+  fileId: contextualAskOpaqueIdSchema,
+  startLine: import_zod2.z.number().int().positive(),
+  endLine: import_zod2.z.number().int().positive(),
+  confidence: import_zod2.z.enum(ASK_SOURCE_CONFIDENCES),
+  targetIds: import_zod2.z.array(contextualAskOpaqueIdSchema).min(1).max(limits.maximumTargets),
+  sourceVersion: contextualAskBoundedText(limits.maximumIdCharacters).optional(),
+  contentHash: contentHashSchema
+}).superRefine((source, context) => {
+  if (source.endLine < source.startLine) {
+    context.addIssue({
+      code: "custom",
+      message: "Source endLine must not precede startLine.",
+      path: ["endLine"]
+    });
+  }
+  if (new Set(source.targetIds).size !== source.targetIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Source target IDs must be unique.",
+      path: ["targetIds"]
+    });
+  }
+});
+function resultBlockCharacters(blocks) {
+  return blocks.reduce((total, block) => {
+    if (block.kind === "paragraph") return total + block.text.length;
+    if (block.kind === "code") return total + block.code.length;
+    return total + block.items.reduce((itemTotal, item) => itemTotal + item.text.length, 0);
+  }, 0);
+}
+var askAnswerResultSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  jobId: contextualAskOpaqueIdSchema,
+  selectionId: contextualAskOpaqueIdSchema,
+  contextHash: contentHashSchema,
+  executor: import_zod2.z.strictObject({
+    executorId: contextualAskOpaqueIdSchema,
+    kind: import_zod2.z.enum(CONTEXTUAL_ASK_EXECUTOR_KINDS),
+    label: contextualAskBoundedText(limits.maximumLabelCharacters),
+    modelLabel: contextualAskBoundedText(limits.maximumLabelCharacters)
+  }),
+  blocks: import_zod2.z.array(askAnswerBlockSchema).min(1).max(limits.maximumAnswerBlocks),
+  sources: import_zod2.z.array(askSourceReferenceSchema).max(limits.maximumSources),
+  warnings: import_zod2.z.array(askAnswerWarningSchema).max(limits.maximumAnswerBlocks),
+  createdAt: import_zod2.z.iso.datetime(),
+  expiresAt: import_zod2.z.iso.datetime()
+}).superRefine((answer, context) => {
+  if (Date.parse(answer.expiresAt) <= Date.parse(answer.createdAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer expiry must follow creation.",
+      path: ["expiresAt"]
+    });
+  }
+  if (resultBlockCharacters(answer.blocks) > limits.maximumAnswerCharacters) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined answer text exceeds the answer limit.",
+      path: ["blocks"]
+    });
+  }
+  const sourceIds = answer.sources.map((source) => source.sourceId);
+  if (new Set(sourceIds).size !== sourceIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer source IDs must be unique.",
+      path: ["sources"]
+    });
+  }
+  const available = new Set(sourceIds);
+  const references = answer.blocks.flatMap(
+    (block) => block.kind === "list" ? block.items.flatMap((item) => item.sourceIds) : block.sourceIds
+  );
+  if (references.length === 0 && !answer.warnings.some((warning) => warning.code === "insufficient-evidence")) {
+    context.addIssue({
+      code: "custom",
+      message: "An uncited answer must declare insufficient evidence.",
+      path: ["warnings"]
+    });
+  }
+  if (references.some((sourceId) => !available.has(sourceId))) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer blocks reference an unknown source ID.",
+      path: ["blocks"]
+    });
+  }
+  if (sourceIds.some((sourceId) => !references.includes(sourceId))) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer sources must be referenced by at least one block.",
+      path: ["sources"]
+    });
+  }
+});
+var contextualAskExecutorCapabilitySchema = import_zod2.z.strictObject({
+  executorId: contextualAskOpaqueIdSchema,
+  kind: import_zod2.z.enum(CONTEXTUAL_ASK_EXECUTOR_KINDS),
+  label: contextualAskBoundedText(limits.maximumLabelCharacters),
+  requestedModelLabel: contextualAskBoundedText(limits.maximumLabelCharacters),
+  effectiveModelLabel: contextualAskBoundedText(limits.maximumLabelCharacters),
+  state: import_zod2.z.enum(CONTEXTUAL_ASK_EXECUTOR_STATES),
+  providerDataConsentRequired: import_zod2.z.boolean(),
+  readOnlyProven: import_zod2.z.boolean(),
+  errorCode: import_zod2.z.enum(CONTEXTUAL_ASK_ERROR_CODES).optional()
+}).superRefine((executor, context) => {
+  if (executor.state === "ready" && (!executor.readOnlyProven || executor.errorCode !== void 0) || executor.state !== "ready" && executor.errorCode === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Executor capability fields are inconsistent."
+    });
+  }
+});
+var contextualAskCapabilitySchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  enabled: import_zod2.z.boolean(),
+  executors: import_zod2.z.array(contextualAskExecutorCapabilitySchema).max(limits.maximumExecutors),
+  safety: import_zod2.z.strictObject({
+    selectionRequired: import_zod2.z.literal(true),
+    singleTurn: import_zod2.z.literal(true),
+    writesAllowed: import_zod2.z.literal(false),
+    historyStored: import_zod2.z.literal(false)
+  }),
+  checkedAt: import_zod2.z.iso.datetime()
+}).superRefine((capability, context) => {
+  if (!capability.enabled && capability.executors.length > 0 || new Set(capability.executors.map((executor) => executor.executorId)).size !== capability.executors.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Contextual Ask capability fields are inconsistent.",
+      path: ["executors"]
+    });
+  }
+});
+
 // src/model/data-flow-adapters.ts
 var DATA_FLOW_QUERY_ADAPTER_MODULES = Object.freeze([
   "@tanstack/react-query",
@@ -341,7 +924,7 @@ var DATA_FLOW_TRPC_REQUEST_METHODS = Object.freeze([
 ]);
 
 // src/model/data-flow.ts
-var import_zod = require("zod");
+var import_zod3 = require("zod");
 
 // src/model/data-flow-limits.ts
 var DEFAULT_DATA_FLOW_LIMITS = Object.freeze({
@@ -412,24 +995,24 @@ var DATA_FLOW_DIAGNOSTIC_CODES = Object.freeze([
   "DATA_FLOW_REDACTION_APPLIED",
   "DATA_FLOW_AI_DISABLED"
 ]);
-var boundedText = (maximum) => import_zod.z.string().trim().min(1).max(maximum);
+var boundedText = (maximum) => import_zod3.z.string().trim().min(1).max(maximum);
 var opaqueIdSchema = boundedText(128).regex(/^[A-Za-z0-9_-]+$/u);
-var diagnosticCodeSchema = import_zod.z.enum(DATA_FLOW_DIAGNOSTIC_CODES);
-var evidenceSourceSchema = import_zod.z.strictObject({
+var diagnosticCodeSchema = import_zod3.z.enum(DATA_FLOW_DIAGNOSTIC_CODES);
+var evidenceSourceSchema = import_zod3.z.strictObject({
   fileId: opaqueIdSchema,
   displayPath: boundedText(1024),
-  line: import_zod.z.number().int().positive(),
-  column: import_zod.z.number().int().positive(),
+  line: import_zod3.z.number().int().positive(),
+  column: import_zod3.z.number().int().positive(),
   sourceVersion: opaqueIdSchema
 });
-var sanitizedObservedUrlSchema = import_zod.z.strictObject({
+var sanitizedObservedUrlSchema = import_zod3.z.strictObject({
   origin: boundedText(512).optional(),
   pathname: boundedText(2048),
-  queryKeys: import_zod.z.array(boundedText(256)).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxFields)
+  queryKeys: import_zod3.z.array(boundedText(256)).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxFields)
 });
-var dataParameterSchema = import_zod.z.strictObject({
+var dataParameterSchema = import_zod3.z.strictObject({
   path: boundedText(1024),
-  position: import_zod.z.enum([
+  position: import_zod3.z.enum([
     "path",
     "query",
     "body",
@@ -442,34 +1025,34 @@ var dataParameterSchema = import_zod.z.strictObject({
   type: boundedText(512).optional(),
   source: boundedText(1024).optional(),
   condition: boundedText(1024).optional(),
-  sensitive: import_zod.z.boolean(),
-  valueState: import_zod.z.literal("not-collected"),
-  evidenceIds: import_zod.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence)
+  sensitive: import_zod3.z.boolean(),
+  valueState: import_zod3.z.literal("not-collected"),
+  evidenceIds: import_zod3.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence)
 });
-var dataResponseSchema = import_zod.z.strictObject({
-  consumedFields: import_zod.z.array(boundedText(1024)).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxFields)
+var dataResponseSchema = import_zod3.z.strictObject({
+  consumedFields: import_zod3.z.array(boundedText(1024)).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxFields)
 });
-var requestOriginSchema = import_zod.z.strictObject({
+var requestOriginSchema = import_zod3.z.strictObject({
   componentSourceId: opaqueIdSchema.optional(),
   triggerCallsiteId: opaqueIdSchema.optional(),
   requestCallsiteId: opaqueIdSchema,
   sourceVersion: opaqueIdSchema
 });
-var capabilityReasonSchema = import_zod.z.strictObject({
+var capabilityReasonSchema = import_zod3.z.strictObject({
   code: diagnosticCodeSchema,
-  retryable: import_zod.z.boolean()
+  retryable: import_zod3.z.boolean()
 });
-var capabilitySchema = import_zod.z.strictObject({
-  enabled: import_zod.z.boolean(),
-  staticAnalysis: import_zod.z.enum(["available", "partial", "unavailable"]),
-  runtimeObservation: import_zod.z.literal("dispatch-only"),
-  responseShape: import_zod.z.literal("consumed-fields-only"),
-  aiAssistance: import_zod.z.literal("disabled"),
-  reasons: import_zod.z.array(capabilityReasonSchema).max(DEFAULT_DATA_FLOW_LIMITS.capabilityMaxReasons)
+var capabilitySchema = import_zod3.z.strictObject({
+  enabled: import_zod3.z.boolean(),
+  staticAnalysis: import_zod3.z.enum(["available", "partial", "unavailable"]),
+  runtimeObservation: import_zod3.z.literal("dispatch-only"),
+  responseShape: import_zod3.z.literal("consumed-fields-only"),
+  aiAssistance: import_zod3.z.literal("disabled"),
+  reasons: import_zod3.z.array(capabilityReasonSchema).max(DEFAULT_DATA_FLOW_LIMITS.capabilityMaxReasons)
 });
-var evidenceSchema = import_zod.z.strictObject({
+var evidenceSchema = import_zod3.z.strictObject({
   id: opaqueIdSchema,
-  kind: import_zod.z.enum([
+  kind: import_zod3.z.enum([
     "source-anchor",
     "import-resolution",
     "symbol-edge",
@@ -482,49 +1065,49 @@ var evidenceSchema = import_zod.z.strictObject({
     "diagnostic"
   ]),
   source: evidenceSourceSchema.optional(),
-  adapter: import_zod.z.strictObject({ id: boundedText(128), version: boundedText(64) }).optional(),
+  adapter: import_zod3.z.strictObject({ id: boundedText(128), version: boundedText(64) }).optional(),
   summaryKey: boundedText(256)
 });
-var diagnosticSchema = import_zod.z.strictObject({
+var diagnosticSchema = import_zod3.z.strictObject({
   id: opaqueIdSchema,
   code: diagnosticCodeSchema,
-  severity: import_zod.z.enum(["info", "warning", "error"]),
-  retryable: import_zod.z.boolean(),
-  evidenceIds: import_zod.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence)
+  severity: import_zod3.z.enum(["info", "warning", "error"]),
+  retryable: import_zod3.z.boolean(),
+  evidenceIds: import_zod3.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence)
 });
-var baselineSchema = import_zod.z.strictObject({
+var baselineSchema = import_zod3.z.strictObject({
   registryEpoch: opaqueIdSchema,
   analyzerVersion: boundedText(64),
   adapterSetHash: boundedText(128),
-  analyzedSourceVersions: import_zod.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxModules)
+  analyzedSourceVersions: import_zod3.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxModules)
 });
-var completenessSchema = import_zod.z.strictObject({
-  complete: import_zod.z.boolean(),
-  visitedModules: import_zod.z.number().int().nonnegative(),
-  visitedCallsites: import_zod.z.number().int().nonnegative(),
-  frontierCount: import_zod.z.number().int().nonnegative(),
-  truncatedBy: import_zod.z.enum(["depth", "modules", "callsites", "bytes", "timeout"]).optional()
+var completenessSchema = import_zod3.z.strictObject({
+  complete: import_zod3.z.boolean(),
+  visitedModules: import_zod3.z.number().int().nonnegative(),
+  visitedCallsites: import_zod3.z.number().int().nonnegative(),
+  frontierCount: import_zod3.z.number().int().nonnegative(),
+  truncatedBy: import_zod3.z.enum(["depth", "modules", "callsites", "bytes", "timeout"]).optional()
 });
-var dataDependencySchema = import_zod.z.strictObject({
+var dataDependencySchema = import_zod3.z.strictObject({
   id: opaqueIdSchema,
-  kind: import_zod.z.enum(["http", "graphql", "rpc", "server-action", "unknown"]),
-  direction: import_zod.z.enum(["read", "write", "read-write", "unknown"]),
-  execution: import_zod.z.enum(DATA_FLOW_EXECUTION_STATES),
-  proof: import_zod.z.enum(DATA_FLOW_PROOF_STATES),
-  association: import_zod.z.enum(DATA_FLOW_ASSOCIATION_KINDS),
+  kind: import_zod3.z.enum(["http", "graphql", "rpc", "server-action", "unknown"]),
+  direction: import_zod3.z.enum(["read", "write", "read-write", "unknown"]),
+  execution: import_zod3.z.enum(DATA_FLOW_EXECUTION_STATES),
+  proof: import_zod3.z.enum(DATA_FLOW_PROOF_STATES),
+  association: import_zod3.z.enum(DATA_FLOW_ASSOCIATION_KINDS),
   method: boundedText(32).optional(),
   operation: boundedText(512).optional(),
   url: sanitizedObservedUrlSchema.optional(),
-  parameters: import_zod.z.array(dataParameterSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxFields),
+  parameters: import_zod3.z.array(dataParameterSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxFields),
   response: dataResponseSchema,
   origin: requestOriginSchema.optional(),
-  suppliedBindings: import_zod.z.array(boundedText(1024)).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
-  locationIds: import_zod.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
-  evidenceIds: import_zod.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence),
-  observationIds: import_zod.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.observationMaxEntries)
+  suppliedBindings: import_zod3.z.array(boundedText(1024)).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
+  locationIds: import_zod3.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
+  evidenceIds: import_zod3.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence),
+  observationIds: import_zod3.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.observationMaxEntries)
 });
-var networkObservationSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(DATA_FLOW_SCHEMA_VERSION),
+var networkObservationSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(DATA_FLOW_SCHEMA_VERSION),
   id: opaqueIdSchema,
   pageEpoch: opaqueIdSchema,
   routeEpoch: opaqueIdSchema,
@@ -533,48 +1116,48 @@ var networkObservationSchema = import_zod.z.strictObject({
   componentSourceId: opaqueIdSchema.optional(),
   triggerCallsiteId: opaqueIdSchema.optional(),
   sourceVersion: opaqueIdSchema.optional(),
-  transport: import_zod.z.enum(["fetch", "trpc", "xhr"]),
+  transport: import_zod3.z.enum(["fetch", "trpc", "xhr"]),
   method: boundedText(32),
   operation: boundedText(512).optional(),
   url: sanitizedObservedUrlSchema,
-  outcome: import_zod.z.literal("dispatched"),
-  freshness: import_zod.z.enum(DATA_FLOW_FRESHNESS_STATES),
-  diagnosticIds: import_zod.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence)
+  outcome: import_zod3.z.literal("dispatched"),
+  freshness: import_zod3.z.enum(DATA_FLOW_FRESHNESS_STATES),
+  diagnosticIds: import_zod3.z.array(opaqueIdSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence)
 });
-var componentIdentitySchema = import_zod.z.strictObject({
+var componentIdentitySchema = import_zod3.z.strictObject({
   componentSourceId: opaqueIdSchema.optional(),
   displayName: boundedText(256).optional(),
   source: evidenceSourceSchema
 });
-var componentDataFlowReportSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(DATA_FLOW_SCHEMA_VERSION),
+var componentDataFlowReportSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(DATA_FLOW_SCHEMA_VERSION),
   reportId: opaqueIdSchema,
   baseline: baselineSchema,
   capability: capabilitySchema,
   component: componentIdentitySchema,
-  dependencies: import_zod.z.array(dataDependencySchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
-  evidence: import_zod.z.array(evidenceSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence),
-  diagnostics: import_zod.z.array(diagnosticSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxDiagnostics),
+  dependencies: import_zod3.z.array(dataDependencySchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
+  evidence: import_zod3.z.array(evidenceSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence),
+  diagnostics: import_zod3.z.array(diagnosticSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxDiagnostics),
   completeness: completenessSchema
 });
-var pageDataFlowReportSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(DATA_FLOW_SCHEMA_VERSION),
+var pageDataFlowReportSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(DATA_FLOW_SCHEMA_VERSION),
   reportId: opaqueIdSchema,
   baseline: baselineSchema,
   capability: capabilitySchema,
-  dependencies: import_zod.z.array(dataDependencySchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
-  evidence: import_zod.z.array(evidenceSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence),
-  diagnostics: import_zod.z.array(diagnosticSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxDiagnostics),
+  dependencies: import_zod3.z.array(dataDependencySchema).max(DEFAULT_DATA_FLOW_LIMITS.graphMaxCallsites),
+  evidence: import_zod3.z.array(evidenceSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxEvidence),
+  diagnostics: import_zod3.z.array(diagnosticSchema).max(DEFAULT_DATA_FLOW_LIMITS.reportMaxDiagnostics),
   completeness: completenessSchema
 });
-var runtimeDataFlowConfigSchema = import_zod.z.strictObject({
-  enabled: import_zod.z.boolean(),
-  runtime: import_zod.z.literal("dispatch"),
-  limits: import_zod.z.strictObject({
-    observationMaxEntries: import_zod.z.number().int().positive(),
-    observationMaxBytes: import_zod.z.number().int().positive(),
-    observationTtlMs: import_zod.z.number().int().positive(),
-    reportMaxBytes: import_zod.z.number().int().positive()
+var runtimeDataFlowConfigSchema = import_zod3.z.strictObject({
+  enabled: import_zod3.z.boolean(),
+  runtime: import_zod3.z.literal("dispatch"),
+  limits: import_zod3.z.strictObject({
+    observationMaxEntries: import_zod3.z.number().int().positive(),
+    observationMaxBytes: import_zod3.z.number().int().positive(),
+    observationTtlMs: import_zod3.z.number().int().positive(),
+    reportMaxBytes: import_zod3.z.number().int().positive()
   })
 });
 
@@ -776,7 +1359,7 @@ function limitDataFlowReportCollections(report, options = {}) {
 }
 
 // src/model/runtime-config.ts
-var import_zod2 = require("zod");
+var import_zod4 = require("zod");
 
 // src/protocol/endpoints.ts
 var SPOTPATCH_API_BASE = "/__spotpatch/v1";
@@ -790,6 +1373,8 @@ var SPOTPATCH_ENDPOINTS = Object.freeze({
   agentCapability: `${SPOTPATCH_API_BASE}/agent/capability`,
   agentWorkspaceHealth: `${SPOTPATCH_API_BASE}/agent/workspace-health`,
   agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`,
+  askCapability: `${SPOTPATCH_API_BASE}/ask/capability`,
+  askJobs: `${SPOTPATCH_API_BASE}/ask/jobs`,
   externalHandoffCapability: `${SPOTPATCH_API_BASE}/external-handoff/capability`,
   externalHandoffPublish: `${SPOTPATCH_API_BASE}/external-handoff/publish`,
   externalHandoffStatus: `${SPOTPATCH_API_BASE}/external-handoff/status`,
@@ -804,6 +1389,17 @@ var SPOTPATCH_ENDPOINTS = Object.freeze({
 function getAgentJobEndpoint(jobId, action) {
   return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
 }
+function getAskJobEndpoint(jobId, action, options = {}) {
+  const endpoint = `${SPOTPATCH_ENDPOINTS.askJobs}/${encodeURIComponent(jobId)}/${action}`;
+  if (action !== "events" && options.afterSequence !== void 0) {
+    throw new RangeError("afterSequence is only valid for the events endpoint.");
+  }
+  if (options.afterSequence === void 0) return endpoint;
+  if (!Number.isSafeInteger(options.afterSequence) || options.afterSequence < 0) {
+    throw new RangeError("afterSequence must be a non-negative safe integer.");
+  }
+  return `${endpoint}?afterSequence=${String(options.afterSequence)}`;
+}
 
 // src/model/editor.ts
 var SPOTPATCH_EDITOR_PREFERENCES = ["auto", "vscode", "cursor"];
@@ -878,39 +1474,39 @@ var SPOTPATCH_NEXT_ROUTER_KINDS = Object.freeze([
   "pages",
   "hybrid"
 ]);
-var boundedText2 = (maximum) => import_zod2.z.string().trim().min(1).max(maximum);
-var profileIdSchema = import_zod2.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
-var runtimeAiModelSchema = import_zod2.z.strictObject({
-  id: profileIdSchema,
+var boundedText2 = (maximum) => import_zod4.z.string().trim().min(1).max(maximum);
+var profileIdSchema2 = import_zod4.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+var runtimeAiModelSchema = import_zod4.z.strictObject({
+  id: profileIdSchema2,
   label: boundedText2(100)
 });
-var runtimeAiProviderSchema = import_zod2.z.strictObject({
-  id: profileIdSchema,
+var runtimeAiProviderSchema = import_zod4.z.strictObject({
+  id: profileIdSchema2,
   label: boundedText2(100),
-  protocol: import_zod2.z.enum(["responses", "chat-completions"]),
-  models: import_zod2.z.array(runtimeAiModelSchema).min(1).max(64),
-  defaultModel: profileIdSchema
+  protocol: import_zod4.z.enum(["responses", "chat-completions"]),
+  models: import_zod4.z.array(runtimeAiModelSchema).min(1).max(64),
+  defaultModel: profileIdSchema2
 }).refine(
   ({ defaultModel, models }) => models.some(({ id }) => id === defaultModel) && new Set(models.map(({ id }) => id)).size === models.length,
   { message: "Runtime AI model profiles are inconsistent." }
 );
-var runtimeAiConfigSchema = import_zod2.z.discriminatedUnion("enabled", [
-  import_zod2.z.strictObject({ enabled: import_zod2.z.literal(false) }),
-  import_zod2.z.strictObject({
-    enabled: import_zod2.z.literal(true),
-    providers: import_zod2.z.array(runtimeAiProviderSchema).min(1).max(32),
-    defaultProvider: profileIdSchema,
-    applyMode: import_zod2.z.enum(AGENT_APPLY_MODES)
+var runtimeAiConfigSchema = import_zod4.z.discriminatedUnion("enabled", [
+  import_zod4.z.strictObject({ enabled: import_zod4.z.literal(false) }),
+  import_zod4.z.strictObject({
+    enabled: import_zod4.z.literal(true),
+    providers: import_zod4.z.array(runtimeAiProviderSchema).min(1).max(32),
+    defaultProvider: profileIdSchema2,
+    applyMode: import_zod4.z.enum(AGENT_APPLY_MODES)
   }).refine(
     ({ defaultProvider, providers }) => providers.some(({ id }) => id === defaultProvider) && new Set(providers.map(({ id }) => id)).size === providers.length,
     { message: "Runtime AI provider profiles are inconsistent." }
   )
 ]);
-var positiveInteger = import_zod2.z.number().int().positive();
+var positiveInteger = import_zod4.z.number().int().positive();
 var runtimeConfigBaseShape = {
-  apiBase: import_zod2.z.literal(SPOTPATCH_API_BASE),
+  apiBase: import_zod4.z.literal(SPOTPATCH_API_BASE),
   ai: runtimeAiConfigSchema,
-  budget: import_zod2.z.strictObject({
+  budget: import_zod4.z.strictObject({
     totalCharacters: positiveInteger,
     domCharacters: positiveInteger,
     cssCharacters: positiveInteger,
@@ -918,29 +1514,30 @@ var runtimeConfigBaseShape = {
     maxCodeLines: positiveInteger,
     maxComponentDepth: positiveInteger
   }),
-  debug: import_zod2.z.boolean(),
+  contextualAsk: import_zod4.z.strictObject({ enabled: import_zod4.z.boolean() }),
+  debug: import_zod4.z.boolean(),
   dataFlow: runtimeDataFlowConfigSchema,
-  editor: import_zod2.z.enum(SPOTPATCH_EDITOR_PREFERENCES),
-  externalAgent: import_zod2.z.strictObject({ enabled: import_zod2.z.boolean() }),
+  editor: import_zod4.z.enum(SPOTPATCH_EDITOR_PREFERENCES),
+  externalAgent: import_zod4.z.strictObject({ enabled: import_zod4.z.boolean() }),
   frameworkVersion: boundedText2(64),
-  locale: import_zod2.z.enum(SPOTPATCH_LOCALE_PREFERENCES),
-  maxTargets: import_zod2.z.number().int().min(1).max(MAX_ANNOTATION_TARGETS),
-  redact: import_zod2.z.boolean(),
-  sessionId: import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
-  sessionToken: import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  locale: import_zod4.z.enum(SPOTPATCH_LOCALE_PREFERENCES),
+  maxTargets: import_zod4.z.number().int().min(1).max(MAX_ANNOTATION_TARGETS),
+  redact: import_zod4.z.boolean(),
+  sessionId: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  sessionToken: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
   shortcut: boundedText2(128),
   spotPatchVersion: boundedText2(64)
 };
-var runtimeConfigSchema = import_zod2.z.discriminatedUnion("framework", [
-  import_zod2.z.strictObject({
+var runtimeConfigSchema = import_zod4.z.discriminatedUnion("framework", [
+  import_zod4.z.strictObject({
     ...runtimeConfigBaseShape,
-    framework: import_zod2.z.literal("vite")
+    framework: import_zod4.z.literal("vite")
   }),
-  import_zod2.z.strictObject({
+  import_zod4.z.strictObject({
     ...runtimeConfigBaseShape,
-    bundler: import_zod2.z.enum(SPOTPATCH_NEXT_BUNDLERS),
-    framework: import_zod2.z.literal("next"),
-    routerKind: import_zod2.z.enum(SPOTPATCH_NEXT_ROUTER_KINDS)
+    bundler: import_zod4.z.enum(SPOTPATCH_NEXT_BUNDLERS),
+    framework: import_zod4.z.literal("next"),
+    routerKind: import_zod4.z.enum(SPOTPATCH_NEXT_ROUTER_KINDS)
   })
 ]);
 
@@ -968,7 +1565,7 @@ function parseSourceMarker(value) {
 }
 
 // src/protocol/external-agent-control.ts
-var import_zod3 = require("zod");
+var import_zod5 = require("zod");
 var EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION = 1;
 var EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS = Object.freeze(["codex"]);
 var EXTERNAL_AGENT_MODES = Object.freeze(["inbox", "managed"]);
@@ -1093,9 +1690,9 @@ var EXTERNAL_AGENT_CONTROL_LIMITS = Object.freeze({
   maximumEventLineBytes: 64 * 1024,
   maximumResultDiffBytes: DEFAULT_AGENT_LIMITS.maxDiffBytes
 });
-var isoTimestampSchema = import_zod3.z.iso.datetime();
-var requestIdSchema = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
-var safeRelativePathSchema = import_zod3.z.string().min(1).max(4096).superRefine((value, context) => {
+var isoTimestampSchema = import_zod5.z.iso.datetime();
+var requestIdSchema = import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var safeRelativePathSchema = import_zod5.z.string().min(1).max(4096).superRefine((value, context) => {
   const segments = value.split("/");
   if (value.startsWith("/") || value.includes("\\") || segments.some(
     (segment) => segment.length === 0 || segment === "." || segment === ".."
@@ -1103,237 +1700,150 @@ var safeRelativePathSchema = import_zod3.z.string().min(1).max(4096).superRefine
     context.addIssue({ code: "custom", message: "Expected a safe relative path." });
   }
 });
-var externalAgentErrorSchema = import_zod3.z.strictObject({
-  code: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_CODES),
-  stage: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_STAGES),
-  recoverability: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_RECOVERABILITY),
-  action: import_zod3.z.enum(EXTERNAL_AGENT_ACTIONS)
+var externalAgentErrorSchema = import_zod5.z.strictObject({
+  code: import_zod5.z.enum(EXTERNAL_AGENT_ERROR_CODES),
+  stage: import_zod5.z.enum(EXTERNAL_AGENT_ERROR_STAGES),
+  recoverability: import_zod5.z.enum(EXTERNAL_AGENT_ERROR_RECOVERABILITY),
+  action: import_zod5.z.enum(EXTERNAL_AGENT_ACTIONS)
 });
-var managedFileSummarySchema = import_zod3.z.strictObject({
+var managedFileSummarySchema = import_zod5.z.strictObject({
   path: safeRelativePathSchema,
-  additions: import_zod3.z.number().int().nonnegative(),
-  deletions: import_zod3.z.number().int().nonnegative()
-});
-var managedCheckSummarySchema = import_zod3.z.strictObject({
-  id: import_zod3.z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/u),
-  outcome: import_zod3.z.enum(EXTERNAL_AGENT_CHECK_OUTCOMES),
-  durationMs: import_zod3.z.number().int().nonnegative(),
-  exitCode: import_zod3.z.number().int().optional()
-});
-var managedTimingSummarySchema = import_zod3.z.strictObject({
-  preparing: import_zod3.z.number().int().nonnegative().optional(),
-  agent: import_zod3.z.number().int().nonnegative().optional(),
-  auditing: import_zod3.z.number().int().nonnegative().optional(),
-  validating: import_zod3.z.number().int().nonnegative().optional(),
-  applying: import_zod3.z.number().int().nonnegative().optional(),
-  total: import_zod3.z.number().int().nonnegative().optional()
-});
-var managedTaskStatusSchema = import_zod3.z.strictObject({
-  revision: import_zod3.z.number().int().positive(),
-  deliveryStatus: import_zod3.z.enum(EXTERNAL_AGENT_DELIVERY_STATUSES),
-  executionStatus: import_zod3.z.enum(EXTERNAL_AGENT_EXECUTION_STATUSES),
-  managedPhase: import_zod3.z.enum(EXTERNAL_AGENT_MANAGED_PHASES),
-  validationOutcome: import_zod3.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES).optional(),
-  files: import_zod3.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
-  checks: import_zod3.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  additions: import_zod5.z.number().int().nonnegative(),
+  deletions: import_zod5.z.number().int().nonnegative()
+});
+var managedCheckSummarySchema = import_zod5.z.strictObject({
+  id: import_zod5.z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/u),
+  outcome: import_zod5.z.enum(EXTERNAL_AGENT_CHECK_OUTCOMES),
+  durationMs: import_zod5.z.number().int().nonnegative(),
+  exitCode: import_zod5.z.number().int().optional()
+});
+var managedTimingSummarySchema = import_zod5.z.strictObject({
+  preparing: import_zod5.z.number().int().nonnegative().optional(),
+  agent: import_zod5.z.number().int().nonnegative().optional(),
+  auditing: import_zod5.z.number().int().nonnegative().optional(),
+  validating: import_zod5.z.number().int().nonnegative().optional(),
+  applying: import_zod5.z.number().int().nonnegative().optional(),
+  total: import_zod5.z.number().int().nonnegative().optional()
+});
+var managedTaskStatusSchema = import_zod5.z.strictObject({
+  revision: import_zod5.z.number().int().positive(),
+  deliveryStatus: import_zod5.z.enum(EXTERNAL_AGENT_DELIVERY_STATUSES),
+  executionStatus: import_zod5.z.enum(EXTERNAL_AGENT_EXECUTION_STATUSES),
+  managedPhase: import_zod5.z.enum(EXTERNAL_AGENT_MANAGED_PHASES),
+  validationOutcome: import_zod5.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES).optional(),
+  files: import_zod5.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: import_zod5.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
   timings: managedTimingSummarySchema,
   resultExpiresAt: isoTimestampSchema.optional()
 });
-var externalAgentControlStatusSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION),
-  sequence: import_zod3.z.number().int().nonnegative(),
-  mode: import_zod3.z.enum(EXTERNAL_AGENT_MODES),
-  adapter: import_zod3.z.strictObject({
-    kind: import_zod3.z.enum(EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS),
-    maturity: import_zod3.z.literal("experimental"),
-    availability: import_zod3.z.enum(["available", "unavailable"])
+var externalAgentControlStatusSchema = import_zod5.z.strictObject({
+  schemaVersion: import_zod5.z.literal(EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION),
+  sequence: import_zod5.z.number().int().nonnegative(),
+  mode: import_zod5.z.enum(EXTERNAL_AGENT_MODES),
+  adapter: import_zod5.z.strictObject({
+    kind: import_zod5.z.enum(EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS),
+    maturity: import_zod5.z.literal("experimental"),
+    availability: import_zod5.z.enum(["available", "unavailable"])
   }),
-  connectionState: import_zod3.z.enum(EXTERNAL_AGENT_CONNECTION_STATES),
-  authReadiness: import_zod3.z.enum(EXTERNAL_AGENT_AUTH_READINESS),
-  grantState: import_zod3.z.enum(EXTERNAL_AGENT_GRANT_STATES),
-  requestedModel: import_zod3.z.string().min(1).max(128).optional(),
-  effectiveModel: import_zod3.z.string().min(1).max(128).optional(),
+  connectionState: import_zod5.z.enum(EXTERNAL_AGENT_CONNECTION_STATES),
+  authReadiness: import_zod5.z.enum(EXTERNAL_AGENT_AUTH_READINESS),
+  grantState: import_zod5.z.enum(EXTERNAL_AGENT_GRANT_STATES),
+  requestedModel: import_zod5.z.string().min(1).max(128).optional(),
+  effectiveModel: import_zod5.z.string().min(1).max(128).optional(),
   task: managedTaskStatusSchema.optional(),
   error: externalAgentErrorSchema.optional(),
   updatedAt: isoTimestampSchema
 });
-var externalAgentControlStatusRequestSchema = import_zod3.z.strictObject({});
-var externalAgentControlConnectRequestSchema = import_zod3.z.strictObject({
+var externalAgentControlStatusRequestSchema = import_zod5.z.strictObject({});
+var externalAgentControlConnectRequestSchema = import_zod5.z.strictObject({
   requestId: requestIdSchema,
-  adapterKind: import_zod3.z.literal("codex"),
-  profile: import_zod3.z.literal(EXTERNAL_AGENT_MANAGED_PROFILE)
+  adapterKind: import_zod5.z.literal("codex"),
+  profile: import_zod5.z.literal(EXTERNAL_AGENT_MANAGED_PROFILE)
 });
-var externalAgentControlDisconnectRequestSchema = import_zod3.z.strictObject({
+var externalAgentControlDisconnectRequestSchema = import_zod5.z.strictObject({
   requestId: requestIdSchema,
-  adapterKind: import_zod3.z.literal("codex"),
-  revokeGrant: import_zod3.z.boolean()
+  adapterKind: import_zod5.z.literal("codex"),
+  revokeGrant: import_zod5.z.boolean()
 });
-var externalAgentControlCancelRequestSchema = import_zod3.z.strictObject({
+var externalAgentControlCancelRequestSchema = import_zod5.z.strictObject({
   requestId: requestIdSchema,
-  revision: import_zod3.z.number().int().positive()
+  revision: import_zod5.z.number().int().positive()
 });
-var externalAgentEventsRequestSchema = import_zod3.z.strictObject({
-  afterSequence: import_zod3.z.number().int().nonnegative().optional()
+var externalAgentEventsRequestSchema = import_zod5.z.strictObject({
+  afterSequence: import_zod5.z.number().int().nonnegative().optional()
 });
-var externalAgentEventSchema = import_zod3.z.discriminatedUnion("type", [
-  import_zod3.z.strictObject({
-    type: import_zod3.z.literal("status"),
+var externalAgentEventSchema = import_zod5.z.discriminatedUnion("type", [
+  import_zod5.z.strictObject({
+    type: import_zod5.z.literal("status"),
     data: externalAgentControlStatusSchema
   }),
-  import_zod3.z.strictObject({
-    type: import_zod3.z.literal("heartbeat"),
-    sequence: import_zod3.z.number().int().nonnegative(),
+  import_zod5.z.strictObject({
+    type: import_zod5.z.literal("heartbeat"),
+    sequence: import_zod5.z.number().int().nonnegative(),
     emittedAt: isoTimestampSchema
   })
 ]);
-var externalAgentResultRequestSchema = import_zod3.z.strictObject({
-  revision: import_zod3.z.number().int().positive()
-});
-var externalAgentManagedResultSchema = import_zod3.z.strictObject({
-  revision: import_zod3.z.number().int().positive(),
-  diff: import_zod3.z.string().max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumResultDiffBytes),
-  files: import_zod3.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
-  checks: import_zod3.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+var externalAgentResultRequestSchema = import_zod5.z.strictObject({
+  revision: import_zod5.z.number().int().positive()
+});
+var externalAgentManagedResultSchema = import_zod5.z.strictObject({
+  revision: import_zod5.z.number().int().positive(),
+  diff: import_zod5.z.string().max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumResultDiffBytes),
+  files: import_zod5.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: import_zod5.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
   timings: managedTimingSummarySchema,
-  validationOutcome: import_zod3.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES),
+  validationOutcome: import_zod5.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES),
   expiresAt: isoTimestampSchema
 });
 
 // src/protocol/external-handoff.ts
-var import_zod5 = require("zod");
+var import_zod7 = require("zod");
 
 // src/protocol/requests.ts
-var import_zod4 = require("zod");
-var runtimeBootstrapRequestSchema = import_zod4.z.strictObject({});
-var sourceCoordinatesSchema = import_zod4.z.strictObject({
-  fileId: import_zod4.z.string().min(1).max(128),
-  line: import_zod4.z.number().int().positive(),
-  column: import_zod4.z.number().int().positive()
+var import_zod6 = require("zod");
+var runtimeBootstrapRequestSchema = import_zod6.z.strictObject({});
+var sourceCoordinatesSchema = import_zod6.z.strictObject({
+  fileId: import_zod6.z.string().min(1).max(128),
+  line: import_zod6.z.number().int().positive(),
+  column: import_zod6.z.number().int().positive()
 });
 var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: import_zod4.z.number().int().positive()
+  maxLines: import_zod6.z.number().int().positive()
 }).strict();
 var openEditorRequestSchema = sourceCoordinatesSchema.strict();
 var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
-  schemaVersion: import_zod4.z.literal(1),
-  sourceVersion: import_zod4.z.string().min(1).max(128).optional()
+  schemaVersion: import_zod6.z.literal(1),
+  sourceVersion: import_zod6.z.string().min(1).max(128).optional()
 }).strict();
-var dataFlowComponentIdentityRequestSchema = import_zod4.z.strictObject({
-  schemaVersion: import_zod4.z.literal(1),
-  componentSourceId: import_zod4.z.string().min(1).max(128),
-  sourceVersion: import_zod4.z.string().min(1).max(128)
+var dataFlowComponentIdentityRequestSchema = import_zod6.z.strictObject({
+  schemaVersion: import_zod6.z.literal(1),
+  componentSourceId: import_zod6.z.string().min(1).max(128),
+  sourceVersion: import_zod6.z.string().min(1).max(128)
 });
-var dataFlowComponentReportRequestSchema = import_zod4.z.union([
+var dataFlowComponentReportRequestSchema = import_zod6.z.union([
   dataFlowSourceCoordinatesRequestSchema,
   dataFlowComponentIdentityRequestSchema
 ]);
-var dataFlowPageReportRequestSchema = import_zod4.z.strictObject({
-  schemaVersion: import_zod4.z.literal(1),
-  targets: import_zod4.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
-});
-var profileIdSchema2 = import_zod4.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString = (maximum) => import_zod4.z.string().max(maximum);
-var sourceRefSchema = import_zod4.z.strictObject({
-  fileId: boundedString(128).optional(),
-  relativePath: boundedString(1024).optional(),
-  line: import_zod4.z.number().int().positive().optional(),
-  column: import_zod4.z.number().int().positive().optional(),
-  origin: import_zod4.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
-  confidence: import_zod4.z.enum(["exact", "probable", "approximate", "unknown"])
-});
-var matchedStyleRuleSchema = import_zod4.z.strictObject({
-  selector: boundedString(2048),
-  declarations: boundedString(8192),
-  source: boundedString(1024).optional(),
-  media: boundedString(1024).optional()
-});
-var codeContextSchema = import_zod4.z.strictObject({
-  relativePath: boundedString(1024),
-  language: import_zod4.z.enum(["tsx", "jsx"]),
-  startLine: import_zod4.z.number().int().positive(),
-  endLine: import_zod4.z.number().int().positive(),
-  excerpt: boundedString(16e3),
-  boundary: import_zod4.z.enum(["component", "nearby-lines"])
+var dataFlowPageReportRequestSchema = import_zod6.z.strictObject({
+  schemaVersion: import_zod6.z.literal(1),
+  targets: import_zod6.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
 });
-var pageContextSchema = import_zod4.z.strictObject({
-  url: boundedString(2048),
-  pathname: boundedString(2048),
-  title: boundedString(1024),
-  viewportWidth: import_zod4.z.number().nonnegative(),
-  viewportHeight: import_zod4.z.number().nonnegative(),
-  devicePixelRatio: import_zod4.z.number().positive()
-});
-var spotTargetContextRequestSchema = import_zod4.z.strictObject({
-  instruction: import_zod4.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
-  page: pageContextSchema.optional(),
-  source: sourceRefSchema,
-  react: import_zod4.z.strictObject({
-    supported: import_zod4.z.boolean(),
-    version: boundedString(64).optional(),
-    componentName: boundedString(256).optional(),
-    componentSourceId: boundedString(128).optional(),
-    sourceVersion: boundedString(128).optional(),
-    componentStack: import_zod4.z.array(boundedString(256)).max(64),
-    source: sourceRefSchema.optional()
-  }),
-  element: import_zod4.z.strictObject({
-    tagName: boundedString(128),
-    selector: boundedString(2048),
-    sanitizedHtml: boundedString(8192),
-    textPreview: boundedString(2048).optional(),
-    role: boundedString(256).optional(),
-    rect: import_zod4.z.strictObject({
-      x: import_zod4.z.number(),
-      y: import_zod4.z.number(),
-      width: import_zod4.z.number().nonnegative(),
-      height: import_zod4.z.number().nonnegative()
-    })
-  }),
-  styles: import_zod4.z.strictObject({
-    classNames: import_zod4.z.array(boundedString(512)).max(256),
-    inlineStyle: boundedString(8192).optional(),
-    matchedRules: import_zod4.z.array(matchedStyleRuleSchema).max(256),
-    computed: import_zod4.z.record(boundedString(256), boundedString(2048)),
-    warnings: import_zod4.z.array(boundedString(1024)).max(64)
-  }),
-  code: codeContextSchema.optional(),
-  warnings: import_zod4.z.array(boundedString(1024)).max(64)
+var profileIdSchema3 = import_zod6.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var agentCapabilityRequestSchema = import_zod6.z.strictObject({
+  providerProfileId: profileIdSchema3,
+  modelProfileId: profileIdSchema3
 });
-var spotAnnotationRequestSchema = import_zod4.z.strictObject({
-  schemaVersion: import_zod4.z.literal(3),
-  id: boundedString(128),
-  locale: import_zod4.z.enum(SPOTPATCH_LOCALES),
-  page: pageContextSchema,
-  targets: import_zod4.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
-  createdAt: import_zod4.z.iso.datetime()
-}).superRefine((annotation, context) => {
-  const total = annotation.targets.reduce(
-    (characters, target) => characters + target.instruction.length,
-    0
-  );
-  if (total > MAX_ANNOTATION_INSTRUCTION_CHARACTERS) {
-    context.addIssue({
-      code: "custom",
-      message: "Combined target instructions exceed the annotation limit.",
-      path: ["targets"]
-    });
-  }
+var agentWorkspaceHealthRequestSchema = import_zod6.z.strictObject({});
+var agentJobCreateRequestSchema = import_zod6.z.strictObject({
+  annotation: spotAnnotationSchema,
+  applyMode: import_zod6.z.enum(AGENT_APPLY_MODES).optional(),
+  providerProfileId: profileIdSchema3,
+  modelProfileId: profileIdSchema3,
+  providerDataConsent: import_zod6.z.literal(true),
+  trustedFastModeConsent: import_zod6.z.literal(true).optional(),
+  workingTreeMode: import_zod6.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
 });
-var agentCapabilityRequestSchema = import_zod4.z.strictObject({
-  providerProfileId: profileIdSchema2,
-  modelProfileId: profileIdSchema2
-});
-var agentWorkspaceHealthRequestSchema = import_zod4.z.strictObject({});
-var agentJobCreateRequestSchema = import_zod4.z.strictObject({
-  annotation: spotAnnotationRequestSchema,
-  applyMode: import_zod4.z.enum(AGENT_APPLY_MODES).optional(),
-  providerProfileId: profileIdSchema2,
-  modelProfileId: profileIdSchema2,
-  providerDataConsent: import_zod4.z.literal(true),
-  trustedFastModeConsent: import_zod4.z.literal(true).optional(),
-  workingTreeMode: import_zod4.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
-});
-var agentJobActionRequestSchema = import_zod4.z.strictObject({});
+var agentJobActionRequestSchema = import_zod6.z.strictObject({});
 
 // src/protocol/external-handoff-constants.ts
 var EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -1399,44 +1909,44 @@ var EXTERNAL_HANDOFF_LIMITS = Object.freeze({
 });
 
 // src/protocol/external-handoff.ts
-var opaqueIdSchema2 = import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
-var isoTimestampSchema2 = import_zod5.z.iso.datetime();
-var externalHandoffReportableDispatchPhaseSchema = import_zod5.z.enum(
+var opaqueIdSchema2 = import_zod7.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var isoTimestampSchema2 = import_zod7.z.iso.datetime();
+var externalHandoffReportableDispatchPhaseSchema = import_zod7.z.enum(
   EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES
 );
-var externalHandoffPageSummarySchema = import_zod5.z.strictObject({
-  origin: import_zod5.z.string().min(1).max(2048),
-  pathname: import_zod5.z.string().min(1).max(2048)
+var externalHandoffPageSummarySchema = import_zod7.z.strictObject({
+  origin: import_zod7.z.string().min(1).max(2048),
+  pathname: import_zod7.z.string().min(1).max(2048)
 });
-var externalHandoffSummarySchema = import_zod5.z.strictObject({
+var externalHandoffSummarySchema = import_zod7.z.strictObject({
   sessionId: opaqueIdSchema2,
-  framework: import_zod5.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
-  revision: import_zod5.z.number().int().positive(),
+  framework: import_zod7.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  revision: import_zod7.z.number().int().positive(),
   cursor: opaqueIdSchema2,
-  targetCount: import_zod5.z.number().int().positive(),
+  targetCount: import_zod7.z.number().int().positive(),
   page: externalHandoffPageSummarySchema,
   publishedAt: isoTimestampSchema2,
   expiresAt: isoTimestampSchema2,
-  state: import_zod5.z.enum(EXTERNAL_HANDOFF_STATES),
-  pickupCount: import_zod5.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
+  state: import_zod7.z.enum(EXTERNAL_HANDOFF_STATES),
+  pickupCount: import_zod7.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
   pickedUpAt: isoTimestampSchema2.optional()
 });
-var externalHandoffSnapshotSchema = import_zod5.z.strictObject({
-  schemaVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+var externalHandoffSnapshotSchema = import_zod7.z.strictObject({
+  schemaVersion: import_zod7.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
   cursor: opaqueIdSchema2,
-  session: import_zod5.z.strictObject({
+  session: import_zod7.z.strictObject({
     id: opaqueIdSchema2,
-    framework: import_zod5.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
+    framework: import_zod7.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
   }),
-  revision: import_zod5.z.number().int().positive(),
+  revision: import_zod7.z.number().int().positive(),
   publishedAt: isoTimestampSchema2,
   expiresAt: isoTimestampSchema2,
-  annotation: spotAnnotationRequestSchema
+  annotation: spotAnnotationSchema
 });
-var activeAdapterSummarySchema = import_zod5.z.strictObject({
-  kind: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
-  state: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
-  canDispatch: import_zod5.z.boolean(),
+var activeAdapterSummarySchema = import_zod7.z.strictObject({
+  kind: import_zod7.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  state: import_zod7.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
+  canDispatch: import_zod7.z.boolean(),
   connectedAt: isoTimestampSchema2,
   updatedAt: isoTimestampSchema2
 }).superRefine((value, context) => {
@@ -1448,83 +1958,258 @@ var activeAdapterSummarySchema = import_zod5.z.strictObject({
     });
   }
 });
-var dispatchSummarySchema = import_zod5.z.strictObject({
-  adapterKind: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
-  revision: import_zod5.z.number().int().positive(),
-  phase: import_zod5.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
+var dispatchSummarySchema = import_zod7.z.strictObject({
+  adapterKind: import_zod7.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  revision: import_zod7.z.number().int().positive(),
+  phase: import_zod7.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
   updatedAt: isoTimestampSchema2
 });
-var externalHandoffCapabilityRequestSchema = import_zod5.z.strictObject({});
-var externalHandoffPublishRequestSchema = import_zod5.z.strictObject({
+var externalHandoffCapabilityRequestSchema = import_zod7.z.strictObject({});
+var externalHandoffPublishRequestSchema = import_zod7.z.strictObject({
   requestId: opaqueIdSchema2,
-  annotation: spotAnnotationRequestSchema
+  annotation: spotAnnotationSchema
 });
-var externalHandoffStatusRequestSchema = import_zod5.z.strictObject({
+var externalHandoffStatusRequestSchema = import_zod7.z.strictObject({
   cursor: opaqueIdSchema2.optional()
 });
-var externalHandoffResolveDeliveryRequestSchema = import_zod5.z.strictObject({
+var externalHandoffResolveDeliveryRequestSchema = import_zod7.z.strictObject({
   cursor: opaqueIdSchema2,
-  confirmation: import_zod5.z.literal("workspace-reviewed")
-});
-var externalHandoffCapabilitySchema = import_zod5.z.strictObject({
-  enabled: import_zod5.z.literal(true),
-  brokerReady: import_zod5.z.boolean(),
-  activeWaitCount: import_zod5.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
-  snapshotSchemaVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
-  brokerProtocolVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  confirmation: import_zod7.z.literal("workspace-reviewed")
+});
+var externalHandoffCapabilitySchema = import_zod7.z.strictObject({
+  enabled: import_zod7.z.literal(true),
+  brokerReady: import_zod7.z.boolean(),
+  activeWaitCount: import_zod7.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
+  snapshotSchemaVersion: import_zod7.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  brokerProtocolVersion: import_zod7.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
 });
-var externalHandoffPublishDeliverySchema = import_zod5.z.discriminatedUnion("mode", [
-  import_zod5.z.strictObject({ mode: import_zod5.z.literal("inbox") }),
-  import_zod5.z.strictObject({
-    mode: import_zod5.z.literal("active"),
+var externalHandoffPublishDeliverySchema = import_zod7.z.discriminatedUnion("mode", [
+  import_zod7.z.strictObject({ mode: import_zod7.z.literal("inbox") }),
+  import_zod7.z.strictObject({
+    mode: import_zod7.z.literal("active"),
     adapter: activeAdapterSummarySchema,
     dispatch: dispatchSummarySchema
   })
 ]);
-var externalHandoffPublishResultSchema = import_zod5.z.strictObject({
+var externalHandoffPublishResultSchema = import_zod7.z.strictObject({
   handoff: externalHandoffSummarySchema,
   delivery: externalHandoffPublishDeliverySchema,
-  replayed: import_zod5.z.boolean()
+  replayed: import_zod7.z.boolean()
 });
-var externalHandoffStatusResultSchema = import_zod5.z.strictObject({
+var externalHandoffStatusResultSchema = import_zod7.z.strictObject({
   handoff: externalHandoffSummarySchema,
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
 });
 
+// src/protocol/contextual-ask.ts
+var import_zod8 = require("zod");
+var limits2 = CONTEXTUAL_ASK_LIMITS;
+var timestampSchema = import_zod8.z.iso.datetime();
+var contextualAskCapabilityRequestSchema = import_zod8.z.strictObject({});
+var askJobCreateRequestSchema = import_zod8.z.strictObject({
+  schemaVersion: import_zod8.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  requestId: contextualAskOpaqueIdSchema,
+  envelope: spotAskTaskEnvelopeSchema,
+  executorId: contextualAskOpaqueIdSchema,
+  providerDataConsent: import_zod8.z.literal(true)
+});
+var askJobActionRequestSchema = import_zod8.z.strictObject({});
+var askJobEventsRequestSchema = import_zod8.z.strictObject({
+  afterSequence: import_zod8.z.number().int().nonnegative().optional()
+});
+var askJobExecutorSnapshotSchema = import_zod8.z.strictObject({
+  executorId: contextualAskOpaqueIdSchema,
+  kind: import_zod8.z.enum(CONTEXTUAL_ASK_EXECUTOR_KINDS),
+  label: contextualAskBoundedText(limits2.maximumLabelCharacters),
+  modelLabel: contextualAskBoundedText(limits2.maximumLabelCharacters)
+});
+var askJobSnapshotSchema = import_zod8.z.strictObject({
+  schemaVersion: import_zod8.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  jobId: contextualAskOpaqueIdSchema,
+  selectionId: contextualAskOpaqueIdSchema,
+  status: import_zod8.z.enum(ASK_JOB_STATUSES),
+  executor: askJobExecutorSnapshotSchema,
+  phaseMessage: contextualAskBoundedText(
+    limits2.maximumPhaseMessageCharacters
+  ).optional(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  canCancel: import_zod8.z.boolean(),
+  errorCode: import_zod8.z.enum(CONTEXTUAL_ASK_ERROR_CODES).optional()
+}).superRefine((snapshot, context) => {
+  if (Date.parse(snapshot.updatedAt) < Date.parse(snapshot.createdAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "Job updatedAt must not precede createdAt.",
+      path: ["updatedAt"]
+    });
+  }
+  const cancellable = ["queued", "authorizing", "running"].includes(snapshot.status);
+  if (snapshot.canCancel !== cancellable) {
+    context.addIssue({
+      code: "custom",
+      message: "Job canCancel does not match its status.",
+      path: ["canCancel"]
+    });
+  }
+  if (snapshot.status === "failed" && snapshot.errorCode === void 0 || snapshot.status === "failed" && snapshot.errorCode === "ASK_CANCELLED" || snapshot.status === "cancelled" && snapshot.errorCode !== "ASK_CANCELLED" || snapshot.status !== "failed" && snapshot.status !== "cancelled" && snapshot.errorCode !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Job errorCode does not match its terminal status.",
+      path: ["errorCode"]
+    });
+  }
+});
+var askJobResultResponseSchema = import_zod8.z.strictObject({
+  snapshot: askJobSnapshotSchema,
+  result: askAnswerResultSchema.optional()
+}).superRefine((response, context) => {
+  const answered = response.snapshot.status === "answered";
+  if (answered !== (response.result !== void 0)) {
+    context.addIssue({
+      code: "custom",
+      message: "Only an answered job must contain an answer result.",
+      path: ["result"]
+    });
+    return;
+  }
+  if (response.result !== void 0 && (response.result.jobId !== response.snapshot.jobId || response.result.selectionId !== response.snapshot.selectionId || response.result.executor.executorId !== response.snapshot.executor.executorId)) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer result identity does not match the job snapshot.",
+      path: ["result"]
+    });
+  }
+});
+var askJobEventBaseShape = {
+  schemaVersion: import_zod8.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  sequence: import_zod8.z.number().int().positive(),
+  jobId: contextualAskOpaqueIdSchema,
+  status: import_zod8.z.enum(ASK_JOB_STATUSES),
+  timestamp: timestampSchema
+};
+var askJobSnapshotEventSchema = import_zod8.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod8.z.literal("snapshot"),
+  snapshot: askJobSnapshotSchema
+});
+var askJobPhaseEventSchema = import_zod8.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod8.z.literal("phase"),
+  message: contextualAskBoundedText(limits2.maximumPhaseMessageCharacters)
+});
+var askReadSourceActivitySchema = import_zod8.z.strictObject({
+  kind: import_zod8.z.literal("source"),
+  sourceId: contextualAskOpaqueIdSchema,
+  relativePath: contextualAskRelativePathSchema
+});
+var askReadFileCountActivitySchema = import_zod8.z.strictObject({
+  kind: import_zod8.z.literal("file-count"),
+  bucket: import_zod8.z.enum(ASK_FILE_COUNT_BUCKETS)
+});
+var askJobReadActivityEventSchema = import_zod8.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod8.z.literal("read-activity"),
+  activity: import_zod8.z.discriminatedUnion("kind", [
+    askReadSourceActivitySchema,
+    askReadFileCountActivitySchema
+  ]),
+  state: import_zod8.z.enum(ASK_READ_ACTIVITY_STATES)
+});
+var askJobAnswerReadyEventSchema = import_zod8.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod8.z.literal("answer-ready")
+});
+var askJobErrorEventSchema = import_zod8.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod8.z.literal("error"),
+  errorCode: import_zod8.z.enum(CONTEXTUAL_ASK_ERROR_CODES)
+});
+var askJobEventSchema = import_zod8.z.discriminatedUnion("type", [
+  askJobSnapshotEventSchema,
+  askJobPhaseEventSchema,
+  askJobReadActivityEventSchema,
+  askJobAnswerReadyEventSchema,
+  askJobErrorEventSchema
+]).superRefine((event, context) => {
+  if (event.type === "snapshot" && (event.snapshot.jobId !== event.jobId || event.snapshot.status !== event.status)) {
+    context.addIssue({
+      code: "custom",
+      message: "Snapshot event identity does not match its envelope.",
+      path: ["snapshot"]
+    });
+  }
+  if (event.type === "read-activity" && event.status !== "running") {
+    context.addIssue({
+      code: "custom",
+      message: "Read activity is only valid while a job is running.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "phase" && ["answered", "cancelled", "failed"].includes(event.status)) {
+    context.addIssue({
+      code: "custom",
+      message: "Phase events cannot report a terminal state.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "answer-ready" && event.status !== "answered") {
+    context.addIssue({
+      code: "custom",
+      message: "Answer-ready must report the answered state.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "error" && !["failed", "cancelled"].includes(event.status)) {
+    context.addIssue({
+      code: "custom",
+      message: "Error events must report a terminal error state.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "error" && (event.status === "cancelled" && event.errorCode !== "ASK_CANCELLED" || event.status === "failed" && event.errorCode === "ASK_CANCELLED")) {
+    context.addIssue({
+      code: "custom",
+      message: "Error event code does not match its status.",
+      path: ["errorCode"]
+    });
+  }
+});
+
 // src/protocol/agent-schemas.ts
-var import_zod6 = require("zod");
-var profileIdSchema3 = import_zod6.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString2 = (maximum) => import_zod6.z.string().max(maximum);
-var errorCodeSchema = import_zod6.z.enum(ERROR_CODES);
-var agentCapabilitySnapshotSchema = import_zod6.z.strictObject({
-  providerProfileId: profileIdSchema3,
+var import_zod9 = require("zod");
+var profileIdSchema4 = import_zod9.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString2 = (maximum) => import_zod9.z.string().max(maximum);
+var errorCodeSchema = import_zod9.z.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = import_zod9.z.strictObject({
+  providerProfileId: profileIdSchema4,
   providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema3,
+  modelProfileId: profileIdSchema4,
   modelLabel: boundedString2(100),
-  protocol: import_zod6.z.enum(["responses", "chat-completions"]),
-  state: import_zod6.z.enum(AGENT_CAPABILITY_STATES),
-  authenticated: import_zod6.z.boolean(),
-  modelAvailable: import_zod6.z.boolean(),
-  toolCalling: import_zod6.z.boolean(),
-  toolResultContinuation: import_zod6.z.boolean(),
-  streaming: import_zod6.z.boolean(),
-  checkedAt: import_zod6.z.iso.datetime().optional(),
+  protocol: import_zod9.z.enum(["responses", "chat-completions"]),
+  state: import_zod9.z.enum(AGENT_CAPABILITY_STATES),
+  authenticated: import_zod9.z.boolean(),
+  modelAvailable: import_zod9.z.boolean(),
+  toolCalling: import_zod9.z.boolean(),
+  toolResultContinuation: import_zod9.z.boolean(),
+  streaming: import_zod9.z.boolean(),
+  checkedAt: import_zod9.z.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-var agentWorkspaceHealthSnapshotSchema = import_zod6.z.strictObject({
-  state: import_zod6.z.enum(AGENT_WORKSPACE_STATES),
-  checkedAt: import_zod6.z.iso.datetime(),
-  changes: import_zod6.z.strictObject({
-    staged: import_zod6.z.number().int().nonnegative(),
-    unstaged: import_zod6.z.number().int().nonnegative(),
-    untracked: import_zod6.z.number().int().nonnegative(),
-    conflicted: import_zod6.z.number().int().nonnegative(),
-    total: import_zod6.z.number().int().nonnegative()
+var agentWorkspaceHealthSnapshotSchema = import_zod9.z.strictObject({
+  state: import_zod9.z.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: import_zod9.z.iso.datetime(),
+  changes: import_zod9.z.strictObject({
+    staged: import_zod9.z.number().int().nonnegative(),
+    unstaged: import_zod9.z.number().int().nonnegative(),
+    untracked: import_zod9.z.number().int().nonnegative(),
+    conflicted: import_zod9.z.number().int().nonnegative(),
+    total: import_zod9.z.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: import_zod6.z.boolean(),
+  canIncludeLocalChanges: import_zod9.z.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -1542,42 +2227,42 @@ var agentWorkspaceHealthSnapshotSchema = import_zod6.z.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = import_zod6.z.strictObject({
+var agentChangedFileSchema = import_zod9.z.strictObject({
   relativePath: boundedString2(1024),
-  kind: import_zod6.z.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: import_zod6.z.number().int().nonnegative(),
-  deletions: import_zod6.z.number().int().nonnegative()
+  kind: import_zod9.z.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: import_zod9.z.number().int().nonnegative(),
+  deletions: import_zod9.z.number().int().nonnegative()
 });
-var agentCheckResultSchema = import_zod6.z.strictObject({
-  checkId: profileIdSchema3,
+var agentCheckResultSchema = import_zod9.z.strictObject({
+  checkId: profileIdSchema4,
   label: boundedString2(100),
-  status: import_zod6.z.enum(AGENT_CHECK_STATUSES),
-  durationMs: import_zod6.z.number().int().nonnegative(),
+  status: import_zod9.z.enum(AGENT_CHECK_STATUSES),
+  durationMs: import_zod9.z.number().int().nonnegative(),
   output: boundedString2(8e4)
 });
-var agentJobSnapshotSchema = import_zod6.z.strictObject({
-  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod6.z.enum(AGENT_JOB_STATUSES),
-  providerProfileId: profileIdSchema3,
+var agentJobSnapshotSchema = import_zod9.z.strictObject({
+  jobId: import_zod9.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod9.z.enum(AGENT_JOB_STATUSES),
+  providerProfileId: profileIdSchema4,
   providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema3,
+  modelProfileId: profileIdSchema4,
   modelLabel: boundedString2(100),
   phaseMessage: boundedString2(1024),
-  createdAt: import_zod6.z.iso.datetime(),
-  updatedAt: import_zod6.z.iso.datetime(),
-  canCancel: import_zod6.z.boolean(),
-  canApply: import_zod6.z.boolean(),
-  canRevert: import_zod6.z.boolean(),
+  createdAt: import_zod9.z.iso.datetime(),
+  updatedAt: import_zod9.z.iso.datetime(),
+  canCancel: import_zod9.z.boolean(),
+  canApply: import_zod9.z.boolean(),
+  canRevert: import_zod9.z.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = import_zod6.z.strictObject({
-  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+var agentJobResultSchema = import_zod9.z.strictObject({
+  jobId: import_zod9.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
   summary: boundedString2(8e4),
   diff: boundedString2(1e6),
-  files: import_zod6.z.array(agentChangedFileSchema).max(100),
-  checks: import_zod6.z.array(agentCheckResultSchema).max(100)
+  files: import_zod9.z.array(agentChangedFileSchema).max(100),
+  checks: import_zod9.z.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = import_zod6.z.strictObject({
+var agentJobResultResponseSchema = import_zod9.z.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -1589,44 +2274,44 @@ var agentJobResultResponseSchema = import_zod6.z.strictObject({
     });
   }
 });
-var agentJobEventBaseSchema = import_zod6.z.strictObject({
-  schemaVersion: import_zod6.z.literal(2),
-  sequence: import_zod6.z.number().int().positive(),
-  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod6.z.enum(AGENT_JOB_STATUSES),
-  timestamp: import_zod6.z.iso.datetime()
+var agentJobEventBaseSchema = import_zod9.z.strictObject({
+  schemaVersion: import_zod9.z.literal(2),
+  sequence: import_zod9.z.number().int().positive(),
+  jobId: import_zod9.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod9.z.enum(AGENT_JOB_STATUSES),
+  timestamp: import_zod9.z.iso.datetime()
 });
-var agentJobEventSchema = import_zod6.z.discriminatedUnion("type", [
+var agentJobEventSchema = import_zod9.z.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: import_zod6.z.literal("snapshot"),
-    data: import_zod6.z.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: import_zod9.z.literal("snapshot"),
+    data: import_zod9.z.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod6.z.literal("phase"),
-    data: import_zod6.z.strictObject({ message: boundedString2(1024) })
+    type: import_zod9.z.literal("phase"),
+    data: import_zod9.z.strictObject({ message: boundedString2(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod6.z.literal("tool"),
-    data: import_zod6.z.strictObject({
-      turn: import_zod6.z.number().int().positive(),
+    type: import_zod9.z.literal("tool"),
+    data: import_zod9.z.strictObject({
+      turn: import_zod9.z.number().int().positive(),
       toolCallId: boundedString2(256),
       toolName: boundedString2(100),
-      state: import_zod6.z.enum(["started", "succeeded", "failed"]),
+      state: import_zod9.z.enum(["started", "succeeded", "failed"]),
       relativePath: boundedString2(1024).optional(),
       checkLabel: boundedString2(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod6.z.literal("check"),
-    data: import_zod6.z.strictObject({ result: agentCheckResultSchema })
+    type: import_zod9.z.literal("check"),
+    data: import_zod9.z.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod6.z.literal("result-ready"),
-    data: import_zod6.z.strictObject({ hasResult: import_zod6.z.literal(true) })
+    type: import_zod9.z.literal("result-ready"),
+    data: import_zod9.z.strictObject({ hasResult: import_zod9.z.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod6.z.literal("error"),
-    data: import_zod6.z.strictObject({
+    type: import_zod9.z.literal("error"),
+    data: import_zod9.z.strictObject({
       code: errorCodeSchema,
       message: boundedString2(1024)
     })
@@ -1662,6 +2347,18 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   AGENT_JOB_STATUSES,
   AGENT_WORKSPACE_SNAPSHOT_LIMITS,
   AGENT_WORKSPACE_STATES,
+  ASK_ANSWER_WARNING_CODES,
+  ASK_EXECUTOR_ANSWER_WARNING_CODES,
+  ASK_FILE_COUNT_BUCKETS,
+  ASK_JOB_STATUSES,
+  ASK_READ_ACTIVITY_STATES,
+  ASK_SOURCE_CONFIDENCES,
+  CONTEXTUAL_ASK_ERROR_CODES,
+  CONTEXTUAL_ASK_EXECUTOR_KINDS,
+  CONTEXTUAL_ASK_EXECUTOR_STATES,
+  CONTEXTUAL_ASK_LIMITS,
+  CONTEXTUAL_ASK_PERMISSION_PROFILE,
+  CONTEXTUAL_ASK_SCHEMA_VERSION,
   DATA_FLOW_ASSOCIATION_KINDS,
   DATA_FLOW_DIAGNOSTIC_CODES,
   DATA_FLOW_EXECUTION_STATES,
@@ -1732,7 +2429,26 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   agentJobSnapshotSchema,
   agentWorkspaceHealthRequestSchema,
   agentWorkspaceHealthSnapshotSchema,
+  askAnswerBlockSchema,
+  askAnswerDraftBlockSchema,
+  askAnswerDraftSchema,
+  askAnswerResultSchema,
+  askAnswerWarningSchema,
+  askDraftCitationSchema,
+  askDraftOriginSchema,
+  askJobActionRequestSchema,
+  askJobCreateRequestSchema,
+  askJobEventSchema,
+  askJobEventsRequestSchema,
+  askJobResultResponseSchema,
+  askJobSnapshotSchema,
+  askSourceReferenceSchema,
   componentDataFlowReportSchema,
+  contextualAskCapabilityRequestSchema,
+  contextualAskCapabilitySchema,
+  contextualAskExecutorCapabilitySchema,
+  contextualAskExecutorPreferenceSchema,
+  contextualAskOptionsSchema,
   dataDependencySchema,
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
@@ -1760,6 +2476,7 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   externalHandoffSummarySchema,
   formatSourceMarker,
   getAgentJobEndpoint,
+  getAskJobEndpoint,
   isErrorCode,
   isSensitiveName,
   limitDataFlowReportCollections,
@@ -1778,6 +2495,11 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   sanitizeUrl,
   sourceContextRequestSchema,
   spotAnnotationRequestSchema,
-  spotTargetContextRequestSchema
+  spotAskTaskEnvelopeSchema,
+  spotChangeTaskEnvelopeSchema,
+  spotSelectionContextSchema,
+  spotSelectionTargetSchema,
+  spotTargetContextRequestSchema,
+  spotTaskEnvelopeSchema
 });
 //# sourceMappingURL=index.cjs.map