@eigenpal/cli 0.16.1 → 0.16.3

package/dist/cli.js

@@ -2845,7 +2845,7 @@ var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, guid, uuid = (version) => {
 }, email, _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`, ipv4, ipv6, cidrv4, cidrv6, base64, base64url, httpProtocol, e164, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date, string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
-}, bigint, integer, number, boolean, lowercase, uppercase;
+}, bigint, integer, number, boolean, _null, lowercase, uppercase;
 var init_regexes = __esm(() => {
   cuid = /^[cC][0-9a-z]{6,}$/;
   cuid2 = /^[0-9a-z]+$/;
@@ -2869,6 +2869,7 @@ var init_regexes = __esm(() => {
   integer = /^-?\d+$/;
   number = /^-?\d+(?:\.\d+)?$/;
   boolean = /^(?:true|false)$/i;
+  _null = /^null$/i;
   lowercase = /^[^A-Z]*$/;
   uppercase = /^[^a-z]*$/;
 });
@@ -3630,7 +3631,7 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
-var $ZodType, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodBigInt, $ZodUnknown, $ZodNever, $ZodDate, $ZodArray, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodTuple, $ZodRecord, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodReadonly, $ZodLazy, $ZodCustom;
+var $ZodType, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodBigInt, $ZodNull, $ZodUnknown, $ZodNever, $ZodDate, $ZodArray, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodTuple, $ZodRecord, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodReadonly, $ZodLazy, $ZodCustom;
 var init_schemas = __esm(() => {
   init_checks();
   init_core();
@@ -4080,6 +4081,23 @@ var init_schemas = __esm(() => {
       return payload;
     };
   });
+  $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = _null;
+    inst._zod.values = new Set([null]);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (input === null)
+        return payload;
+      payload.issues.push({
+        expected: "null",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
   $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload) => payload;
@@ -5409,6 +5427,12 @@ function _coercedBigint(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _null2(Class, params) {
+  return new Class({
+    type: "null",
+    ...normalizeParams(params)
+  });
+}
 function _unknown(Class) {
   return new Class({
     type: "unknown"
@@ -6637,6 +6661,9 @@ function int(params) {
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
 }
+function _null3(params) {
+  return _null2(ZodNull, params);
+}
 function unknown() {
   return _unknown(ZodUnknown);
 }
@@ -6824,7 +6851,7 @@ function _instanceof(cls, params = {}) {
   };
   return inst;
 }
-var _installedGroups, ZodType, _ZodString, ZodString, ZodStringFormat, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodBigInt, ZodUnknown, ZodNever, ZodDate, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodReadonly, ZodLazy, ZodCustom;
+var _installedGroups, ZodType, _ZodString, ZodString, ZodStringFormat, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodBigInt, ZodNull, ZodUnknown, ZodNever, ZodDate, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodReadonly, ZodLazy, ZodCustom;
 var init_schemas2 = __esm(() => {
   init_core2();
   init_core2();
@@ -7219,6 +7246,11 @@ var init_schemas2 = __esm(() => {
     inst.maxValue = bag.maximum ?? null;
     inst.format = bag.format ?? null;
   });
+  ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
+    $ZodNull.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => nullProcessor(inst, ctx, json, params);
+  });
   ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
     $ZodUnknown.init(inst, def);
     ZodType.init(inst, def);
@@ -7672,6 +7704,9 @@ var init_common = __esm(() => {
     EVAL_BATCH: "evb",
     RUN_REVIEW: "rev",
     RUN_REVIEW_CORRECTION: "rvc",
+    HUMAN_REVIEW_TASK: "hrt",
+    HUMAN_REVIEW_FIELD_DECISION: "hrd",
+    HUMAN_REVIEW_FIELD_MUTATION: "hrm",
     TABLE_ROW: "row",
     FOLDER: "fldr",
     AGENT_WORKFLOW: "awf",
@@ -8275,13 +8310,14 @@ var init_extract = __esm(() => {
   ExtractInputSchema = object({
     content: string2().optional().describe("Text content to extract from"),
     text: string2().optional().describe("Text content (alternative to content, e.g., from document parser)"),
+    structured: unknown().optional().describe("Optional structured document (ParsedDocument or parser-owned structured output). Validated at the extract use boundary."),
     contentType: _enum(["text", "image"]).default("text"),
     imageData: string2().optional(),
     imageMimeType: string2().optional()
-  }).refine((data) => data.content || data.text, {
-    message: "Either content or text must be provided"
+  }).refine((data) => data.content || data.text || data.structured !== undefined, {
+    message: "Either content, text, or structured must be provided"
   });
-  ExtractOutputSchema = record(string2(), unknown()).describe("Extracted structured data matching the provided schema. Unless grounding is disabled (grounded: false), the output also carries a reserved `_grounding` map keyed by field name: `_grounding.<field> = { confidence: high|medium|low, needsReview, reason?, source_span: { start, end, text, alignment } | null }`, plus reserved `_degraded: true` / `_reason` markers when the grounding LLM pass could not run.");
+  ExtractOutputSchema = record(string2(), unknown()).describe('Extracted structured data matching the provided schema. Unless grounding is disabled (grounded: false), the output also carries a reserved `_grounding` map keyed by dotted field path: `_grounding["line_items.0.amount"] = { confidence: high|medium|low, score?, needsReview, reason?, quote?, citations?, source_span }`, plus reserved `_degraded: true` / `_reason` markers when grounding could not run the shared algorithm or the Eigenpal text pass. Lineage is never included in this JSON.');
   ExtractConfigSchema = object({
     schema: record(string2(), unknown()).describe("JSON Schema defining the structure to extract"),
     prompt: string2().optional().describe("Custom prompt template for extraction"),
@@ -15678,6 +15714,310 @@ var init_email_servers = __esm(() => {
   ]).meta({ id: "TestEmailServerResponse" });
 });
 
+// ../types/src/human-review.ts
+function jsonByteLength(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function countJsonPointerPatternSegments(pointer) {
+  return pointer.length <= 1 ? 0 : pointer.slice(1).split("/").length;
+}
+function selectionPatternLimitMessage(limit, label, actual) {
+  return `${label} exceeds the ${limit} limit (${actual} provided)`;
+}
+function refineHumanReviewSelectionSize(selection, ctx) {
+  const selectionBytes = jsonByteLength(selection);
+  if (selectionBytes > HUMAN_REVIEW_LIMITS.selectionBytes) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Review selection exceeds the ${HUMAN_REVIEW_LIMITS.selectionBytes} byte limit (${selectionBytes} bytes)`,
+      path: []
+    });
+  }
+}
+function createHumanReviewSelectionBaseSchema(fieldPolicySchema) {
+  return object({
+    include: array(HumanReviewJsonPointerPatternSchema).default([]).superRefine((patterns, ctx) => {
+      if (patterns.length > HUMAN_REVIEW_LIMITS.selectionIncludePatterns) {
+        ctx.addIssue({
+          code: ZodIssueCode.custom,
+          message: selectionPatternLimitMessage(HUMAN_REVIEW_LIMITS.selectionIncludePatterns, "selection.include pattern count", patterns.length)
+        });
+      }
+    }).optional().describe("RFC 6901 pointers or wildcard patterns (for example `/items/*/amount`)"),
+    exclude: array(HumanReviewJsonPointerPatternSchema).default([]).superRefine((patterns, ctx) => {
+      if (patterns.length > HUMAN_REVIEW_LIMITS.selectionExcludePatterns) {
+        ctx.addIssue({
+          code: ZodIssueCode.custom,
+          message: selectionPatternLimitMessage(HUMAN_REVIEW_LIMITS.selectionExcludePatterns, "selection.exclude pattern count", patterns.length)
+        });
+      }
+    }).optional().describe("RFC 6901 pointers removed after include expansion"),
+    fields: record(HumanReviewJsonPointerPatternSchema, fieldPolicySchema).superRefine((fields, ctx) => {
+      const count = Object.keys(fields).length;
+      if (count > HUMAN_REVIEW_LIMITS.selectionFieldPolicies) {
+        ctx.addIssue({
+          code: ZodIssueCode.custom,
+          message: selectionPatternLimitMessage(HUMAN_REVIEW_LIMITS.selectionFieldPolicies, "selection.fields policy count", count)
+        });
+      }
+    }).optional().describe("Per-field selection policy keyed by exact pointers or wildcard patterns. Exact beats the most specific wildcard; equally specific overlapping wildcards are rejected.")
+  }).strict().superRefine((selection, ctx) => {
+    refineHumanReviewSelectionSize(selection, ctx);
+  });
+}
+var HUMAN_REVIEW_LIMITS, FEATURE_OFF_VALUES, INVALID_JSON_POINTER_ESCAPE, HumanReviewJsonPointerSchema, HumanReviewJsonPointerPatternSchema, HumanReviewCategoricalConfidenceSchema, HumanReviewNumericConfidenceSchema, HumanReviewMetadataFromSchema, HumanReviewResolvedConfidenceSchema, HumanReviewConfidenceValueSchema, HumanReviewFieldMetadataSchema, HumanReviewFieldPolicySchema, HumanReviewSelectionBaseSchema, HumanReviewSelectionSchema, HumanReviewFilesSchema, HumanReviewResolvedRequestSchema, HumanReviewFieldMetadataInputSchema, HumanReviewFieldPolicyInputSchema, HumanReviewSelectionInputBaseSchema, HumanReviewSelectionInputSchema, HumanReviewStepConfigSchema, HumanReviewSelectionReasonSchema, HumanReviewTaskStatusSchema, HumanReviewSourceKindSchema, HumanReviewScalarSchema, HUMAN_REVIEW_FILE_ROLES, HumanReviewFileRoleSchema, HumanReviewFileSchema, HumanReviewInputProjectionSchema, HumanReviewFieldDecisionSchema, HumanReviewTaskSummarySchema, HumanReviewTaskListResponseSchema, HumanReviewConflictSchema, HumanReviewLineageSourceSchema, HumanReviewMutationBaseSchema, HumanReviewConfirmFieldSchema, HumanReviewApproveSchema, HumanReviewRejectSchema, HumanReviewAgentContinuationManifestSchema;
+var init_human_review = __esm(() => {
+  init_zod();
+  init_common();
+  HUMAN_REVIEW_LIMITS = {
+    dataBytes: 2 * 1024 * 1024,
+    scalarLeaves: 1e4,
+    metadataBytes: 1024 * 1024,
+    requiredFields: 2000,
+    selectionIncludePatterns: 200,
+    selectionExcludePatterns: 200,
+    selectionFieldPolicies: 500,
+    selectionPatternChars: 512,
+    selectionPatternSegments: 32,
+    selectionBytes: 256 * 1024,
+    attachments: 100,
+    agentContinuationBytes: 10 * 1024 * 1024,
+    agentContinuationRetentionDays: 30
+  };
+  FEATURE_OFF_VALUES = new Set(["0", "false", "off", "no"]);
+  INVALID_JSON_POINTER_ESCAPE = /~(?![01])/;
+  HumanReviewJsonPointerSchema = string2().refine((value) => value.startsWith("/") && !INVALID_JSON_POINTER_ESCAPE.test(value), {
+    message: 'Expected an RFC 6901 JSON Pointer beginning with "/"'
+  });
+  HumanReviewJsonPointerPatternSchema = HumanReviewJsonPointerSchema.max(HUMAN_REVIEW_LIMITS.selectionPatternChars, {
+    message: `JSON Pointer pattern exceeds the ${HUMAN_REVIEW_LIMITS.selectionPatternChars} character limit`
+  }).superRefine((value, ctx) => {
+    const segmentCount = countJsonPointerPatternSegments(value);
+    if (segmentCount > HUMAN_REVIEW_LIMITS.selectionPatternSegments) {
+      ctx.addIssue({
+        code: ZodIssueCode.custom,
+        message: selectionPatternLimitMessage(HUMAN_REVIEW_LIMITS.selectionPatternSegments, "JSON Pointer pattern segment count", segmentCount)
+      });
+    }
+  }).refine((value) => value.slice(1).split("/").every((segment) => segment === "*" || !segment.includes("*")), { message: "A wildcard must occupy an entire JSON Pointer segment" });
+  HumanReviewCategoricalConfidenceSchema = _enum(["low", "medium", "high"]);
+  HumanReviewNumericConfidenceSchema = number2().finite().min(0).max(1);
+  HumanReviewMetadataFromSchema = _enum(["ai.extract"]).describe("Producer adapter. `ai.extract` derives field confidence from `_grounding` and strips that reserved key from review data. Grounding is not stripped unless this is set.");
+  HumanReviewResolvedConfidenceSchema = union([
+    HumanReviewNumericConfidenceSchema,
+    HumanReviewCategoricalConfidenceSchema,
+    string2().min(1)
+  ]);
+  HumanReviewConfidenceValueSchema = union([
+    HumanReviewNumericConfidenceSchema,
+    HumanReviewCategoricalConfidenceSchema
+  ]);
+  HumanReviewFieldMetadataSchema = object({
+    confidence: HumanReviewResolvedConfidenceSchema.optional().describe("Producer-supplied confidence: 0–1 numeric (legacy) or categorical low|medium|high from ai.extract grounding. Not calibrated by Eigenpal."),
+    label: string2().max(500).optional().describe("Short label shown in the review UI"),
+    description: string2().max(5000).optional().describe("Longer reviewer guidance for this field"),
+    review: _enum(["auto", "always", "never"]).default("auto").optional().describe("Legacy per-field override kept for existing tasks. Prefer selection.fields.review."),
+    display: record(string2(), unknown()).optional().describe("Opaque display metadata preserved for the review UI")
+  }).strict();
+  HumanReviewFieldPolicySchema = object({
+    review: _enum(["always", "never", "skip"]).optional().describe("Always require review, or never/skip review for matching paths"),
+    threshold: HumanReviewResolvedConfidenceSchema.optional().describe("Per-field confidence threshold; overrides the global threshold for matching paths")
+  }).strict();
+  HumanReviewSelectionBaseSchema = createHumanReviewSelectionBaseSchema(HumanReviewFieldPolicySchema);
+  HumanReviewSelectionSchema = discriminatedUnion("mode", [
+    HumanReviewSelectionBaseSchema.extend({
+      mode: literal("confidence"),
+      threshold: HumanReviewResolvedConfidenceSchema,
+      missingConfidence: _enum(["review", "skip"]).default("review").optional()
+    }),
+    HumanReviewSelectionBaseSchema.extend({
+      mode: literal("explicit")
+    }),
+    HumanReviewSelectionBaseSchema.extend({
+      mode: literal("all")
+    })
+  ]);
+  HumanReviewFilesSchema = object({
+    includeRunInputs: boolean2().default(true).optional().describe("Attach every authorized run input file to the review task"),
+    attachments: array(string2().min(1)).max(HUMAN_REVIEW_LIMITS.attachments).default([]).optional().describe("Additional current-run file or artifact template expressions")
+  }).strict();
+  HumanReviewResolvedRequestSchema = object({
+    data: union([record(string2(), unknown()), array(unknown())]),
+    schema: JsonSchemaSchema.optional(),
+    metadataFrom: HumanReviewMetadataFromSchema.optional(),
+    fieldMetadata: record(HumanReviewJsonPointerSchema, HumanReviewFieldMetadataSchema).default({}).optional(),
+    selection: HumanReviewSelectionSchema,
+    files: HumanReviewFilesSchema.default({ includeRunInputs: true, attachments: [] }).optional(),
+    instructions: string2().max(1e4).optional()
+  }).strict();
+  HumanReviewFieldMetadataInputSchema = object({
+    confidence: union([
+      HumanReviewNumericConfidenceSchema,
+      HumanReviewCategoricalConfidenceSchema,
+      string2().min(1)
+    ]).optional(),
+    label: string2().max(500).optional(),
+    description: string2().max(5000).optional(),
+    review: _enum(["auto", "always", "never"]).default("auto").optional(),
+    display: record(string2(), unknown()).optional()
+  }).strict();
+  HumanReviewFieldPolicyInputSchema = object({
+    review: _enum(["always", "never", "skip"]).optional(),
+    threshold: union([
+      HumanReviewNumericConfidenceSchema,
+      HumanReviewCategoricalConfidenceSchema,
+      string2().min(1)
+    ]).optional()
+  }).strict();
+  HumanReviewSelectionInputBaseSchema = createHumanReviewSelectionBaseSchema(HumanReviewFieldPolicyInputSchema);
+  HumanReviewSelectionInputSchema = discriminatedUnion("mode", [
+    HumanReviewSelectionInputBaseSchema.extend({
+      mode: literal("confidence").describe("Review fields below threshold or missing confidence"),
+      threshold: union([
+        HumanReviewNumericConfidenceSchema,
+        HumanReviewCategoricalConfidenceSchema,
+        string2().min(1)
+      ]).describe("Fields with confidence strictly below this value require review. Equality auto-approves. Numeric 0–1 or categorical low|medium|high. Template strings are resolved at runtime."),
+      missingConfidence: _enum(["review", "skip"]).default("review").optional().describe("Whether unscored or type-mismatched fields require review (default review)")
+    }),
+    HumanReviewSelectionInputBaseSchema.extend({
+      mode: literal("explicit").describe("Review only paths matched by include/exclude")
+    }),
+    HumanReviewSelectionInputBaseSchema.extend({
+      mode: literal("all").describe("Review every scalar leaf unless excluded or review: never")
+    })
+  ]).describe("Field selection policy resolved once when the task is created");
+  HumanReviewStepConfigSchema = object({
+    data: union([string2().min(1), record(string2(), unknown()), array(unknown())]).describe("Structured data or a template expression resolving to an object or array"),
+    schema: JsonSchemaSchema.optional().describe("Optional JSON Schema for validating edits and exposing downstream autocomplete. When omitted with metadataFrom: ai.extract and a direct whole-output data expression, the extract step schema is reused."),
+    metadataFrom: HumanReviewMetadataFromSchema.optional(),
+    fieldMetadata: record(HumanReviewJsonPointerSchema, HumanReviewFieldMetadataInputSchema).default({}).optional().describe("RFC 6901 pointer map of producer facts (labels, confidence, display). Selection policy belongs under selection.fields; fieldMetadata.review is a legacy alias."),
+    selection: HumanReviewSelectionInputSchema,
+    files: HumanReviewFilesSchema.default({ includeRunInputs: true, attachments: [] }).optional().describe("Run input files and optional current-run attachments for reviewers"),
+    instructions: string2().max(1e4).optional().describe("Free-form guidance shown above the review workspace")
+  }).strict();
+  HumanReviewSelectionReasonSchema = _enum([
+    "always",
+    "explicit",
+    "low_confidence",
+    "missing_confidence",
+    "all",
+    "reviewer_edit",
+    "threshold_met",
+    "never",
+    "excluded",
+    "unmatched",
+    "missing_confidence_skip"
+  ]);
+  HumanReviewTaskStatusSchema = _enum(["pending", "approved", "rejected", "cancelled"]);
+  HumanReviewSourceKindSchema = _enum(["workflow_step", "agent_tool"]);
+  HumanReviewScalarSchema = union([
+    string2(),
+    number2().finite(),
+    boolean2(),
+    _null3()
+  ]);
+  HUMAN_REVIEW_FILE_ROLES = ["run_input", "attachment"];
+  HumanReviewFileRoleSchema = _enum(HUMAN_REVIEW_FILE_ROLES);
+  HumanReviewFileSchema = object({
+    fileId: string2().min(1),
+    filename: string2().min(1),
+    mimeType: string2().optional(),
+    size: number2().int().nonnegative().optional(),
+    fieldName: string2().optional(),
+    artifactPath: string2().min(1),
+    role: HumanReviewFileRoleSchema.optional().describe("run_input for authorized run input files; attachment for extra current-run files. Omitted on historical tasks and inferred at read time.")
+  }).strict();
+  HumanReviewInputProjectionSchema = discriminatedUnion("status", [
+    object({
+      status: literal("available"),
+      data: union([record(string2(), unknown()), array(unknown())])
+    }).strict(),
+    object({
+      status: literal("omitted_too_large")
+    }).strict()
+  ]);
+  HumanReviewFieldDecisionSchema = object({
+    id: string2().min(1),
+    path: HumanReviewJsonPointerSchema,
+    originalValue: HumanReviewScalarSchema,
+    currentValue: HumanReviewScalarSchema,
+    required: boolean2(),
+    reason: HumanReviewSelectionReasonSchema,
+    confirmedBy: string2().nullable(),
+    confirmedAt: string2().nullable(),
+    version: number2().int().positive()
+  }).strict();
+  HumanReviewTaskSummarySchema = object({
+    id: string2().min(1),
+    executionId: string2().min(1),
+    automationId: string2().min(1),
+    automationName: string2().min(1),
+    sourceKind: HumanReviewSourceKindSchema,
+    sourceLabel: string2().min(1),
+    status: HumanReviewTaskStatusSchema,
+    requiredCount: number2().int().nonnegative(),
+    confirmedCount: number2().int().nonnegative(),
+    version: number2().int().positive(),
+    createdAt: string2(),
+    updatedAt: string2()
+  }).strict();
+  HumanReviewTaskListResponseSchema = object({
+    tasks: array(HumanReviewTaskSummarySchema),
+    nextCursor: string2().nullable()
+  }).strict();
+  HumanReviewConflictSchema = object({
+    error: string2(),
+    currentVersion: number2().int().positive().optional(),
+    status: HumanReviewTaskStatusSchema.optional()
+  }).strict();
+  HumanReviewLineageSourceSchema = object({
+    stepExecutionId: string2().min(1),
+    stepName: string2().min(1),
+    lineageArtifactKey: string2().min(1).nullable(),
+    parsedDocumentArtifactKey: string2().min(1).nullable()
+  }).strict();
+  HumanReviewMutationBaseSchema = object({
+    expectedVersion: number2().int().positive(),
+    idempotencyKey: string2().min(1).max(200)
+  }).strict();
+  HumanReviewConfirmFieldSchema = HumanReviewMutationBaseSchema.extend({
+    path: HumanReviewJsonPointerSchema,
+    value: HumanReviewScalarSchema,
+    confirmed: boolean2().default(true).optional()
+  });
+  HumanReviewApproveSchema = object({
+    expectedVersion: number2().int().positive()
+  }).strict();
+  HumanReviewRejectSchema = HumanReviewMutationBaseSchema.extend({
+    reason: string2().trim().min(1).max(5000)
+  });
+  HumanReviewAgentContinuationManifestSchema = object({
+    version: literal(1),
+    toolCallId: string2().min(1),
+    taskId: string2().min(1),
+    executionId: string2().min(1),
+    createdAt: string2().min(1),
+    expiresAt: string2().min(1),
+    cost: object({
+      totalInputTokens: number2().nonnegative(),
+      totalOutputTokens: number2().nonnegative(),
+      totalCacheReadTokens: number2().nonnegative(),
+      totalCacheWriteTokens: number2().nonnegative(),
+      agentTurns: number2().nonnegative(),
+      durationMs: number2().nonnegative().optional(),
+      e2bCostUsd: number2().nonnegative().nullable().optional()
+    }).optional(),
+    traceByteLength: number2().int().nonnegative().optional(),
+    artifacts: array(object({ name: string2().min(1) })).default([]),
+    reconstruction: object({
+      requestedSourceRef: string2().optional(),
+      resolvedGitRef: string2().optional(),
+      resolvedCommitSha: string2().optional()
+    }).optional()
+  }).strict();
+});
+
 // ../../node_modules/@babel/parser/lib/index.js
 var require_lib = __commonJS(function(exports) {
   Object.defineProperty(exports, "__esModule", {
@@ -53272,7 +53612,7 @@ var init_retry = __esm(() => {
 });
 
 // ../types/src/workflow/steps.ts
-var AI_STEP_TYPES, TRANSFORM_STEP_TYPES, ACTION_STEP_TYPES, CONTROL_STEP_TYPES, STEP_TYPES, StepTypeSchema, BaseStepSchema, ControlContainerBaseStepSchema, AIStepSchema, TransformStepSchema, HttpMethodSchema, ActionStepSchema, WaitStepSchema, FailStepSchema, LegacyBlockStepSchemaInner, IfStepSchemaInner, SwitchCaseSchemaInner, SwitchStepSchemaInner, ParallelBranchSchemaInner, ParallelStepSchemaInner, ForeachStepSchemaInner, ParallelMapStepSchemaInner, StepSchema;
+var AI_STEP_TYPES, TRANSFORM_STEP_TYPES, ACTION_STEP_TYPES, CONTROL_STEP_TYPES, STEP_TYPES, StepTypeSchema, BaseStepSchema, ControlContainerBaseStepSchema, AIStepSchema, TransformStepSchema, HttpMethodSchema, ActionStepSchema, WaitStepSchema, HumanReviewStepSchema, FailStepSchema, LegacyBlockStepSchemaInner, IfStepSchemaInner, SwitchCaseSchemaInner, SwitchStepSchemaInner, ParallelBranchSchemaInner, ParallelStepSchemaInner, ForeachStepSchemaInner, ParallelMapStepSchemaInner, StepSchema;
 var init_steps = __esm(() => {
   init_zod();
   init_retry();
@@ -53312,6 +53652,7 @@ var init_steps = __esm(() => {
     "control.parallel",
     "control.parallel_map",
     "control.wait",
+    "control.human_review",
     "control.fail"
   ];
   STEP_TYPES = [
@@ -53347,6 +53688,10 @@ var init_steps = __esm(() => {
     type: literal("control.wait"),
     duration: number2().positive().optional()
   });
+  HumanReviewStepSchema = BaseStepSchema.extend({
+    type: literal("control.human_review"),
+    with: record(string2(), unknown())
+  });
   FailStepSchema = BaseStepSchema.extend({
     type: literal("control.fail"),
     condition: string2().optional(),
@@ -53404,6 +53749,7 @@ var init_steps = __esm(() => {
     TransformStepSchema,
     ActionStepSchema,
     WaitStepSchema,
+    HumanReviewStepSchema,
     FailStepSchema,
     LegacyBlockStepSchemaInner,
     IfStepSchemaInner,
@@ -53433,12 +53779,13 @@ function getStepSchema(stepType) {
 function listStepTypes() {
   return [...STEP_TYPES];
 }
-var OptionalReasoningEffortSchema, AiParseConfigSchema, AiParseOutputSchema, AiExtractConfigSchema, AiExtractOutputSchema, VisionPageRangeSchema, AiVisionConfigSchema, AiVisionOutputSchema, AiSplitConfigSchema, AiSplitSectionSchema, AiSplitOutputSchema, AiSegmentConfigSchema, AiSegmentOutputSchema, AiClassifyConfigSchema, AiClassifyOutputSchema, ClassifyPagesLabelSchema2, AiClassifyPagesConfigSchema, AiClassifyPagesOutputSchema, TransformSetConfigSchema, TransformSetOutputSchema, TransformRemoveConfigSchema, TransformRemoveOutputSchema, TransformCombineConfigSchema, TransformCombineOutputSchema, TransformSplitConfigSchema, TransformSplitOutputSchema, TransformMergeConfigSchema, TransformMergeOutputSchema, TransformTemplateConfigSchema, TransformTemplateOutputSchema, TransformPdfEmbedConfigSchema, TransformPdfEmbedOutputSchema, TransformXlsxToJsonConfigSchema, TransformXlsxToJsonOutputSchema, JsonToXlsxAuthoringRowsSchema, JsonToXlsxSheetConfigSchema, TransformJsonToXlsxConfigSchema, TransformJsonToXlsxOutputSchema, TransformScriptConfigSchema, TransformScriptOutputSchema, ParsedDocPageSchema, TransformTextChunkerConfigSchema, TransformTextChunkerOutputSchema, RegexNormalizerSchema, RegexFormatSchema, REGEX_FLAGS, RegexFieldSchema, TransformRegexExtractConfigSchema, TransformRegexExtractOutputSchema, ActionHttpConfigSchema, ActionHttpOutputSchema, ActionInvokeWorkflowConfigSchema, ActionInvokeWorkflowOutputSchema, ActionWebsiteReaderConfigSchema, ActionWebsiteReaderOutputSchema, ACTION_EMAIL_MAX_ATTACHMENTS = 10, ACTION_EMAIL_MAX_ATTACHMENT_BYTES, ACTION_EMAIL_BODY_MAX_BYTES, emailBodyMaxBytes = (value) => new TextEncoder().encode(value).byteLength <= ACTION_EMAIL_BODY_MAX_BYTES, ActionEmailRecipientListSchema, ActionEmailToSchema, ActionEmailOptionalRecipientsSchema, ActionEmailAttachmentSchema, ActionEmailConfigSchema, ActionEmailOutputSchema, ControlIfConfigSchema, ControlIfOutputSchema, ControlSwitchConfigSchema, ControlSwitchOutputSchema, ControlForeachConfigSchema, ControlForeachOutputSchema, ControlParallelMapConfigSchema, ControlParallelMapOutputSchema, ControlParallelConfigSchema, ControlParallelOutputSchema, ControlWaitConfigSchema, ControlWaitOutputSchema, ControlFailConfigSchema, ControlFailOutputSchema, STEP_SCHEMAS;
+var OptionalReasoningEffortSchema, AiParseConfigSchema, AiParseOutputSchema, AiExtractConfigSchema, AiExtractOutputSchema, VisionPageRangeSchema, AiVisionConfigSchema, AiVisionOutputSchema, AiSplitConfigSchema, AiSplitSectionSchema, AiSplitOutputSchema, AiSegmentConfigSchema, AiSegmentOutputSchema, AiClassifyConfigSchema, AiClassifyOutputSchema, ClassifyPagesLabelSchema2, AiClassifyPagesConfigSchema, AiClassifyPagesOutputSchema, TransformSetConfigSchema, TransformSetOutputSchema, TransformRemoveConfigSchema, TransformRemoveOutputSchema, TransformCombineConfigSchema, TransformCombineOutputSchema, TransformSplitConfigSchema, TransformSplitOutputSchema, TransformMergeConfigSchema, TransformMergeOutputSchema, TransformTemplateConfigSchema, TransformTemplateOutputSchema, TransformPdfEmbedConfigSchema, TransformPdfEmbedOutputSchema, TransformXlsxToJsonConfigSchema, TransformXlsxToJsonOutputSchema, JsonToXlsxAuthoringRowsSchema, JsonToXlsxSheetConfigSchema, TransformJsonToXlsxConfigSchema, TransformJsonToXlsxOutputSchema, TransformScriptConfigSchema, TransformScriptOutputSchema, ParsedDocPageSchema, TransformTextChunkerConfigSchema, TransformTextChunkerOutputSchema, RegexNormalizerSchema, RegexFormatSchema, REGEX_FLAGS, RegexFieldSchema, TransformRegexExtractConfigSchema, TransformRegexExtractOutputSchema, ActionHttpConfigSchema, ActionHttpOutputSchema, ActionInvokeWorkflowConfigSchema, ActionInvokeWorkflowOutputSchema, ActionWebsiteReaderConfigSchema, ActionWebsiteReaderOutputSchema, ACTION_EMAIL_MAX_ATTACHMENTS = 10, ACTION_EMAIL_MAX_ATTACHMENT_BYTES, ACTION_EMAIL_BODY_MAX_BYTES, emailBodyMaxBytes = (value) => new TextEncoder().encode(value).byteLength <= ACTION_EMAIL_BODY_MAX_BYTES, ActionEmailRecipientListSchema, ActionEmailToSchema, ActionEmailOptionalRecipientsSchema, ActionEmailAttachmentSchema, ActionEmailConfigSchema, ActionEmailOutputSchema, ControlIfConfigSchema, ControlIfOutputSchema, ControlSwitchConfigSchema, ControlSwitchOutputSchema, ControlForeachConfigSchema, ControlForeachOutputSchema, ControlParallelMapConfigSchema, ControlParallelMapOutputSchema, ControlParallelConfigSchema, ControlParallelOutputSchema, ControlWaitConfigSchema, ControlWaitOutputSchema, ControlHumanReviewConfigSchema, ControlHumanReviewOutputSchema, ControlFailConfigSchema, ControlFailOutputSchema, STEP_SCHEMAS;
 var init_step_configs = __esm(() => {
   init_zod();
   init_ai_client();
   init_common();
   init_email_servers();
+  init_human_review();
   init_parser();
   init_json_to_xlsx();
   init_xlsx_to_json();
@@ -53489,7 +53836,7 @@ var init_step_configs = __esm(() => {
     })).optional().describe("Optional few-shot examples pinning grounding to verbatim source text per field."),
     reviewOn: _enum(["medium_or_low", "low_only"]).optional().describe("Which grounding confidences set needsReview on a field. Default: low_only (only fields whose value could not be located in the source). Use medium_or_low to also flag approximate and derived matches.")
   });
-  AiExtractOutputSchema = record(string2(), unknown()).describe("Extracted structured data matching the provided schema. Unless grounding is disabled (grounded: false), the output also carries a reserved `_grounding` map keyed by field name: `_grounding.<field> = { confidence: high|medium|low, needsReview, reason?, source_span: { start, end, text, alignment } | null }`, plus reserved `_degraded: true` / `_reason` markers when the grounding LLM pass could not run.");
+  AiExtractOutputSchema = record(string2(), unknown()).describe('Extracted structured data matching the provided schema. Unless grounding is disabled (grounded: false), the output also carries a reserved `_grounding` map keyed by dotted field path: `_grounding["line_items.0.amount"] = { confidence: high|medium|low, score?, needsReview, reason?, quote?, citations?, source_span }`, plus reserved `_degraded: true` / `_reason` markers when grounding could not run the shared algorithm or the Eigenpal text pass. Lineage is never included in this JSON.');
   VisionPageRangeSchema = tuple([number2().int().min(0), number2().int().min(0)]).describe("Inclusive 0-based [start, end] page range, matching ai.split page_range.");
   AiVisionConfigSchema = object({
     document: string2().describe("Template expression resolving to the input file (PDF, image, or Office document)."),
@@ -53909,7 +54256,7 @@ var init_step_configs = __esm(() => {
     execution: _enum(["inline", "child"]).optional().describe("inline: run target steps in this execution (default). child: spawn a separate run with lineage."),
     input: record(string2(), unknown()).optional().describe("Input record keyed by the invoked workflow's declared inputs"),
     wait: boolean2().optional().describe("Child mode only. Wait for the invoked workflow to complete and return its output (default: true). Set false for fire-and-forget."),
-    timeout: number2().optional().describe("Child mode only. Max wait time in ms when waiting (default: 300000)"),
+    timeout: number2().optional().describe("Child mode only. Max wait time in ms while the child is queued or running (default: 300000). Once the child pauses for human review, the parent pauses durably instead of using this timeout."),
     pollInterval: number2().optional().describe("Child mode only. How often to poll status in ms when waiting (default: 1000)")
   }).superRefine((data, ctx) => {
     const hasWorkflow = typeof data.workflow === "string" && data.workflow.length > 0;
@@ -54064,6 +54411,8 @@ var init_step_configs = __esm(() => {
   ControlWaitOutputSchema = object({
     waited: number2().describe("Actual milliseconds waited")
   });
+  ControlHumanReviewConfigSchema = HumanReviewStepConfigSchema;
+  ControlHumanReviewOutputSchema = unknown().describe("The complete reviewed data in the same object or array shape as the input.");
   ControlFailConfigSchema = object({
     condition: string2().optional().describe("Optional LiquidJS expression. When set, the step only fails if this evaluates truthy; when omitted, it always fails when reached (compose with control.if for legacy gating)."),
     statusCode: number2().int().min(400).max(599).default(422).describe("HTTP-style status code returned to the caller (sync runs) and persisted on the execution. Default 422 (Unprocessable Entity)."),
@@ -54332,6 +54681,15 @@ var init_step_configs = __esm(() => {
       outputSchema: ControlWaitOutputSchema,
       configInWith: false
     },
+    "control.human_review": {
+      type: "control.human_review",
+      category: "control",
+      name: "Human Review",
+      description: "Pause the run for selective field confirmation or correction, then continue with the reviewed data.",
+      configSchema: ControlHumanReviewConfigSchema,
+      outputSchema: ControlHumanReviewOutputSchema,
+      configInWith: true
+    },
     "control.fail": {
       type: "control.fail",
       category: "control",
@@ -54636,16 +54994,52 @@ function evalPathIsDescendant(descendant, ancestor) {
 var MAX_UNORDERED_ARRAY_ITEMS = 1000, MAX_UNORDERED_PAIR_COMPARISONS = 1e6, MAX_UNORDERED_COMPARISON_OPERATIONS = 2000000;
 var init_compare_output = () => {};
 
+// ../types/src/human-review-evaluation.ts
+var HumanReviewEvaluationFieldFixtureSchema, HumanReviewEvaluationStepFixtureSchema, HumanReviewEvaluationFixtureSchema, HumanReviewEvaluationObservationSchema;
+var init_human_review_evaluation = __esm(() => {
+  init_zod();
+  init_human_review();
+  HumanReviewEvaluationFieldFixtureSchema = object({
+    expectedRoute: _enum(["review", "skip"]).optional(),
+    expectedReason: HumanReviewSelectionReasonSchema.optional(),
+    expectedValue: HumanReviewScalarSchema.optional()
+  }).strict();
+  HumanReviewEvaluationStepFixtureSchema = object({
+    fields: record(HumanReviewJsonPointerSchema, HumanReviewEvaluationFieldFixtureSchema).default({}),
+    simulate: object({
+      outcome: literal("approved").optional(),
+      edits: record(HumanReviewJsonPointerSchema, HumanReviewScalarSchema).optional()
+    }).strict().optional()
+  }).strict();
+  HumanReviewEvaluationFixtureSchema = object({
+    version: literal(1),
+    steps: record(string2().min(1), HumanReviewEvaluationStepFixtureSchema)
+  }).strict();
+  HumanReviewEvaluationObservationSchema = object({
+    version: literal(1),
+    stepPath: string2().min(1),
+    fields: record(HumanReviewJsonPointerSchema, object({
+      route: _enum(["review", "skip"]),
+      reason: HumanReviewSelectionReasonSchema,
+      rawCorrect: boolean2().optional(),
+      corrected: boolean2().optional()
+    }).strict()),
+    simulated: boolean2()
+  }).strict();
+});
+
 // ../types/src/eval/dataset-archive.ts
 var DATASET_NAME_PATTERN, DatasetNameSchema, DatasetMetaSchema, DatasetImportModeSchema, DatasetImportRequestSchema, EvaluatorsImportRequestSchema, EvalResultsExportFormatSchema, BooleanQueryFlagSchema, ExperimentExportBaseQuerySchema, ExperimentExportQuerySchema, EvalResultExportRowSchema, EvalResultsExportJsonSchema;
 var init_dataset_archive = __esm(() => {
   init_zod();
+  init_human_review_evaluation();
   DATASET_NAME_PATTERN = /^[a-z0-9][a-z0-9-_]*$/;
   DatasetNameSchema = string2().min(1).max(128).regex(DATASET_NAME_PATTERN, "name must be lowercase kebab/snake-case").describe("Example folder name: 1-128 lowercase letters, digits, hyphens, or underscores; must start with a letter or digit.");
   DatasetMetaSchema = object({
     rowOrder: number2().int().min(0).optional().describe("Non-negative display order hint for this example."),
     annotation: string2().max(2000).optional().describe("Free-form example note, limited to 2000 characters."),
-    overrides: record(string2(), unknown()).optional().describe('Per-step output overrides as `{ "steps": { "<stepName>": <outputObject> } }`; overridden steps are skipped or partially merged during evaluation.')
+    overrides: record(string2(), unknown()).optional().describe('Per-step output overrides as `{ "steps": { "<stepName>": <outputObject> } }`; overridden steps are skipped or partially merged during evaluation.'),
+    review: HumanReviewEvaluationFixtureSchema.optional().describe("Optional human-review evaluation fixture: expected field routes and simulated approvals or edits for this example.")
   });
   DatasetImportModeSchema = _enum(["append", "replace"]).describe("append keeps existing examples; replace removes them before import.");
   DatasetImportRequestSchema = object({
@@ -54668,7 +55062,7 @@ var init_dataset_archive = __esm(() => {
     exampleName: string2().nullable(),
     batchId: string2().min(1).nullable(),
     evaluatorName: string2().min(1),
-    evaluatorType: _enum(["exact-diff", "llm-judge", "custom-script"]),
+    evaluatorType: _enum(["exact-diff", "llm-judge", "custom-script", "human-review"]),
     score: number2().nullable(),
     passed: boolean2().nullable(),
     label: string2().nullable(),
@@ -55616,10 +56010,11 @@ function validateWebhookHeaderCollection(input, ctx) {
     }
   }
 }
-var WEBHOOK_API_VERSION = "2026-07-01", WEBHOOK_MAX_PAYLOAD_BYTES, WEBHOOK_MAX_HEADERS = 20, WEBHOOK_MAX_HEADER_BYTES, WEBHOOK_EVENT_TYPES, WEBHOOK_DELIVERY_STATES, WEBHOOK_RESERVED_HEADERS, RESERVED_HEADER_SET, WebhookEventTypeSchema, WebhookDeliveryStateSchema, WebhookEndpointIdSchema, WebhookEventIdSchema, WebhookDeliveryIdSchema, WebhookAttemptIdSchema, HeaderNameSchema, WebhookCustomHeaderSchema, RetainedWebhookCustomHeaderSchema, RedactedWebhookCustomHeaderSchema, PublicWebhookRunSchema, EnvelopeBaseSchema, RunCreatedWebhookEventSchema, RunStatusChangedWebhookEventSchema, WebhookEventEnvelopeSchema, WebhookEndpointSchema, WebhookDestinationUrlSchema, CreateWebhookEndpointSchema, UpdateWebhookEndpointSchema, CreateWebhookEndpointResponseSchema, WebhookDeliverySchema, WebhookDeliveryAttemptSchema;
+var WEBHOOK_API_VERSION = "2026-07-01", WEBHOOK_MAX_PAYLOAD_BYTES, WEBHOOK_MAX_HEADERS = 20, WEBHOOK_MAX_HEADER_BYTES, WEBHOOK_EVENT_TYPES, WEBHOOK_DELIVERY_STATES, WEBHOOK_RESERVED_HEADERS, RESERVED_HEADER_SET, WebhookEventTypeSchema, WebhookDeliveryStateSchema, WebhookEndpointIdSchema, WebhookEventIdSchema, WebhookDeliveryIdSchema, WebhookAttemptIdSchema, HeaderNameSchema, WebhookCustomHeaderSchema, RetainedWebhookCustomHeaderSchema, RedactedWebhookCustomHeaderSchema, PublicWebhookRunSchema, HUMAN_REVIEW_WEBHOOK_OUTCOMES, PublicHumanReviewEventMetadataSchema, PublicWebhookHumanReviewSchema, EnvelopeBaseSchema, RunCreatedWebhookEventSchema, RunStatusChangedWebhookEventSchema, WebhookEventEnvelopeSchema, WebhookEndpointSchema, WebhookDestinationUrlSchema, CreateWebhookEndpointSchema, UpdateWebhookEndpointSchema, CreateWebhookEndpointResponseSchema, WebhookDeliverySchema, WebhookDeliveryAttemptSchema;
 var init_webhooks = __esm(() => {
   init_zod();
   init_execution_row();
+  init_human_review();
   WEBHOOK_MAX_PAYLOAD_BYTES = 1024 * 1024;
   WEBHOOK_MAX_HEADER_BYTES = 16 * 1024;
   WEBHOOK_EVENT_TYPES = ["run.created", "run.status_changed"];
@@ -55681,6 +56076,23 @@ var init_webhooks = __esm(() => {
     output: unknown().optional(),
     outputOmitted: boolean2().optional()
   });
+  HUMAN_REVIEW_WEBHOOK_OUTCOMES = [
+    "created",
+    "approved",
+    "rejected",
+    "cancelled"
+  ];
+  PublicHumanReviewEventMetadataSchema = object({
+    taskId: string2().min(1),
+    sourceKind: HumanReviewSourceKindSchema,
+    sourceLabel: string2().min(1),
+    requiredCount: number2().int().nonnegative(),
+    confirmedCount: number2().int().nonnegative().optional(),
+    actorUserId: string2().nullable().optional()
+  }).strict();
+  PublicWebhookHumanReviewSchema = PublicHumanReviewEventMetadataSchema.extend({
+    outcome: _enum(HUMAN_REVIEW_WEBHOOK_OUTCOMES)
+  }).strict();
   EnvelopeBaseSchema = object({
     id: WebhookEventIdSchema,
     apiVersion: literal(WEBHOOK_API_VERSION),
@@ -55696,7 +56108,8 @@ var init_webhooks = __esm(() => {
     data: object({
       run: PublicWebhookRunSchema,
       previousStatus: _enum(EXECUTION_STATUSES),
-      currentStatus: _enum(EXECUTION_STATUSES)
+      currentStatus: _enum(EXECUTION_STATUSES),
+      humanReview: PublicWebhookHumanReviewSchema.optional()
     })
   });
   WebhookEventEnvelopeSchema = discriminatedUnion("type", [
@@ -205733,7 +206146,7 @@ import { fileURLToPath as fileURLToPath8 } from "url";
 // package.json
 var package_default = {
   name: "@eigenpal/cli",
-  version: "0.16.1",
+  version: "0.16.3",
   description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
   keywords: [
     "eigenpal",
@@ -241476,11 +241889,19 @@ import {
 } from "node:fs";
 import { dirname as dirname4, join as join7, relative as relative2, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-var TEMPLATE_NAMES = ["blank", "pdf-extraction", "text-classification"];
+var TEMPLATE_NAMES = [
+  "blank",
+  "pdf-extraction",
+  "text-classification",
+  "human-review-confidence-exception",
+  "human-review-explicit-critical"
+];
 var TEMPLATE_DESCRIPTIONS = {
   blank: "Single-step pass-through. Good starting point when you know what you want to build.",
   "pdf-extraction": "Parse a PDF/image with the auto parser, then ai.extract structured fields against a JSON schema.",
-  "text-classification": "Classify free-form text into one of a fixed set of labels (positive/neutral/negative)."
+  "text-classification": "Classify free-form text into one of a fixed set of labels (positive/neutral/negative).",
+  "human-review-confidence-exception": "Parse and extract an invoice, then pause for human review only on low-confidence fields.",
+  "human-review-explicit-critical": "Parse and extract payment fields, then pause for explicit review of total and IBAN only."
 };
 function isValidProjectName(name) {
   return /^[a-z0-9][a-z0-9-_]*$/.test(name) && name.length <= 60;
@@ -242274,7 +242695,7 @@ async function installSkillTools(opts) {
       initialValues: initial,
       required: false
     });
-    if (q(picked)) {
+    if (q(picked) || !Array.isArray(picked)) {
       me("Aborted.");
       return;
     }
@@ -242349,7 +242770,7 @@ async function uninstallSkillTools(opts) {
       })),
       required: false
     });
-    if (q(picked)) {
+    if (q(picked) || !Array.isArray(picked)) {
       me("Aborted.");
       return;
     }
@@ -242893,6 +243314,13 @@ function validateStepConfigsRecursive(steps, pathPrefix) {
     if (step.type === "control.block") {
       continue;
     }
+    if (step.type === "control.human_review" && pathPrefix.length > 1) {
+      issues.push({
+        path: [...stepPath, "type"],
+        message: "control.human_review is supported only in the top-level step sequence; nested and concurrent review checkpoints are not supported",
+        code: "custom"
+      });
+    }
     const schemaDef = getStepSchema(step.type);
     if (schemaDef?.configInWith) {
       const cfg = step.with ?? {};