@enricai/barnacle 1.0.0

package/dist/lib/job-tracking.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Shared Zod schema fragment for the optional post-submission tracking-click
+ * URL that every plugin may receive. The engine reads `TrackingUrl`
+ * site-agnostically in loader.ts (fireTrackingClick) — this fragment is the
+ * single source of truth so a type change propagates to every plugin from one
+ * place.
+ *
+ * Compose into a plugin contract via `.extend(JobTrackingSchema.shape)` or
+ * `.merge(JobTrackingSchema)` depending on which Zod combinator the plugin
+ * already uses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobTrackingSchema = void 0;
+const v4_1 = require("zod/v4");
+exports.JobTrackingSchema = v4_1.z.object({
+    TrackingUrl: v4_1.z.url().optional(),
+});
+//# sourceMappingURL=job-tracking.js.map

package/dist/lib/job-tracking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-tracking.js","sourceRoot":"","sources":["../../src/lib/job-tracking.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAEH,+BAA2B;AAEd,QAAA,iBAAiB,GAAG,MAAC,CAAC,MAAM,CAAC;IACxC,WAAW,EAAE,MAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC"}

package/dist/lib/llm/anthropic-client.d.ts

@@ -0,0 +1,12 @@
+import Anthropic from "@anthropic-ai/sdk";
+/**
+ * Build the shared Anthropic client used by the self-heal cascade's LLM
+ * techniques (attempt-5 rephrase, replan, judges). Returns `null` on a
+ * Bedrock-only deployment or when no `ANTHROPIC_API_KEY` is configured, so
+ * callers degrade to deterministic-only healing instead of crashing. Extracted
+ * to a leaf module so every entrypoint — the recon CLI, the heal loops, and
+ * generated site plugins running {@link runHealingFlow} — resolves the client
+ * the same way rather than each duplicating the env/Bedrock gate.
+ */
+export declare function buildAnthropicClient(): Anthropic | null;
+//# sourceMappingURL=anthropic-client.d.ts.map

package/dist/lib/llm/anthropic-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-client.d.ts","sourceRoot":"","sources":["../../../src/lib/llm/anthropic-client.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAI1C;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,IAAI,SAAS,GAAG,IAAI,CAGvD"}

package/dist/lib/llm/anthropic-client.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAnthropicClient = buildAnthropicClient;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const config_1 = require("../../config");
+/**
+ * Build the shared Anthropic client used by the self-heal cascade's LLM
+ * techniques (attempt-5 rephrase, replan, judges). Returns `null` on a
+ * Bedrock-only deployment or when no `ANTHROPIC_API_KEY` is configured, so
+ * callers degrade to deterministic-only healing instead of crashing. Extracted
+ * to a leaf module so every entrypoint — the recon CLI, the heal loops, and
+ * generated site plugins running {@link runHealingFlow} — resolves the client
+ * the same way rather than each duplicating the env/Bedrock gate.
+ */
+function buildAnthropicClient() {
+    if (config_1.config.scraper.useBedrock || !config_1.config.scraper.anthropicApiKey)
+        return null;
+    return new sdk_1.default({ apiKey: config_1.config.scraper.anthropicApiKey });
+}
+//# sourceMappingURL=anthropic-client.js.map

package/dist/lib/llm/anthropic-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-client.js","sourceRoot":"","sources":["../../../src/lib/llm/anthropic-client.ts"],"names":[],"mappings":";;;;;AAaA,oDAGC;AAhBD,4DAA0C;AAE1C,qCAAkC;AAElC;;;;;;;;GAQG;AACH,SAAgB,oBAAoB;IAClC,IAAI,eAAM,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,eAAM,CAAC,OAAO,CAAC,eAAe;QAAE,OAAO,IAAI,CAAC;IAC9E,OAAO,IAAI,aAAS,CAAC,EAAE,MAAM,EAAE,eAAM,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;AACnE,CAAC"}

package/dist/lib/llm/judge.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Generic Haiku 4.5 judge primitive. Every fuzzy-data judgment in the engine
+ * routes through this — submit-verification, invalid-field detection, modal-
+ * priority ranking, error-message extraction. Replaces deterministic regexes
+ * that silently miss patterns outside what we've happened to observe across
+ * AppCast + ClearCompany (both Angular).
+ *
+ * Why a separate primitive instead of inlining into each call site:
+ *  - Single chokepoint for telemetry, error classification, and latency
+ *    accounting across all judge calls.
+ *  - Pinned model + always-on structured output prevents drift: every
+ *    call site uses `messages.parse` + `output_config.format` so Haiku's
+ *    GA constrained-decoding makes schema violations structurally
+ *    impossible.
+ *  - Soft cost-control: clamps `max_tokens` to a small default since
+ *    verdicts are small JSON blobs, not prose.
+ *
+ * Model selection: Haiku 4.5 is GA, costs $1 / $5 per million tokens
+ * (input/output), runs in ~810ms p50 TTFT on Anthropic's first-party API,
+ * and has its own rate-limit pool separate from Opus. Validated empirically
+ * 2026-06-11 on two production failure dumps — see plan file for the
+ * verifySubmit cases.
+ *
+ * On schema/API failure the wrapper returns null and logs the failureKind
+ * via classifyLlmCallFailure(); callers are expected to fall back to a
+ * conservative default (typically "not verified" / "no judgment").
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { z } from "zod/v4";
+import { type LlmCallInput } from "../../lib/telemetry/call-capture";
+/** Injectable capture function — matches `captureLlmCall`'s signature. */
+export type JudgeCaptureFn = (input: LlmCallInput) => Promise<void>;
+export interface HaikuJudgeParams<T extends z.ZodTypeAny> {
+    client: Anthropic;
+    systemPrompt: string;
+    userPrompt: string;
+    schema: T;
+    callType: string;
+    maxTokens?: number;
+    captureFn?: JudgeCaptureFn;
+}
+export interface HaikuJudgeResult<T extends z.ZodTypeAny> {
+    parsed: z.infer<T>;
+    latencyMs: number;
+}
+/**
+ * Send a structured-output judgment request to Haiku 4.5. Returns the
+ * parsed verdict and the wall-clock latency. Returns null on any failure
+ * (API error, schema-validation error, parsed_output null) — callers fall
+ * back to a conservative default.
+ *
+ * The telemetry contract matches every other engine LLM call site exactly:
+ * one NDJSON entry per call regardless of outcome, with parsedOk/success
+ * fields distinguishing happy path from failure modes.
+ */
+export declare function callHaikuJudge<T extends z.ZodTypeAny>(params: HaikuJudgeParams<T>): Promise<HaikuJudgeResult<T> | null>;
+//# sourceMappingURL=judge.d.ts.map

package/dist/lib/llm/judge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge.d.ts","sourceRoot":"","sources":["../../../src/lib/llm/judge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,8BAA8B,CAAC;AAsBtC,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEpE,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU;IACtD,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,CAAC,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU;IACtD,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACzD,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CA0ErC"}

package/dist/lib/llm/judge.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Generic Haiku 4.5 judge primitive. Every fuzzy-data judgment in the engine
+ * routes through this — submit-verification, invalid-field detection, modal-
+ * priority ranking, error-message extraction. Replaces deterministic regexes
+ * that silently miss patterns outside what we've happened to observe across
+ * AppCast + ClearCompany (both Angular).
+ *
+ * Why a separate primitive instead of inlining into each call site:
+ *  - Single chokepoint for telemetry, error classification, and latency
+ *    accounting across all judge calls.
+ *  - Pinned model + always-on structured output prevents drift: every
+ *    call site uses `messages.parse` + `output_config.format` so Haiku's
+ *    GA constrained-decoding makes schema violations structurally
+ *    impossible.
+ *  - Soft cost-control: clamps `max_tokens` to a small default since
+ *    verdicts are small JSON blobs, not prose.
+ *
+ * Model selection: Haiku 4.5 is GA, costs $1 / $5 per million tokens
+ * (input/output), runs in ~810ms p50 TTFT on Anthropic's first-party API,
+ * and has its own rate-limit pool separate from Opus. Validated empirically
+ * 2026-06-11 on two production failure dumps — see plan file for the
+ * verifySubmit cases.
+ *
+ * On schema/API failure the wrapper returns null and logs the failureKind
+ * via classifyLlmCallFailure(); callers are expected to fall back to a
+ * conservative default (typically "not verified" / "no judgment").
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callHaikuJudge = callHaikuJudge;
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("@anthropic-ai/sdk/helpers/zod");
+const logging_1 = require("../../lib/logging");
+const call_capture_1 = require("../../lib/telemetry/call-capture");
+const logger = (0, logging_1.getLogger)({ name: "haiku-judge" });
+/**
+ * Pinned Haiku version. We pin to a dated snapshot so prompts that
+ * empirically work today keep working when Anthropic ships a newer
+ * Haiku — model behavior on edge cases can shift between minor versions.
+ */
+const HAIKU_MODEL_ID = "claude-haiku-4-5-20251001";
+/** Default max-tokens for verdict outputs. Verdicts are small JSON blobs;
+ * 512 tokens comfortably covers any of our schemas including the rationale
+ * fields, while preventing accidental cost explosion if the LLM tried to
+ * write prose. */
+const DEFAULT_MAX_TOKENS = 512;
+/** Warn threshold for input prompt size. Haiku TTFT degrades with context;
+ * the cutoff below isn't a hard ceiling, just a sanity bell for prompts
+ * that would benefit from trimming before they ship to production. */
+const LARGE_PROMPT_WARN_CHARS = 32_000;
+/**
+ * Send a structured-output judgment request to Haiku 4.5. Returns the
+ * parsed verdict and the wall-clock latency. Returns null on any failure
+ * (API error, schema-validation error, parsed_output null) — callers fall
+ * back to a conservative default.
+ *
+ * The telemetry contract matches every other engine LLM call site exactly:
+ * one NDJSON entry per call regardless of outcome, with parsedOk/success
+ * fields distinguishing happy path from failure modes.
+ */
+async function callHaikuJudge(params) {
+    const { client, systemPrompt, userPrompt, schema, callType, maxTokens = DEFAULT_MAX_TOKENS, captureFn = call_capture_1.captureLlmCall, } = params;
+    if (userPrompt.length > LARGE_PROMPT_WARN_CHARS) {
+        logger.warn(`haiku-judge ${callType}: large prompt ${userPrompt.length} chars; consider trimming for latency`);
+    }
+    const callId = (0, node_crypto_1.randomUUID)();
+    const t0 = performance.now();
+    try {
+        const response = await client.messages.parse({
+            model: HAIKU_MODEL_ID,
+            max_tokens: maxTokens,
+            system: systemPrompt,
+            messages: [{ role: "user", content: userPrompt }],
+            output_config: {
+                format: (0, zod_1.zodOutputFormat)(schema),
+            },
+        });
+        const latencyMs = performance.now() - t0;
+        const parsed = response.parsed_output;
+        if (parsed === null) {
+            throw new Error("structured-output enabled but parsed_output is null");
+        }
+        const textBlock = response.content.find((b) => b.type === "text");
+        const rawText = textBlock?.type === "text" ? textBlock.text : "";
+        await captureFn({
+            callId,
+            callType,
+            model: HAIKU_MODEL_ID,
+            systemPrompt,
+            userContent: userPrompt,
+            responseContent: rawText,
+            parsedOk: true,
+            inputTokens: response.usage?.input_tokens ?? null,
+            outputTokens: response.usage?.output_tokens ?? null,
+            latencyMs,
+            success: true,
+            errorMessage: null,
+            failureKind: null,
+        });
+        return { parsed: parsed, latencyMs };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const latencyMs = performance.now() - t0;
+        await captureFn({
+            callId,
+            callType,
+            model: HAIKU_MODEL_ID,
+            systemPrompt,
+            userContent: userPrompt,
+            responseContent: null,
+            parsedOk: false,
+            inputTokens: null,
+            outputTokens: null,
+            latencyMs,
+            success: false,
+            errorMessage: message,
+            failureKind: (0, call_capture_1.classifyLlmCallFailure)(err),
+        });
+        return null;
+    }
+}
+//# sourceMappingURL=judge.js.map

package/dist/lib/llm/judge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge.js","sourceRoot":"","sources":["../../../src/lib/llm/judge.ts"],"names":[],"mappings":"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"}

package/dist/lib/llm/judges/error-messages.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Error-messages extraction judge. Replaces the framework-conventional
+ * regex `errorPattern = /(error-message|mat-error|field-error|...)/` over
+ * DOM class signatures.
+ *
+ * Why: same shape as the invalid-fields judge. The regex covered Angular
+ * and Material conventions but missed React Hook Form render-prop errors,
+ * headless UI component-based errors, toast-based error notifications,
+ * inline tooltip errors, and any site-specific error container class.
+ * When the regex missed, the rephrase prompt's VISIBLE ERROR section
+ * was `(none)` and the LLM lost the structured field-level rejection
+ * messages the server had returned.
+ *
+ * The judge extracts structurally-marked error messages with optional
+ * field hints and severity. Visual-only error styling does NOT count.
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { z } from "zod/v4";
+import { type JudgeCaptureFn } from "../../../lib/llm/judge";
+import { ERROR_MESSAGES_SCHEMA } from "../../../lib/llm/schemas";
+declare const ERROR_MESSAGES_SYSTEM_PROMPT = "You are a strict error-message extractor for browser forms. Given a body-HTML excerpt, identify visible error messages and required-field warnings tied to specific form inputs.\n\nStrict criteria for extracting a message:\n- It lives inside a structural error container (class containing \"error\", \"validation\", \"feedback\", \"invalid\", \"required\", \"help-block-error\", \"form-error\", or app-prefixed equivalent), OR\n- It's inside an aria-live=\"polite\" or aria-live=\"assertive\" region, OR\n- It's directly adjacent to a field marked aria-invalid=\"true\" or data-invalid.\n\nDo NOT extract:\n- Placeholder text inside empty inputs (placeholder= attribute).\n- Help text / hint text that's always visible and explains the field (e.g. \"Format: MM/DD/YYYY\").\n- Tooltips that auto-hide on click outside.\n- Plain prose text that happens to contain words like \"error\" but isn't a structural error indicator.\n\nEach message:\n- text: the visible message string, trimmed to \u2264400 chars.\n- fieldHint: a short identifier for the field the error applies to (label text, placeholder, name= attribute, id), or null if not discoverable.\n- severity: \"error\" for structural validation failures, \"warning\" for soft hints (e.g. \"field will be required\"), \"info\" for purely informational adjacent messages.\n\nReturn up to 50 messages. Empty array when no structural error containers are visible.";
+export interface JudgeErrorMessagesInput {
+    /** Body HTML excerpt to scan (typically the page DOM, truncated to ~8KB). */
+    bodyHtmlExcerpt: string;
+}
+/**
+ * Run the error-messages judge. Returns a list of structurally-marked
+ * error messages with field hints and severity. Returns null when the
+ * client is null (Bedrock-only) or the API call fails — callers fall back
+ * to an empty list.
+ */
+export declare function judgeErrorMessagesWithLLM(params: {
+    client: Anthropic | null;
+    input: JudgeErrorMessagesInput;
+    captureFn?: JudgeCaptureFn;
+}): Promise<z.infer<typeof ERROR_MESSAGES_SCHEMA> | null>;
+export { ERROR_MESSAGES_SYSTEM_PROMPT };
+//# sourceMappingURL=error-messages.d.ts.map

package/dist/lib/llm/judges/error-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-messages.d.ts","sourceRoot":"","sources":["../../../../src/lib/llm/judges/error-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,QAAA,MAAM,4BAA4B,y4CAkBqD,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACtC,6EAA6E;IAC7E,eAAe,EAAE,MAAM,CAAC;CACzB;AASD;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IACtD,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,uBAAuB,CAAC;IAC/B,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAAG,IAAI,CAAC,CAaxD;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAC"}

package/dist/lib/llm/judges/error-messages.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Error-messages extraction judge. Replaces the framework-conventional
+ * regex `errorPattern = /(error-message|mat-error|field-error|...)/` over
+ * DOM class signatures.
+ *
+ * Why: same shape as the invalid-fields judge. The regex covered Angular
+ * and Material conventions but missed React Hook Form render-prop errors,
+ * headless UI component-based errors, toast-based error notifications,
+ * inline tooltip errors, and any site-specific error container class.
+ * When the regex missed, the rephrase prompt's VISIBLE ERROR section
+ * was `(none)` and the LLM lost the structured field-level rejection
+ * messages the server had returned.
+ *
+ * The judge extracts structurally-marked error messages with optional
+ * field hints and severity. Visual-only error styling does NOT count.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_MESSAGES_SYSTEM_PROMPT = void 0;
+exports.judgeErrorMessagesWithLLM = judgeErrorMessagesWithLLM;
+const judge_1 = require("../../../lib/llm/judge");
+const schemas_1 = require("../../../lib/llm/schemas");
+const call_types_1 = require("../../../lib/telemetry/call-types");
+const ERROR_MESSAGES_SYSTEM_PROMPT = `You are a strict error-message extractor for browser forms. Given a body-HTML excerpt, identify visible error messages and required-field warnings tied to specific form inputs.
+
+Strict criteria for extracting a message:
+- It lives inside a structural error container (class containing "error", "validation", "feedback", "invalid", "required", "help-block-error", "form-error", or app-prefixed equivalent), OR
+- It's inside an aria-live="polite" or aria-live="assertive" region, OR
+- It's directly adjacent to a field marked aria-invalid="true" or data-invalid.
+
+Do NOT extract:
+- Placeholder text inside empty inputs (placeholder= attribute).
+- Help text / hint text that's always visible and explains the field (e.g. "Format: MM/DD/YYYY").
+- Tooltips that auto-hide on click outside.
+- Plain prose text that happens to contain words like "error" but isn't a structural error indicator.
+
+Each message:
+- text: the visible message string, trimmed to ≤400 chars.
+- fieldHint: a short identifier for the field the error applies to (label text, placeholder, name= attribute, id), or null if not discoverable.
+- severity: "error" for structural validation failures, "warning" for soft hints (e.g. "field will be required"), "info" for purely informational adjacent messages.
+
+Return up to 50 messages. Empty array when no structural error containers are visible.`;
+exports.ERROR_MESSAGES_SYSTEM_PROMPT = ERROR_MESSAGES_SYSTEM_PROMPT;
+function buildErrorMessagesPrompt(input) {
+    return `Extract visible structurally-marked error messages from this excerpt.
+
+BODY HTML EXCERPT:
+${input.bodyHtmlExcerpt}`;
+}
+/**
+ * Run the error-messages judge. Returns a list of structurally-marked
+ * error messages with field hints and severity. Returns null when the
+ * client is null (Bedrock-only) or the API call fails — callers fall back
+ * to an empty list.
+ */
+async function judgeErrorMessagesWithLLM(params) {
+    const { client, input, captureFn } = params;
+    if (client === null)
+        return null;
+    if (input.bodyHtmlExcerpt.length === 0)
+        return null;
+    const result = await (0, judge_1.callHaikuJudge)({
+        client,
+        systemPrompt: ERROR_MESSAGES_SYSTEM_PROMPT,
+        userPrompt: buildErrorMessagesPrompt(input),
+        schema: schemas_1.ERROR_MESSAGES_SCHEMA,
+        callType: call_types_1.CALL_TYPE_JUDGE_ERROR_MESSAGES,
+        captureFn,
+    });
+    return result?.parsed ?? null;
+}
+//# sourceMappingURL=error-messages.js.map

package/dist/lib/llm/judges/error-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-messages.js","sourceRoot":"","sources":["../../../../src/lib/llm/judges/error-messages.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AA+CH,8DAiBC;AA3DD,2CAAsE;AACtE,+CAA0D;AAC1D,2DAA4E;AAE5E,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;;;;;;uFAkBkD,CAAC;AAuC/E,oEAA4B;AAhCrC,SAAS,wBAAwB,CAAC,KAA8B;IAC9D,OAAO;;;EAGP,KAAK,CAAC,eAAe,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,yBAAyB,CAAC,MAI/C;IACC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IAC5C,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,IAAI,KAAK,CAAC,eAAe,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACpD,MAAM,MAAM,GAAG,MAAM,IAAA,sBAAc,EAAC;QAClC,MAAM;QACN,YAAY,EAAE,4BAA4B;QAC1C,UAAU,EAAE,wBAAwB,CAAC,KAAK,CAAC;QAC3C,MAAM,EAAE,+BAAqB;QAC7B,QAAQ,EAAE,2CAA8B;QACxC,SAAS;KACV,CAAC,CAAC;IACH,OAAO,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC;AAChC,CAAC"}

package/dist/lib/llm/judges/invalid-fields.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Invalid-fields detection judge. Replaces the framework-conventional
+ * regex `INVALID_CLASS_RX` (matching Angular ng-invalid, Material
+ * mat-form-field-invalid, Bootstrap is-invalid, etc) with a Haiku 4.5
+ * structured-output call.
+ *
+ * Why: the regex covered Angular and Bootstrap conventions but silently
+ * missed React Hook Form (aria-invalid attribute), Mantine (data-invalid),
+ * Chakra (aria-invalid), HTML5 native :invalid (no class added), Tailwind
+ * form libraries, and arbitrary site-specific markers. When the regex
+ * missed, the rephrase prompt saw `(none)` in its FORM FIELDS section and
+ * the cascade lost the V4-C redirect signal.
+ *
+ * The judge looks at a body-HTML excerpt + a list of structured field
+ * candidates (tag + class + aria attributes) and decides whether each
+ * candidate is structurally invalid (class containing "invalid",
+ * aria-invalid="true", data-invalid, or near a semantic error container).
+ * Visual-only styling does NOT count.
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { z } from "zod/v4";
+import { type JudgeCaptureFn } from "../../../lib/llm/judge";
+import { INVALID_FIELDS_SCHEMA } from "../../../lib/llm/schemas";
+declare const INVALID_FIELDS_SYSTEM_PROMPT = "You are a strict invalid-field detector for browser forms. Given a body-HTML excerpt and (optionally) site-specific class-name prefixes, identify form fields that are structurally in an invalid/error state.\n\nStrict criteria for present=true (mark a field):\n- The container has a class containing \"invalid\" (e.g. ng-invalid, mat-form-field-invalid, is-invalid, field-invalid, app-input-invalid, etc.), OR\n- The element has aria-invalid=\"true\", OR\n- The element has data-invalid (truthy), OR\n- The container is structurally adjacent to an error-message container (class containing \"error\", \"validation\", \"feedback\", \"required\", \"help-block-error\", etc.), OR\n- The element is structurally adjacent to a visible error-text span/div that explains why it's invalid.\n\nDo NOT mark a field when:\n- Only visual styling indicates error (red border via CSS, no semantic marker).\n- The container is in a pristine/untouched state (e.g. ng-pristine ng-untouched alongside ng-invalid means the user hasn't interacted yet \u2014 that's a \"may become invalid\" state, not currently invalid).\n- The element is a hidden input or non-interactive ancestor.\n- The container is invalid ONLY because a descendant is invalid (parent-bubbled invalidity). Angular bubbles ng-invalid up to wrapping forms / lists / question containers; Bootstrap mirrors this on form-group; React Hook Form propagates aria-invalid through fieldsets. When you see <ol class=\"ng-invalid\"> with <li class=\"ng-valid\"> children where ONE deeper descendant is actually invalid, report ONLY the deepest leaf that carries the failure. The leaf is the smallest container with the invalid marker AND no further invalid descendants. Reporting bubbled parents alongside the real leaf creates false positives (the parent's children look like they're invalid when they are not).\n\nWhen the supplied knownErrorClassPrefixes list is non-empty, also treat class names starting with any of those prefixes followed by \"-invalid\" or \"-error\" as structural markers (site-specific convention).\n\nReturn up to 50 fields. Top-level present=true means at least one field is currently invalid. present=false means no structural invalid markers found anywhere in the excerpt.\n\nEach field entry:\n- containerXpath: a best-effort xpath identifying the container (tag + nth-of-type)\n- label: the visible label text near the field, or null if not discoverable\n- markerKind: which marker type triggered (\"class\", \"aria\", \"data\", \"error-container\", \"other\")\n- framework: which UI library this looks like (\"angular\", \"react\", \"vue\", \"mantine\", \"chakra\", \"bootstrap\", \"other\"). Look at framework-conventional class signatures to decide.";
+export interface JudgeInvalidFieldsInput {
+    /** Body HTML excerpt to scan (typically the page DOM, truncated to ~8KB). */
+    bodyHtmlExcerpt: string;
+    /** Site-supplied class-name prefixes that wrap error/invalid state (e.g. ["uapp-", "app-"]). */
+    knownErrorClassPrefixes: readonly string[];
+}
+/**
+ * Run the invalid-fields judge. Returns the parsed verdict (a list of
+ * detected invalid containers + a top-level present boolean). Returns null
+ * when the client is null (Bedrock-only) or when the API call fails —
+ * callers fall back to a conservative "no invalid markers detected" default.
+ */
+export declare function judgeInvalidFieldsWithLLM(params: {
+    client: Anthropic | null;
+    input: JudgeInvalidFieldsInput;
+    captureFn?: JudgeCaptureFn;
+}): Promise<z.infer<typeof INVALID_FIELDS_SCHEMA> | null>;
+export { INVALID_FIELDS_SYSTEM_PROMPT };
+//# sourceMappingURL=invalid-fields.d.ts.map

package/dist/lib/llm/judges/invalid-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-fields.d.ts","sourceRoot":"","sources":["../../../../src/lib/llm/judges/invalid-fields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,QAAA,MAAM,4BAA4B,uqFAuB+I,CAAC;AAElL,MAAM,WAAW,uBAAuB;IACtC,6EAA6E;IAC7E,eAAe,EAAE,MAAM,CAAC;IACxB,gGAAgG;IAChG,uBAAuB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C;AAWD;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IACtD,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,uBAAuB,CAAC;IAC/B,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAAG,IAAI,CAAC,CAYxD;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAC"}

package/dist/lib/llm/judges/invalid-fields.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Invalid-fields detection judge. Replaces the framework-conventional
+ * regex `INVALID_CLASS_RX` (matching Angular ng-invalid, Material
+ * mat-form-field-invalid, Bootstrap is-invalid, etc) with a Haiku 4.5
+ * structured-output call.
+ *
+ * Why: the regex covered Angular and Bootstrap conventions but silently
+ * missed React Hook Form (aria-invalid attribute), Mantine (data-invalid),
+ * Chakra (aria-invalid), HTML5 native :invalid (no class added), Tailwind
+ * form libraries, and arbitrary site-specific markers. When the regex
+ * missed, the rephrase prompt saw `(none)` in its FORM FIELDS section and
+ * the cascade lost the V4-C redirect signal.
+ *
+ * The judge looks at a body-HTML excerpt + a list of structured field
+ * candidates (tag + class + aria attributes) and decides whether each
+ * candidate is structurally invalid (class containing "invalid",
+ * aria-invalid="true", data-invalid, or near a semantic error container).
+ * Visual-only styling does NOT count.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_FIELDS_SYSTEM_PROMPT = void 0;
+exports.judgeInvalidFieldsWithLLM = judgeInvalidFieldsWithLLM;
+const judge_1 = require("../../../lib/llm/judge");
+const schemas_1 = require("../../../lib/llm/schemas");
+const call_types_1 = require("../../../lib/telemetry/call-types");
+const INVALID_FIELDS_SYSTEM_PROMPT = `You are a strict invalid-field detector for browser forms. Given a body-HTML excerpt and (optionally) site-specific class-name prefixes, identify form fields that are structurally in an invalid/error state.
+
+Strict criteria for present=true (mark a field):
+- The container has a class containing "invalid" (e.g. ng-invalid, mat-form-field-invalid, is-invalid, field-invalid, app-input-invalid, etc.), OR
+- The element has aria-invalid="true", OR
+- The element has data-invalid (truthy), OR
+- The container is structurally adjacent to an error-message container (class containing "error", "validation", "feedback", "required", "help-block-error", etc.), OR
+- The element is structurally adjacent to a visible error-text span/div that explains why it's invalid.
+
+Do NOT mark a field when:
+- Only visual styling indicates error (red border via CSS, no semantic marker).
+- The container is in a pristine/untouched state (e.g. ng-pristine ng-untouched alongside ng-invalid means the user hasn't interacted yet — that's a "may become invalid" state, not currently invalid).
+- The element is a hidden input or non-interactive ancestor.
+- The container is invalid ONLY because a descendant is invalid (parent-bubbled invalidity). Angular bubbles ng-invalid up to wrapping forms / lists / question containers; Bootstrap mirrors this on form-group; React Hook Form propagates aria-invalid through fieldsets. When you see <ol class="ng-invalid"> with <li class="ng-valid"> children where ONE deeper descendant is actually invalid, report ONLY the deepest leaf that carries the failure. The leaf is the smallest container with the invalid marker AND no further invalid descendants. Reporting bubbled parents alongside the real leaf creates false positives (the parent's children look like they're invalid when they are not).
+
+When the supplied knownErrorClassPrefixes list is non-empty, also treat class names starting with any of those prefixes followed by "-invalid" or "-error" as structural markers (site-specific convention).
+
+Return up to 50 fields. Top-level present=true means at least one field is currently invalid. present=false means no structural invalid markers found anywhere in the excerpt.
+
+Each field entry:
+- containerXpath: a best-effort xpath identifying the container (tag + nth-of-type)
+- label: the visible label text near the field, or null if not discoverable
+- markerKind: which marker type triggered ("class", "aria", "data", "error-container", "other")
+- framework: which UI library this looks like ("angular", "react", "vue", "mantine", "chakra", "bootstrap", "other"). Look at framework-conventional class signatures to decide.`;
+exports.INVALID_FIELDS_SYSTEM_PROMPT = INVALID_FIELDS_SYSTEM_PROMPT;
+function buildInvalidFieldsPrompt(input) {
+    return `Identify form fields currently in an invalid/error state.
+
+KNOWN ERROR-CLASS PREFIXES (site-specific, optional): ${JSON.stringify(input.knownErrorClassPrefixes)}
+
+BODY HTML EXCERPT:
+${input.bodyHtmlExcerpt}`;
+}
+/**
+ * Run the invalid-fields judge. Returns the parsed verdict (a list of
+ * detected invalid containers + a top-level present boolean). Returns null
+ * when the client is null (Bedrock-only) or when the API call fails —
+ * callers fall back to a conservative "no invalid markers detected" default.
+ */
+async function judgeInvalidFieldsWithLLM(params) {
+    const { client, input, captureFn } = params;
+    if (client === null)
+        return null;
+    const result = await (0, judge_1.callHaikuJudge)({
+        client,
+        systemPrompt: INVALID_FIELDS_SYSTEM_PROMPT,
+        userPrompt: buildInvalidFieldsPrompt(input),
+        schema: schemas_1.INVALID_FIELDS_SCHEMA,
+        callType: call_types_1.CALL_TYPE_JUDGE_INVALID_FIELDS,
+        captureFn,
+    });
+    return result?.parsed ?? null;
+}
+//# sourceMappingURL=invalid-fields.js.map

package/dist/lib/llm/judges/invalid-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-fields.js","sourceRoot":"","sources":["../../../../src/lib/llm/judges/invalid-fields.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAwDH,8DAgBC;AAnED,2CAAsE;AACtE,+CAA0D;AAC1D,2DAA4E;AAE5E,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;;;;;;;;;;;iLAuB4I,CAAC;AA0CzK,oEAA4B;AAjCrC,SAAS,wBAAwB,CAAC,KAA8B;IAC9D,OAAO;;wDAE+C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,uBAAuB,CAAC;;;EAGnG,KAAK,CAAC,eAAe,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,yBAAyB,CAAC,MAI/C;IACC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IAC5C,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,MAAM,MAAM,GAAG,MAAM,IAAA,sBAAc,EAAC;QAClC,MAAM;QACN,YAAY,EAAE,4BAA4B;QAC1C,UAAU,EAAE,wBAAwB,CAAC,KAAK,CAAC;QAC3C,MAAM,EAAE,+BAAqB;QAC7B,QAAQ,EAAE,2CAA8B;QACxC,SAAS;KACV,CAAC,CAAC;IACH,OAAO,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC;AAChC,CAAC"}

package/dist/lib/llm/judges/modal-priority.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Modal-priority judge. Replaces the keyword regex
+ * `MODAL_PRIORITY_RX = /(modal|dialog|popup|overlay|drawer)/i` that
+ * matched Stagehand's English description strings.
+ *
+ * Why: the regex missed sheet, flyout, panel, sidebar, lightbox,
+ * cdk-overlay, radix-portal, app-prefixed variants, and any non-English
+ * description. When the regex missed, the rephrase prompt's UNFOCUSED
+ * OBSERVE section didn't bubble the blocking modal to the top — the
+ * LLM saw the form fields first and didn't realize a modal was in the
+ * way.
+ *
+ * The judge looks at the full unfocused-observe list and decides which
+ * entries are STRUCTURALLY blocking the form (modal with backdrop,
+ * dialog, overlay, popup) vs which are always-visible UI (sidebars,
+ * sticky headers, panels). Returns indices to bubble to the top.
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { z } from "zod/v4";
+import { type JudgeCaptureFn } from "../../../lib/llm/judge";
+import { MODAL_PRIORITY_SCHEMA } from "../../../lib/llm/schemas";
+declare const MODAL_PRIORITY_SYSTEM_PROMPT = "You are a strict modal-priority judge for browser-automation. Given a list of UI elements observed on the page (with English descriptions), identify which ones are STRUCTURALLY blocking modal/dialog/overlay components that need to be dismissed before the underlying form can be interacted with.\n\nStrict criteria for marking an index as priority:\n- Cookie consent banners (block the page until accepted/dismissed) \u2014 PRIORITY.\n- Welcome / sign-in modals with a dismiss action \u2014 PRIORITY.\n- Floating sheet/flyout/dialog/popup/overlay UIs covering form content \u2014 PRIORITY.\n- Lightbox image viewers \u2014 PRIORITY when they cover the form.\n- Drawer components when they're modal (block underlying interaction) \u2014 PRIORITY.\n\nDo NOT mark as priority:\n- Sidebars and navigation panels that are always visible by design.\n- Sticky headers / footers that don't block form interaction.\n- Tooltips / popovers that auto-dismiss on click outside.\n- Slide-out panels in responsive layouts when they're statically open.\n\nThe descriptions are English prose generated by Stagehand. Class names mentioned in the description (e.g. cdk-overlay, app-modal) are stronger evidence than keywords. Site-specific app-prefixed dialog/modal classes count as priority.\n\nReturn the indices (0-based) of priority items in the order they appear in the input. Max 50 items. Include a one-sentence rationale citing the strongest signal.";
+export interface JudgeModalPriorityInput {
+    /** Each entry as it appears in the unfocused-observe list. Indices are 0-based. */
+    observations: {
+        description: string;
+        selector: string;
+    }[];
+}
+/**
+ * Run the modal-priority judge. Returns priority indices + a rationale.
+ * Returns null when the client is null (Bedrock-only) or the API call
+ * fails — callers fall back to leaving the original order untouched.
+ */
+export declare function judgeModalPriorityWithLLM(params: {
+    client: Anthropic | null;
+    input: JudgeModalPriorityInput;
+    captureFn?: JudgeCaptureFn;
+}): Promise<z.infer<typeof MODAL_PRIORITY_SCHEMA> | null>;
+export { MODAL_PRIORITY_SYSTEM_PROMPT };
+//# sourceMappingURL=modal-priority.d.ts.map

package/dist/lib/llm/judges/modal-priority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal-priority.d.ts","sourceRoot":"","sources":["../../../../src/lib/llm/judges/modal-priority.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,QAAA,MAAM,4BAA4B,k6CAiBgI,CAAC;AAEnK,MAAM,WAAW,uBAAuB;IACtC,mFAAmF;IACnF,YAAY,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3D;AAYD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IACtD,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,uBAAuB,CAAC;IAC/B,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAAG,IAAI,CAAC,CAaxD;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAC"}