markform 0.1.1 → 0.1.3

package/dist/src-Cs4_9lWP.mjs

@@ -1,2151 +0,0 @@
-import { S as getWebSearchConfig, _ as DEFAULT_PRIORITY, at as SessionTranscriptSchema, et as PatchSchema, f as AGENT_ROLE, h as DEFAULT_MAX_TURNS, m as DEFAULT_MAX_PATCHES_PER_TURN, n as getFieldsForRoles, p as DEFAULT_MAX_ISSUES, r as inspect, t as applyPatches, u as serialize, v as DEFAULT_ROLE_INSTRUCTIONS } from "./apply-BQdd-fdx.mjs";
-import { z } from "zod";
-import Markdoc from "@markdoc/markdoc";
-import YAML from "yaml";
-import { sha256 } from "js-sha256";
-import { generateText, stepCountIs, zodSchema } from "ai";
-import { openai } from "@ai-sdk/openai";
-import { google } from "@ai-sdk/google";
-
-//#region src/engine/parse.ts
-/**
-* Markdoc parser for .form.md files.
-*
-* Parses Markdoc documents and extracts form schema, values, and documentation blocks.
-*/
-/** Parse error with source location info */
-var ParseError = class extends Error {
-	constructor(message, line, col) {
-		super(message);
-		this.line = line;
-		this.col = col;
-		this.name = "ParseError";
-	}
-};
-const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-/**
-* Extract YAML frontmatter from markdown content.
-*/
-function extractFrontmatter(content) {
-	const match = FRONTMATTER_REGEX.exec(content);
-	if (!match) return {
-		frontmatter: {},
-		body: content
-	};
-	const yamlContent = match[1];
-	const body = content.slice(match[0].length);
-	try {
-		const lines = (yamlContent ?? "").split("\n");
-		const result = {};
-		for (const line of lines) {
-			const colonIndex = line.indexOf(":");
-			if (colonIndex > 0 && !line.startsWith(" ") && !line.startsWith("	")) {
-				const key = line.slice(0, colonIndex).trim();
-				const value = line.slice(colonIndex + 1).trim();
-				if (value.startsWith("\"") && value.endsWith("\"")) result[key] = value.slice(1, -1);
-				else if (value === "") result[key] = {};
-				else result[key] = value;
-			}
-		}
-		return {
-			frontmatter: result,
-			body
-		};
-	} catch (_error) {
-		throw new ParseError("Failed to parse frontmatter YAML");
-	}
-}
-/** Map checkbox marker to state value */
-const CHECKBOX_MARKERS = {
-	"[ ]": "todo",
-	"[x]": "done",
-	"[X]": "done",
-	"[/]": "incomplete",
-	"[*]": "active",
-	"[-]": "na",
-	"[y]": "yes",
-	"[Y]": "yes",
-	"[n]": "no",
-	"[N]": "no"
-};
-const OPTION_TEXT_PATTERN = /^(\[[^\]]\])\s*(.*?)\s*$/;
-/**
-* Parse option text to extract marker and label.
-* Text is like "[ ] Label" or "[x] Label".
-*/
-function parseOptionText(text) {
-	const match = OPTION_TEXT_PATTERN.exec(text);
-	if (!match) return null;
-	return {
-		marker: match[1] ?? "",
-		label: (match[2] ?? "").trim()
-	};
-}
-/**
-* Check if a node is a tag node with specific name.
-* Works with raw AST nodes (not transformed Tags).
-*/
-function isTagNode(node, name) {
-	if (typeof node !== "object" || node === null) return false;
-	if (node.type === "tag" && node.tag) return name === void 0 || node.tag === name;
-	return false;
-}
-/**
-* Get string attribute value or undefined.
-*/
-function getStringAttr(node, name) {
-	const value = node.attributes?.[name];
-	return typeof value === "string" ? value : void 0;
-}
-/**
-* Get number attribute value or undefined.
-*/
-function getNumberAttr(node, name) {
-	const value = node.attributes?.[name];
-	return typeof value === "number" ? value : void 0;
-}
-/**
-* Get boolean attribute value or undefined.
-*/
-function getBooleanAttr(node, name) {
-	const value = node.attributes?.[name];
-	return typeof value === "boolean" ? value : void 0;
-}
-/**
-* Get validator references from validate attribute.
-* Handles both single string and array formats.
-*/
-function getValidateAttr(node) {
-	const value = node.attributes?.validate;
-	if (value === void 0 || value === null) return;
-	if (Array.isArray(value)) return value;
-	if (typeof value === "string") return [value];
-	if (typeof value === "object") return [value];
-}
-/**
-* Extract option items from node children (for option lists).
-* Works with raw AST nodes. Collects text and ID from list items.
-*/
-function extractOptionItems(node) {
-	const items = [];
-	/**
-	* Collect all text content from a node tree into a single string.
-	*/
-	function collectText(n) {
-		let text = "";
-		if (n.type === "text" && typeof n.attributes?.content === "string") text += n.attributes.content;
-		if (n.type === "softbreak") text += "\n";
-		if (n.children && Array.isArray(n.children)) for (const c of n.children) text += collectText(c);
-		return text;
-	}
-	/**
-	* Traverse to find list items and extract their content.
-	*/
-	function traverse(child) {
-		if (!child || typeof child !== "object") return;
-		if (child.type === "item") {
-			const text = collectText(child);
-			const id = typeof child.attributes?.id === "string" ? child.attributes.id : null;
-			if (text.trim()) items.push({
-				id,
-				text: text.trim()
-			});
-			return;
-		}
-		if (child.children && Array.isArray(child.children)) for (const c of child.children) traverse(c);
-	}
-	if (node.children && Array.isArray(node.children)) for (const child of node.children) traverse(child);
-	return items;
-}
-/**
-* Extract fence value from node children.
-* Looks for ```value code blocks.
-*/
-function extractFenceValue(node) {
-	function traverse(child) {
-		if (!child || typeof child !== "object") return null;
-		if (child.type === "fence") {
-			if (child.attributes?.language === "value") return typeof child.attributes?.content === "string" ? child.attributes.content : null;
-		}
-		if (child.children && Array.isArray(child.children)) for (const c of child.children) {
-			const result = traverse(c);
-			if (result !== null) return result;
-		}
-		return null;
-	}
-	if (node.children && Array.isArray(node.children)) for (const child of node.children) {
-		const result = traverse(child);
-		if (result !== null) return result;
-	}
-	return null;
-}
-/**
-* Get priority attribute value or default to DEFAULT_PRIORITY.
-*/
-function getPriorityAttr(node) {
-	const value = getStringAttr(node, "priority");
-	if (value === "high" || value === "medium" || value === "low") return value;
-	return DEFAULT_PRIORITY;
-}
-/**
-* Parse a string-field tag.
-*/
-function parseStringField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("string-field missing required 'id' attribute");
-	if (!label) throw new ParseError(`string-field '${id}' missing required 'label' attribute`);
-	const field = {
-		kind: "string",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		multiline: getBooleanAttr(node, "multiline"),
-		pattern: getStringAttr(node, "pattern"),
-		minLength: getNumberAttr(node, "minLength"),
-		maxLength: getNumberAttr(node, "maxLength"),
-		validate: getValidateAttr(node)
-	};
-	const fenceContent = extractFenceValue(node);
-	return {
-		field,
-		value: {
-			kind: "string",
-			value: fenceContent !== null ? fenceContent.trim() : null
-		}
-	};
-}
-/**
-* Parse a number-field tag.
-*/
-function parseNumberField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("number-field missing required 'id' attribute");
-	if (!label) throw new ParseError(`number-field '${id}' missing required 'label' attribute`);
-	const field = {
-		kind: "number",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		min: getNumberAttr(node, "min"),
-		max: getNumberAttr(node, "max"),
-		integer: getBooleanAttr(node, "integer"),
-		validate: getValidateAttr(node)
-	};
-	const fenceContent = extractFenceValue(node);
-	let numValue = null;
-	if (fenceContent !== null) {
-		const trimmed = fenceContent.trim();
-		if (trimmed) {
-			const parsed = Number(trimmed);
-			if (!Number.isNaN(parsed)) numValue = parsed;
-		}
-	}
-	return {
-		field,
-		value: {
-			kind: "number",
-			value: numValue
-		}
-	};
-}
-/**
-* Parse a string-list tag.
-*/
-function parseStringListField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("string-list missing required 'id' attribute");
-	if (!label) throw new ParseError(`string-list '${id}' missing required 'label' attribute`);
-	const field = {
-		kind: "string_list",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		minItems: getNumberAttr(node, "minItems"),
-		maxItems: getNumberAttr(node, "maxItems"),
-		itemMinLength: getNumberAttr(node, "itemMinLength"),
-		itemMaxLength: getNumberAttr(node, "itemMaxLength"),
-		uniqueItems: getBooleanAttr(node, "uniqueItems"),
-		validate: getValidateAttr(node)
-	};
-	const fenceContent = extractFenceValue(node);
-	const items = [];
-	if (fenceContent !== null) {
-		const lines = fenceContent.split("\n");
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (trimmed) items.push(trimmed);
-		}
-	}
-	return {
-		field,
-		value: {
-			kind: "string_list",
-			items
-		}
-	};
-}
-/**
-* Parse options from a select/checkbox field.
-*/
-function parseOptions(node, fieldId) {
-	const items = extractOptionItems(node);
-	const options = [];
-	const selected = {};
-	const seenIds = /* @__PURE__ */ new Set();
-	for (const item of items) {
-		const parsed = parseOptionText(item.text);
-		if (!parsed) continue;
-		if (!item.id) throw new ParseError(`Option in field '${fieldId}' missing ID annotation. Use {% #option_id %}`);
-		if (seenIds.has(item.id)) throw new ParseError(`Duplicate option ID '${item.id}' in field '${fieldId}'`);
-		seenIds.add(item.id);
-		options.push({
-			id: item.id,
-			label: parsed.label
-		});
-		const state = CHECKBOX_MARKERS[parsed.marker];
-		if (state !== void 0) selected[item.id] = state;
-	}
-	return {
-		options,
-		selected
-	};
-}
-/**
-* Parse a single-select tag.
-*/
-function parseSingleSelectField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("single-select missing required 'id' attribute");
-	if (!label) throw new ParseError(`single-select '${id}' missing required 'label' attribute`);
-	const { options, selected } = parseOptions(node, id);
-	const field = {
-		kind: "single_select",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		options,
-		validate: getValidateAttr(node)
-	};
-	let selectedOption = null;
-	for (const [optId, state] of Object.entries(selected)) if (state === "done") {
-		selectedOption = optId;
-		break;
-	}
-	return {
-		field,
-		value: {
-			kind: "single_select",
-			selected: selectedOption
-		}
-	};
-}
-/**
-* Parse a multi-select tag.
-*/
-function parseMultiSelectField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("multi-select missing required 'id' attribute");
-	if (!label) throw new ParseError(`multi-select '${id}' missing required 'label' attribute`);
-	const { options, selected } = parseOptions(node, id);
-	const field = {
-		kind: "multi_select",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		options,
-		minSelections: getNumberAttr(node, "minSelections"),
-		maxSelections: getNumberAttr(node, "maxSelections"),
-		validate: getValidateAttr(node)
-	};
-	const selectedOptions = [];
-	for (const [optId, state] of Object.entries(selected)) if (state === "done") selectedOptions.push(optId);
-	return {
-		field,
-		value: {
-			kind: "multi_select",
-			selected: selectedOptions
-		}
-	};
-}
-/**
-* Parse a checkboxes tag.
-*/
-function parseCheckboxesField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("checkboxes missing required 'id' attribute");
-	if (!label) throw new ParseError(`checkboxes '${id}' missing required 'label' attribute`);
-	const { options, selected } = parseOptions(node, id);
-	const checkboxModeStr = getStringAttr(node, "checkboxMode");
-	let checkboxMode = "multi";
-	if (checkboxModeStr === "multi" || checkboxModeStr === "simple" || checkboxModeStr === "explicit") checkboxMode = checkboxModeStr;
-	const approvalModeStr = getStringAttr(node, "approvalMode");
-	let approvalMode = "none";
-	if (approvalModeStr === "blocking") approvalMode = "blocking";
-	const explicitRequired = getBooleanAttr(node, "required");
-	let required;
-	if (checkboxMode === "explicit") {
-		if (explicitRequired === false) throw new ParseError(`Checkbox field "${label}" has checkboxMode="explicit" which is inherently required. Cannot set required=false. Remove required attribute or change checkboxMode.`);
-		required = true;
-	} else required = explicitRequired ?? false;
-	const field = {
-		kind: "checkboxes",
-		id,
-		label,
-		required,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		checkboxMode,
-		minDone: getNumberAttr(node, "minDone"),
-		options,
-		approvalMode,
-		validate: getValidateAttr(node)
-	};
-	const values = {};
-	for (const opt of options) {
-		const state = selected[opt.id];
-		if (state === void 0 || state === "todo") values[opt.id] = checkboxMode === "explicit" ? "unfilled" : "todo";
-		else values[opt.id] = state;
-	}
-	return {
-		field,
-		value: {
-			kind: "checkboxes",
-			values
-		}
-	};
-}
-/**
-* Parse a url-field tag.
-*/
-function parseUrlField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("url-field missing required 'id' attribute");
-	if (!label) throw new ParseError(`url-field '${id}' missing required 'label' attribute`);
-	const field = {
-		kind: "url",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		validate: getValidateAttr(node)
-	};
-	const fenceContent = extractFenceValue(node);
-	return {
-		field,
-		value: {
-			kind: "url",
-			value: fenceContent !== null ? fenceContent.trim() : null
-		}
-	};
-}
-/**
-* Parse a url-list tag.
-*/
-function parseUrlListField(node) {
-	const id = getStringAttr(node, "id");
-	const label = getStringAttr(node, "label");
-	if (!id) throw new ParseError("url-list missing required 'id' attribute");
-	if (!label) throw new ParseError(`url-list '${id}' missing required 'label' attribute`);
-	const field = {
-		kind: "url_list",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		priority: getPriorityAttr(node),
-		role: getStringAttr(node, "role") ?? AGENT_ROLE,
-		minItems: getNumberAttr(node, "minItems"),
-		maxItems: getNumberAttr(node, "maxItems"),
-		uniqueItems: getBooleanAttr(node, "uniqueItems"),
-		validate: getValidateAttr(node)
-	};
-	const fenceContent = extractFenceValue(node);
-	const items = [];
-	if (fenceContent !== null) {
-		const lines = fenceContent.split("\n");
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (trimmed) items.push(trimmed);
-		}
-	}
-	return {
-		field,
-		value: {
-			kind: "url_list",
-			items
-		}
-	};
-}
-/**
-* Parse a field tag and return field schema and value.
-*/
-function parseField(node) {
-	if (!isTagNode(node)) return null;
-	switch (node.tag) {
-		case "string-field": return parseStringField(node);
-		case "number-field": return parseNumberField(node);
-		case "string-list": return parseStringListField(node);
-		case "single-select": return parseSingleSelectField(node);
-		case "multi-select": return parseMultiSelectField(node);
-		case "checkboxes": return parseCheckboxesField(node);
-		case "url-field": return parseUrlField(node);
-		case "url-list": return parseUrlListField(node);
-		default: return null;
-	}
-}
-/**
-* Parse a field-group tag.
-*/
-function parseFieldGroup(node, valuesByFieldId, orderIndex, idIndex, parentId) {
-	const id = getStringAttr(node, "id");
-	const title = getStringAttr(node, "title");
-	if (!id) throw new ParseError("field-group missing required 'id' attribute");
-	if (idIndex.has(id)) throw new ParseError(`Duplicate ID '${id}'`);
-	idIndex.set(id, {
-		kind: "group",
-		parentId
-	});
-	const children = [];
-	function processChildren(child) {
-		if (!child || typeof child !== "object") return;
-		const result = parseField(child);
-		if (result) {
-			if (idIndex.has(result.field.id)) throw new ParseError(`Duplicate ID '${result.field.id}'`);
-			idIndex.set(result.field.id, {
-				kind: "field",
-				parentId: id
-			});
-			children.push(result.field);
-			valuesByFieldId[result.field.id] = result.value;
-			orderIndex.push(result.field.id);
-			if ("options" in result.field) for (const opt of result.field.options) {
-				const qualifiedRef = `${result.field.id}.${opt.id}`;
-				if (idIndex.has(qualifiedRef)) throw new ParseError(`Duplicate option ref '${qualifiedRef}'`);
-				idIndex.set(qualifiedRef, {
-					kind: "option",
-					parentId: id,
-					fieldId: result.field.id
-				});
-			}
-		}
-		if (child.children && Array.isArray(child.children)) for (const c of child.children) processChildren(c);
-	}
-	if (node.children && Array.isArray(node.children)) for (const child of node.children) processChildren(child);
-	return {
-		kind: "field_group",
-		id,
-		title,
-		validate: getValidateAttr(node),
-		children
-	};
-}
-/**
-* Parse a form tag.
-*/
-function parseFormTag(node, valuesByFieldId, orderIndex, idIndex) {
-	const id = getStringAttr(node, "id");
-	const title = getStringAttr(node, "title");
-	if (!id) throw new ParseError("form missing required 'id' attribute");
-	if (idIndex.has(id)) throw new ParseError(`Duplicate ID '${id}'`);
-	idIndex.set(id, { kind: "form" });
-	const groups = [];
-	function findFieldGroups(child) {
-		if (!child || typeof child !== "object") return;
-		if (isTagNode(child, "field-group")) {
-			const group = parseFieldGroup(child, valuesByFieldId, orderIndex, idIndex, id);
-			groups.push(group);
-			return;
-		}
-		if (child.children && Array.isArray(child.children)) for (const c of child.children) findFieldGroups(c);
-	}
-	if (node.children && Array.isArray(node.children)) for (const child of node.children) findFieldGroups(child);
-	return {
-		id,
-		title,
-		groups
-	};
-}
-/** Valid documentation tag names */
-const DOC_TAG_NAMES = [
-	"description",
-	"instructions",
-	"documentation"
-];
-/**
-* Extract all documentation blocks from AST.
-* Looks for {% description %}, {% instructions %}, and {% documentation %} tags.
-*/
-function extractDocBlocks(ast, idIndex) {
-	const docs = [];
-	const seenRefs = /* @__PURE__ */ new Set();
-	function traverse(node) {
-		if (!node || typeof node !== "object") return;
-		const nodeTag = node.type === "tag" && node.tag ? node.tag : null;
-		if (nodeTag && DOC_TAG_NAMES.includes(nodeTag)) {
-			const tag = nodeTag;
-			const ref = getStringAttr(node, "ref");
-			if (!ref) throw new ParseError(`${tag} block missing required 'ref' attribute`);
-			if (!idIndex.has(ref)) throw new ParseError(`${tag} block references unknown ID '${ref}'`);
-			const uniqueKey = `${ref}:${tag}`;
-			if (seenRefs.has(uniqueKey)) throw new ParseError(`Duplicate ${tag} block for ref='${ref}'`);
-			seenRefs.add(uniqueKey);
-			let bodyMarkdown = "";
-			function extractText(n) {
-				if (n.type === "text" && typeof n.attributes?.content === "string") bodyMarkdown += n.attributes.content;
-				if (n.children && Array.isArray(n.children)) for (const c of n.children) extractText(c);
-			}
-			if (node.children && Array.isArray(node.children)) for (const child of node.children) extractText(child);
-			docs.push({
-				tag,
-				ref,
-				bodyMarkdown: bodyMarkdown.trim()
-			});
-		}
-		if (node.children && Array.isArray(node.children)) for (const child of node.children) traverse(child);
-	}
-	traverse(ast);
-	return docs;
-}
-/**
-* Parse a Markform .form.md document.
-*
-* @param markdown - The full markdown content including frontmatter
-* @returns The parsed form representation
-* @throws ParseError if the document is invalid
-*/
-function parseForm(markdown) {
-	const { body } = extractFrontmatter(markdown);
-	const ast = Markdoc.parse(body);
-	let formSchema = null;
-	const valuesByFieldId = {};
-	const orderIndex = [];
-	const idIndex = /* @__PURE__ */ new Map();
-	function findFormTag(node) {
-		if (!node || typeof node !== "object") return;
-		if (isTagNode(node, "form")) {
-			if (formSchema) throw new ParseError("Multiple form tags found - only one allowed");
-			formSchema = parseFormTag(node, valuesByFieldId, orderIndex, idIndex);
-			return;
-		}
-		if (node.children && Array.isArray(node.children)) for (const child of node.children) findFormTag(child);
-	}
-	findFormTag(ast);
-	if (!formSchema) throw new ParseError("No form tag found in document");
-	const docs = extractDocBlocks(ast, idIndex);
-	return {
-		schema: formSchema,
-		valuesByFieldId,
-		skipsByFieldId: {},
-		docs,
-		orderIndex,
-		idIndex
-	};
-}
-
-//#endregion
-//#region src/engine/session.ts
-/**
-* Session module - parsing and serializing session transcripts.
-*
-* Session transcripts are used for golden testing and session replay.
-* They capture the full interaction between the harness and agent.
-*/
-/**
-* Parse a session transcript from YAML string.
-*
-* Converts snake_case keys to camelCase for TypeScript consumption.
-*
-* @param yaml - YAML string containing session transcript
-* @returns Parsed and validated SessionTranscript
-* @throws Error if YAML is invalid or doesn't match schema
-*/
-function parseSession(yaml) {
-	let raw;
-	try {
-		raw = YAML.parse(yaml);
-	} catch (err) {
-		throw new Error(`Failed to parse session YAML: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	const converted = toCamelCaseDeep(raw);
-	const result = SessionTranscriptSchema.safeParse(converted);
-	if (!result.success) {
-		const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
-		throw new Error(`Invalid session transcript: ${errors}`);
-	}
-	return result.data;
-}
-/**
-* Serialize a session transcript to YAML string.
-*
-* Converts camelCase keys to snake_case for YAML output.
-*
-* @param session - Session transcript to serialize
-* @returns YAML string
-*/
-function serializeSession(session) {
-	const snakeCased = toSnakeCaseDeep(session);
-	return YAML.stringify(snakeCased, {
-		indent: 2,
-		lineWidth: 0
-	});
-}
-/**
-* Convert a string from snake_case to camelCase.
-*/
-function snakeToCamel(str) {
-	return str.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
-}
-/**
-* Convert a string from camelCase to snake_case.
-*/
-function camelToSnake(str) {
-	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-/**
-* Recursively convert all object keys from snake_case to camelCase.
-*
-* Preserves keys that are user-defined identifiers (like option IDs in
-* checkboxes `values` objects).
-*
-* @param obj - Object to convert
-* @param preserveKeys - If true, don't convert keys in this object (but still recurse into values)
-*/
-function toCamelCaseDeep(obj, preserveKeys = false) {
-	if (obj === null || obj === void 0) return obj;
-	if (Array.isArray(obj)) return obj.map((item) => toCamelCaseDeep(item, false));
-	if (typeof obj === "object") {
-		const result = {};
-		const record = obj;
-		for (const [key, value] of Object.entries(record)) {
-			const resultKey = preserveKeys ? key : snakeToCamel(key);
-			result[resultKey] = toCamelCaseDeep(value, key === "values" && record.op === "set_checkboxes");
-		}
-		return result;
-	}
-	return obj;
-}
-/**
-* Recursively convert all object keys from camelCase to snake_case.
-*
-* Preserves keys that are user-defined identifiers (like option IDs in
-* checkboxes `values` objects).
-*
-* @param obj - Object to convert
-* @param preserveKeys - If true, don't convert keys in this object (but still recurse into values)
-*/
-function toSnakeCaseDeep(obj, preserveKeys = false) {
-	if (obj === null || obj === void 0) return obj;
-	if (Array.isArray(obj)) return obj.map((item) => toSnakeCaseDeep(item, false));
-	if (typeof obj === "object") {
-		const result = {};
-		const record = obj;
-		for (const [key, value] of Object.entries(record)) {
-			const resultKey = preserveKeys ? key : camelToSnake(key);
-			result[resultKey] = toSnakeCaseDeep(value, key === "values" && record.op === "set_checkboxes");
-		}
-		return result;
-	}
-	return obj;
-}
-
-//#endregion
-//#region src/engine/valueCoercion.ts
-/**
-* Find a field by ID.
-*
-* Uses idIndex for O(1) validation that the ID exists and is a field,
-* then retrieves the Field object from the schema.
-*/
-function findFieldById(form, fieldId) {
-	if (form.idIndex.get(fieldId)?.kind !== "field") return;
-	for (const group of form.schema.groups) for (const field of group.children) if (field.id === fieldId) return field;
-}
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isStringArray(value) {
-	return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function coerceToString(fieldId, rawValue) {
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_string",
-			fieldId,
-			value: null
-		}
-	};
-	if (typeof rawValue === "string") return {
-		ok: true,
-		patch: {
-			op: "set_string",
-			fieldId,
-			value: rawValue
-		}
-	};
-	if (typeof rawValue === "number") return {
-		ok: true,
-		patch: {
-			op: "set_string",
-			fieldId,
-			value: String(rawValue)
-		},
-		warning: `Coerced number ${rawValue} to string for field '${fieldId}'`
-	};
-	if (typeof rawValue === "boolean") return {
-		ok: true,
-		patch: {
-			op: "set_string",
-			fieldId,
-			value: String(rawValue)
-		},
-		warning: `Coerced boolean ${rawValue} to string for field '${fieldId}'`
-	};
-	return {
-		ok: false,
-		error: `Cannot coerce ${typeof rawValue} to string for field '${fieldId}'`
-	};
-}
-function coerceToNumber(fieldId, rawValue) {
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_number",
-			fieldId,
-			value: null
-		}
-	};
-	if (typeof rawValue === "number") return {
-		ok: true,
-		patch: {
-			op: "set_number",
-			fieldId,
-			value: rawValue
-		}
-	};
-	if (typeof rawValue === "string") {
-		const parsed = Number(rawValue);
-		if (!Number.isNaN(parsed)) return {
-			ok: true,
-			patch: {
-				op: "set_number",
-				fieldId,
-				value: parsed
-			},
-			warning: `Coerced string '${rawValue}' to number for field '${fieldId}'`
-		};
-		return {
-			ok: false,
-			error: `Cannot coerce non-numeric string '${rawValue}' to number for field '${fieldId}'`
-		};
-	}
-	return {
-		ok: false,
-		error: `Cannot coerce ${typeof rawValue} to number for field '${fieldId}'`
-	};
-}
-function coerceToStringList(fieldId, rawValue) {
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_string_list",
-			fieldId,
-			items: []
-		}
-	};
-	if (isStringArray(rawValue)) return {
-		ok: true,
-		patch: {
-			op: "set_string_list",
-			fieldId,
-			items: rawValue
-		}
-	};
-	if (typeof rawValue === "string") return {
-		ok: true,
-		patch: {
-			op: "set_string_list",
-			fieldId,
-			items: [rawValue]
-		},
-		warning: `Coerced single string to array for field '${fieldId}'`
-	};
-	if (Array.isArray(rawValue)) {
-		const items = [];
-		for (const item of rawValue) if (typeof item === "string") items.push(item);
-		else if (typeof item === "number" || typeof item === "boolean") items.push(String(item));
-		else return {
-			ok: false,
-			error: `Cannot coerce array with non-string items to string_list for field '${fieldId}'`
-		};
-		return {
-			ok: true,
-			patch: {
-				op: "set_string_list",
-				fieldId,
-				items
-			},
-			warning: `Coerced array items to strings for field '${fieldId}'`
-		};
-	}
-	return {
-		ok: false,
-		error: `Cannot coerce ${typeof rawValue} to string_list for field '${fieldId}'`
-	};
-}
-function coerceToSingleSelect(field, rawValue) {
-	if (field.kind !== "single_select") return {
-		ok: false,
-		error: `Field '${field.id}' is not a single_select field`
-	};
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_single_select",
-			fieldId: field.id,
-			selected: null
-		}
-	};
-	if (typeof rawValue !== "string") return {
-		ok: false,
-		error: `single_select field '${field.id}' requires a string option ID, got ${typeof rawValue}`
-	};
-	const validOptions = new Set(field.options.map((o) => o.id));
-	if (!validOptions.has(rawValue)) return {
-		ok: false,
-		error: `Invalid option '${rawValue}' for single_select field '${field.id}'. Valid options: ${Array.from(validOptions).join(", ")}`
-	};
-	return {
-		ok: true,
-		patch: {
-			op: "set_single_select",
-			fieldId: field.id,
-			selected: rawValue
-		}
-	};
-}
-function coerceToMultiSelect(field, rawValue) {
-	if (field.kind !== "multi_select") return {
-		ok: false,
-		error: `Field '${field.id}' is not a multi_select field`
-	};
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_multi_select",
-			fieldId: field.id,
-			selected: []
-		}
-	};
-	const validOptions = new Set(field.options.map((o) => o.id));
-	let selected;
-	let warning;
-	if (typeof rawValue === "string") {
-		selected = [rawValue];
-		warning = `Coerced single string to array for multi_select field '${field.id}'`;
-	} else if (isStringArray(rawValue)) selected = rawValue;
-	else return {
-		ok: false,
-		error: `multi_select field '${field.id}' requires a string or string array, got ${typeof rawValue}`
-	};
-	for (const optId of selected) if (!validOptions.has(optId)) return {
-		ok: false,
-		error: `Invalid option '${optId}' for multi_select field '${field.id}'. Valid options: ${Array.from(validOptions).join(", ")}`
-	};
-	const patch = {
-		op: "set_multi_select",
-		fieldId: field.id,
-		selected
-	};
-	return warning ? {
-		ok: true,
-		patch,
-		warning
-	} : {
-		ok: true,
-		patch
-	};
-}
-function coerceToCheckboxes(field, rawValue) {
-	if (field.kind !== "checkboxes") return {
-		ok: false,
-		error: `Field '${field.id}' is not a checkboxes field`
-	};
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_checkboxes",
-			fieldId: field.id,
-			values: {}
-		}
-	};
-	if (!isPlainObject(rawValue)) return {
-		ok: false,
-		error: `checkboxes field '${field.id}' requires a Record<string, CheckboxValue>, got ${typeof rawValue}`
-	};
-	const validOptions = new Set(field.options.map((o) => o.id));
-	const checkboxMode = field.checkboxMode;
-	const values = {};
-	const validValues = new Set(checkboxMode === "explicit" ? [
-		"unfilled",
-		"yes",
-		"no"
-	] : checkboxMode === "simple" ? ["todo", "done"] : [
-		"todo",
-		"done",
-		"incomplete",
-		"active",
-		"na"
-	]);
-	for (const [optId, value] of Object.entries(rawValue)) {
-		if (!validOptions.has(optId)) return {
-			ok: false,
-			error: `Invalid option '${optId}' for checkboxes field '${field.id}'. Valid options: ${Array.from(validOptions).join(", ")}`
-		};
-		if (typeof value !== "string" || !validValues.has(value)) return {
-			ok: false,
-			error: `Invalid checkbox value '${String(value)}' for option '${optId}' in field '${field.id}'. Valid values for ${checkboxMode} mode: ${Array.from(validValues).join(", ")}`
-		};
-		values[optId] = value;
-	}
-	return {
-		ok: true,
-		patch: {
-			op: "set_checkboxes",
-			fieldId: field.id,
-			values
-		}
-	};
-}
-function coerceToUrl(fieldId, rawValue) {
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_url",
-			fieldId,
-			value: null
-		}
-	};
-	if (typeof rawValue === "string") return {
-		ok: true,
-		patch: {
-			op: "set_url",
-			fieldId,
-			value: rawValue
-		}
-	};
-	return {
-		ok: false,
-		error: `Cannot coerce ${typeof rawValue} to url for field '${fieldId}'`
-	};
-}
-function coerceToUrlList(fieldId, rawValue) {
-	if (rawValue === null) return {
-		ok: true,
-		patch: {
-			op: "set_url_list",
-			fieldId,
-			items: []
-		}
-	};
-	if (isStringArray(rawValue)) return {
-		ok: true,
-		patch: {
-			op: "set_url_list",
-			fieldId,
-			items: rawValue
-		}
-	};
-	if (typeof rawValue === "string") return {
-		ok: true,
-		patch: {
-			op: "set_url_list",
-			fieldId,
-			items: [rawValue]
-		},
-		warning: `Coerced single string to array for field '${fieldId}'`
-	};
-	if (Array.isArray(rawValue)) {
-		const items = [];
-		for (const item of rawValue) if (typeof item === "string") items.push(item);
-		else return {
-			ok: false,
-			error: `Cannot coerce array with non-string items to url_list for field '${fieldId}'`
-		};
-		return {
-			ok: true,
-			patch: {
-				op: "set_url_list",
-				fieldId,
-				items
-			}
-		};
-	}
-	return {
-		ok: false,
-		error: `Cannot coerce ${typeof rawValue} to url_list for field '${fieldId}'`
-	};
-}
-/**
-* Coerce a raw value to a Patch for a specific field.
-*/
-function coerceToFieldPatch(form, fieldId, rawValue) {
-	const field = findFieldById(form, fieldId);
-	if (!field) return {
-		ok: false,
-		error: `Field '${fieldId}' not found`
-	};
-	switch (field.kind) {
-		case "string": return coerceToString(fieldId, rawValue);
-		case "number": return coerceToNumber(fieldId, rawValue);
-		case "string_list": return coerceToStringList(fieldId, rawValue);
-		case "single_select": return coerceToSingleSelect(field, rawValue);
-		case "multi_select": return coerceToMultiSelect(field, rawValue);
-		case "checkboxes": return coerceToCheckboxes(field, rawValue);
-		case "url": return coerceToUrl(fieldId, rawValue);
-		case "url_list": return coerceToUrlList(fieldId, rawValue);
-	}
-}
-/**
-* Coerce an entire InputContext to patches.
-*
-* Returns patches for valid entries, collects warnings for coercions,
-* and errors for invalid entries.
-*/
-function coerceInputContext(form, inputContext) {
-	const patches = [];
-	const warnings = [];
-	const errors = [];
-	for (const [fieldId, rawValue] of Object.entries(inputContext)) {
-		if (rawValue === null) continue;
-		const result = coerceToFieldPatch(form, fieldId, rawValue);
-		if (result.ok) {
-			patches.push(result.patch);
-			if ("warning" in result && result.warning) warnings.push(result.warning);
-		} else errors.push(result.error);
-	}
-	return {
-		patches,
-		warnings,
-		errors
-	};
-}
-
-//#endregion
-//#region src/harness/harness.ts
-/**
-* Form Harness - Execution harness for form filling.
-*
-* Manages the step protocol for agent-driven form completion:
-* INIT -> STEP -> WAIT -> APPLY -> (repeat) -> COMPLETE
-*/
-const DEFAULT_CONFIG = {
-	maxIssues: DEFAULT_MAX_ISSUES,
-	maxPatchesPerTurn: DEFAULT_MAX_PATCHES_PER_TURN,
-	maxTurns: DEFAULT_MAX_TURNS
-};
-/**
-* Form harness for managing agent-driven form filling.
-*/
-var FormHarness = class {
-	form;
-	config;
-	state = "init";
-	turnNumber = 0;
-	turns = [];
-	constructor(form, config = {}) {
-		this.form = form;
-		this.config = {
-			...DEFAULT_CONFIG,
-			...config
-		};
-	}
-	/**
-	* Get the current harness state.
-	*/
-	getState() {
-		return this.state;
-	}
-	/**
-	* Get the current turn number.
-	*/
-	getTurnNumber() {
-		return this.turnNumber;
-	}
-	/**
-	* Get the recorded session turns.
-	*/
-	getTurns() {
-		return [...this.turns];
-	}
-	/**
-	* Get the current form.
-	*/
-	getForm() {
-		return this.form;
-	}
-	/**
-	* Check if the harness has reached max turns.
-	*
-	* Returns true when we've completed all allowed turns. This happens when:
-	* - turnNumber >= maxTurns AND we've already applied (state is "complete")
-	* - OR turnNumber > maxTurns (we've exceeded the limit)
-	*
-	* This allows the harness loop to run N times when maxTurns=N by returning
-	* false when we're at turn N but haven't applied yet (state is "wait").
-	*/
-	hasReachedMaxTurns() {
-		if (this.turnNumber > this.config.maxTurns) return true;
-		if (this.turnNumber === this.config.maxTurns && this.state === "complete") return true;
-		return false;
-	}
-	/**
-	* Perform a step - inspect the form and return current state.
-	*
-	* This transitions from INIT/WAIT -> STEP state.
-	* Returns the current form state with prioritized issues.
-	*
-	* On first step with fillMode='overwrite', clears all target role fields
-	* so they will be reported as needing to be filled.
-	*/
-	step() {
-		if (this.state === "complete") throw new Error("Harness is complete - cannot step");
-		if (this.state === "init" && this.config.fillMode === "overwrite") this.clearTargetRoleFields();
-		this.turnNumber++;
-		if (this.turnNumber > this.config.maxTurns) {
-			this.state = "complete";
-			const result$1 = inspect(this.form, { targetRoles: this.config.targetRoles });
-			return {
-				structureSummary: result$1.structureSummary,
-				progressSummary: result$1.progressSummary,
-				issues: [],
-				stepBudget: 0,
-				isComplete: result$1.isComplete,
-				turnNumber: this.turnNumber
-			};
-		}
-		this.state = "step";
-		const result = inspect(this.form, { targetRoles: this.config.targetRoles });
-		const stepResult = this.computeStepResult(result);
-		this.state = stepResult.issues.length === 0 ? "complete" : "wait";
-		return stepResult;
-	}
-	/**
-	* Apply patches to the form.
-	*
-	* This transitions from WAIT -> STEP/COMPLETE state.
-	* Records the turn in the session transcript.
-	*
-	* @param patches - Patches to apply
-	* @param issues - Issues that were shown to the agent (for recording)
-	* @param llmStats - Optional LLM stats for session logging
-	* @returns StepResult after applying patches
-	*/
-	apply(patches, issues, llmStats) {
-		if (this.state !== "wait") throw new Error(`Cannot apply in state: ${this.state}`);
-		if (patches.length > this.config.maxPatchesPerTurn) throw new Error(`Too many patches: ${patches.length} > ${this.config.maxPatchesPerTurn}`);
-		applyPatches(this.form, patches);
-		const result = inspect(this.form, { targetRoles: this.config.targetRoles });
-		const stepResult = this.computeStepResult(result);
-		this.recordTurn(issues, patches, result, llmStats);
-		if (stepResult.issues.length === 0 || this.turnNumber >= this.config.maxTurns) this.state = "complete";
-		else this.state = "wait";
-		return stepResult;
-	}
-	/**
-	* Compute step result from inspect result.
-	* Applies issue filtering and computes step budget.
-	*/
-	computeStepResult(result) {
-		const limitedIssues = this.filterIssuesByScope(result.issues).slice(0, this.config.maxIssues);
-		const stepBudget = Math.min(this.config.maxPatchesPerTurn, limitedIssues.length);
-		return {
-			structureSummary: result.structureSummary,
-			progressSummary: result.progressSummary,
-			issues: limitedIssues,
-			stepBudget,
-			isComplete: result.isComplete,
-			turnNumber: this.turnNumber
-		};
-	}
-	/**
-	* Record a turn in the session transcript.
-	*/
-	recordTurn(issues, patches, result, llmStats) {
-		const hash = sha256(serialize(this.form));
-		const requiredIssueCount = result.issues.filter((i) => i.severity === "required").length;
-		const turn = {
-			turn: this.turnNumber,
-			inspect: { issues },
-			apply: { patches },
-			after: {
-				requiredIssueCount,
-				markdownSha256: hash,
-				answeredFieldCount: result.progressSummary.counts.answeredFields,
-				skippedFieldCount: result.progressSummary.counts.skippedFields
-			}
-		};
-		if (llmStats) turn.llm = llmStats;
-		this.turns.push(turn);
-	}
-	/**
-	* Check if the form is complete.
-	*/
-	isComplete() {
-		return inspect(this.form, { targetRoles: this.config.targetRoles }).isComplete;
-	}
-	/**
-	* Get the current markdown content of the form.
-	*/
-	getMarkdown() {
-		return serialize(this.form);
-	}
-	/**
-	* Get the SHA256 hash of the current form markdown.
-	*/
-	getMarkdownHash() {
-		return sha256(serialize(this.form));
-	}
-	/**
-	* Filter issues based on maxFieldsPerTurn and maxGroupsPerTurn limits.
-	*
-	* Issues are processed in priority order. An issue is included if:
-	* - Adding it doesn't exceed the field limit (for field/option scoped issues)
-	* - Adding it doesn't exceed the group limit
-	*
-	* Form-level issues are always included.
-	*/
-	filterIssuesByScope(issues) {
-		const maxFields = this.config.maxFieldsPerTurn;
-		const maxGroups = this.config.maxGroupsPerTurn;
-		if (maxFields === void 0 && maxGroups === void 0) return issues;
-		const result = [];
-		const seenFields = /* @__PURE__ */ new Set();
-		const seenGroups = /* @__PURE__ */ new Set();
-		for (const issue of issues) {
-			if (issue.scope === "form") {
-				result.push(issue);
-				continue;
-			}
-			const fieldId = this.getFieldIdFromRef(issue.ref, issue.scope);
-			const groupId = fieldId ? this.getGroupForField(fieldId) : void 0;
-			if (maxFields !== void 0 && fieldId) {
-				if (!seenFields.has(fieldId) && seenFields.size >= maxFields) continue;
-			}
-			if (maxGroups !== void 0 && groupId) {
-				if (!seenGroups.has(groupId) && seenGroups.size >= maxGroups) continue;
-			}
-			result.push(issue);
-			if (fieldId) seenFields.add(fieldId);
-			if (groupId) seenGroups.add(groupId);
-		}
-		return result;
-	}
-	/**
-	* Extract field ID from an issue ref.
-	*/
-	getFieldIdFromRef(ref, scope) {
-		if (scope === "field") return ref;
-		if (scope === "option") {
-			const dotIndex = ref.indexOf(".");
-			return dotIndex > 0 ? ref.slice(0, dotIndex) : void 0;
-		}
-	}
-	/**
-	* Get the parent group ID for a field.
-	*/
-	getGroupForField(fieldId) {
-		const entry = this.form.idIndex.get(fieldId);
-		if (!entry) return;
-		if (entry.parentId) {
-			if (this.form.idIndex.get(entry.parentId)?.kind === "group") return entry.parentId;
-		}
-	}
-	/**
-	* Clear all fields that match the target roles.
-	* Used when fillMode='overwrite' to re-fill already-filled fields.
-	*/
-	clearTargetRoleFields() {
-		const targetRoles = this.config.targetRoles ?? [AGENT_ROLE];
-		const clearPatches = getFieldsForRoles(this.form, targetRoles).map((field) => ({
-			op: "clear_field",
-			fieldId: field.id
-		}));
-		if (clearPatches.length > 0) applyPatches(this.form, clearPatches);
-	}
-};
-/**
-* Create a new form harness.
-*
-* @param form - The parsed form to fill
-* @param config - Optional harness configuration
-* @returns A new FormHarness instance
-*/
-function createHarness(form, config) {
-	return new FormHarness(form, config);
-}
-
-//#endregion
-//#region src/harness/mockAgent.ts
-/**
-* Mock agent that generates patches from a pre-filled form.
-*/
-var MockAgent = class {
-	completedValues;
-	fieldMap;
-	/**
-	* Create a mock agent from a completed form.
-	*
-	* @param completedForm - A fully-filled form to use as source of values
-	*/
-	constructor(completedForm) {
-		this.completedValues = { ...completedForm.valuesByFieldId };
-		this.fieldMap = /* @__PURE__ */ new Map();
-		for (const group of completedForm.schema.groups) for (const field of group.children) this.fieldMap.set(field.id, field);
-	}
-	/**
-	* Generate patches from the completed mock to address issues.
-	*
-	* Processes issues in priority order, generating patches for
-	* fields that have values in the completed mock. For fields with no
-	* value (empty optional fields), generates skip_field patches.
-	* Returns AgentResponse with patches but no stats (mock doesn't track LLM usage).
-	*/
-	async generatePatches(issues, _form, maxPatches) {
-		const patches = [];
-		const addressedFields = /* @__PURE__ */ new Set();
-		for (const issue of issues) {
-			if (patches.length >= maxPatches) break;
-			if (issue.scope !== "field") continue;
-			const fieldId = issue.ref;
-			if (addressedFields.has(fieldId)) continue;
-			const field = this.fieldMap.get(fieldId);
-			if (!field) continue;
-			const completedValue = this.completedValues[fieldId];
-			if (!completedValue || !this.hasValue(completedValue)) {
-				if (!field.required) {
-					patches.push({
-						op: "skip_field",
-						fieldId,
-						reason: "No value in mock form"
-					});
-					addressedFields.add(fieldId);
-				}
-				continue;
-			}
-			const patch = this.createPatch(fieldId, field, completedValue);
-			if (patch) {
-				patches.push(patch);
-				addressedFields.add(fieldId);
-			}
-		}
-		return Promise.resolve({ patches });
-	}
-	/**
-	* Check if a field value actually has content (not null/empty).
-	*/
-	hasValue(value) {
-		switch (value.kind) {
-			case "string": return value.value !== null && value.value !== "";
-			case "number": return value.value !== null;
-			case "string_list": return value.items.length > 0;
-			case "single_select": return value.selected !== null;
-			case "multi_select": return value.selected.length > 0;
-			case "checkboxes": return true;
-			case "url": return value.value !== null && value.value !== "";
-			case "url_list": return value.items.length > 0;
-			default: return false;
-		}
-	}
-	/**
-	* Create a patch for a field based on its kind and completed value.
-	*/
-	createPatch(fieldId, field, value) {
-		switch (field.kind) {
-			case "string": return {
-				op: "set_string",
-				fieldId,
-				value: value.value
-			};
-			case "number": return {
-				op: "set_number",
-				fieldId,
-				value: value.value
-			};
-			case "string_list": return {
-				op: "set_string_list",
-				fieldId,
-				items: value.items
-			};
-			case "single_select": return {
-				op: "set_single_select",
-				fieldId,
-				selected: value.selected
-			};
-			case "multi_select": return {
-				op: "set_multi_select",
-				fieldId,
-				selected: value.selected
-			};
-			case "checkboxes": return {
-				op: "set_checkboxes",
-				fieldId,
-				values: value.values
-			};
-			case "url": return {
-				op: "set_url",
-				fieldId,
-				value: value.value
-			};
-			case "url_list": return {
-				op: "set_url_list",
-				fieldId,
-				items: value.items
-			};
-			default: return null;
-		}
-	}
-};
-/**
-* Create a mock agent from a completed form.
-*
-* @param completedForm - A fully-filled form to use as source of values
-* @returns A new MockAgent instance
-*/
-function createMockAgent(completedForm) {
-	return new MockAgent(completedForm);
-}
-
-//#endregion
-//#region src/harness/prompts.ts
-/**
-* Agent Prompts - Centralized prompt definitions for the live agent.
-*
-* All hardcoded prompts are defined here for easy review, modification,
-* and future configurability. This file serves as the single source of
-* truth for agent behavior instructions.
-*/
-/**
-* Default system prompt for the live agent.
-*
-* This is the base instruction set that defines the agent's core behavior
-* for form filling. It emphasizes accuracy over completeness and prohibits
-* fabrication of data.
-*/
-const DEFAULT_SYSTEM_PROMPT = `# Form Instructions
-Carefully research answers to all questions in the form, using all available tools you have.
-
-Guidelines:
-1. Focus on required fields first (severity: "required"), then address optional fields (severity: "recommended")
-2. You MUST address ALL issues shown to you - both required AND recommended (optional)
-3. NEVER fabricate or guess information - only use data you can verify
-4. If you cannot find verifiable information for a field, use skip_field to mark it as skipped with a reason
-5. For string fields: use appropriate text from verified sources
-6. For number fields: use appropriate numeric values from verified sources
-7. For single_select: choose one valid option ID
-8. For multi_select: choose one or more valid option IDs
-9. For checkboxes: set appropriate states (done/todo for simple, yes/no for explicit)
-
-CRITICAL: Accuracy is more important than completeness. Use skip_field when information cannot be verified.
-
-Always use the generatePatches tool to submit your field values.
-`;
-/**
-* Web search instructions appended when web search tools are available.
-*
-* These instructions enforce that the agent must verify all information
-* through web search before filling fields.
-*/
-const WEB_SEARCH_INSTRUCTIONS = `# Web Search
-You have access to web search tools. You MUST use them to verify ALL information before filling fields.
-
-Guidelines:
-1. Search for official sources (company websites, Crunchbase, LinkedIn, press releases)
-2. Cross-reference information across multiple sources when possible
-3. Only fill fields with data you found and verified through search
-4. If a search returns no results or uncertain information, use skip_field with a reason explaining what you searched for
-5. NEVER fill fields with guessed or assumed information
-`;
-/**
-* Description for the generatePatches tool.
-*
-* This tells the model how to use the patch submission tool.
-*/
-const GENERATE_PATCHES_TOOL_DESCRIPTION = "Generate patches to fill form fields. Each patch sets a field value. Use the field IDs from the issues list. Return patches for all issues you can address.";
-/**
-* Header for the issues section in the context prompt.
-*/
-const ISSUES_HEADER = "# Current Form Issues";
-/**
-* Template for the issues intro text.
-* @param maxPatches - Maximum number of patches to generate
-*/
-function getIssuesIntro(maxPatches) {
-	return `You need to address up to ${maxPatches} issues. Here are the current issues:`;
-}
-/**
-* Instructions section for the context prompt.
-*
-* This explains the patch format for each field type.
-*/
-const PATCH_FORMAT_INSTRUCTIONS = `# Instructions
-
-Use the generatePatches tool to submit patches for the fields above.
-Each patch should match the field type:
-- string: { op: "set_string", fieldId: "...", value: "..." }
-- number: { op: "set_number", fieldId: "...", value: 123 }
-- string_list: { op: "set_string_list", fieldId: "...", items: ["...", "..."] }
-- single_select: { op: "set_single_select", fieldId: "...", selected: "option_id" }
-- multi_select: { op: "set_multi_select", fieldId: "...", selected: ["opt1", "opt2"] }
-- checkboxes: { op: "set_checkboxes", fieldId: "...", values: { "opt1": "done", "opt2": "todo" } }
-- url: { op: "set_url", fieldId: "...", value: "https://..." }
-- url_list: { op: "set_url_list", fieldId: "...", items: ["https://...", "https://..."] }
-
-If you cannot find verifiable information for a field, skip it:
-- skip: { op: "skip_field", fieldId: "...", reason: "Information not available" }`;
-/**
-* Section headers used when building the composed system prompt.
-*/
-const SECTION_HEADERS = {
-	formInstructions: "# Form Instructions",
-	roleInstructions: (role) => `# Instructions for ${role} role`,
-	roleGuidance: "# Role guidance",
-	fieldInstructions: "# Field-specific instructions",
-	additionalContext: "# Additional Context"
-};
-
-//#endregion
-//#region src/harness/liveAgent.ts
-/**
-* Live agent that uses an LLM to generate patches.
-*/
-var LiveAgent = class {
-	model;
-	maxStepsPerTurn;
-	systemPromptAddition;
-	targetRole;
-	provider;
-	enableWebSearch;
-	webSearchTools = null;
-	constructor(config) {
-		this.model = config.model;
-		this.maxStepsPerTurn = config.maxStepsPerTurn ?? 3;
-		this.systemPromptAddition = config.systemPromptAddition;
-		this.targetRole = config.targetRole ?? AGENT_ROLE;
-		this.provider = config.provider;
-		this.enableWebSearch = config.enableWebSearch ?? true;
-		if (this.enableWebSearch && this.provider) this.webSearchTools = loadWebSearchTools(this.provider);
-	}
-	/**
-	* Get list of available tool names for this agent.
-	* Useful for logging what capabilities the agent has.
-	*/
-	getAvailableToolNames() {
-		const tools = ["generatePatches"];
-		if (this.webSearchTools) tools.push(...Object.keys(this.webSearchTools));
-		return tools;
-	}
-	/**
-	* Generate patches using the LLM.
-	*
-	* Each call is stateless - the full form context is provided fresh each turn.
-	* The form itself carries all state (filled values, remaining issues).
-	* Returns patches and per-turn stats for observability.
-	*/
-	async generatePatches(issues, form, maxPatches) {
-		const contextPrompt = buildContextPrompt(issues, form, maxPatches);
-		let systemPrompt = buildSystemPrompt(form, this.targetRole, issues);
-		if (this.systemPromptAddition) systemPrompt += "\n\n# Additional Context\n" + this.systemPromptAddition;
-		if (this.enableWebSearch && this.provider && !this.webSearchTools) this.webSearchTools = loadWebSearchTools(this.provider);
-		if (this.webSearchTools && Object.keys(this.webSearchTools).length > 0) systemPrompt += "\n\n" + WEB_SEARCH_INSTRUCTIONS;
-		const tools = {
-			generatePatches: {
-				description: GENERATE_PATCHES_TOOL_DESCRIPTION,
-				inputSchema: zodSchema(z.object({ patches: z.array(PatchSchema).max(maxPatches).describe("Array of patches. Each patch sets a value for one field.") }))
-			},
-			...this.webSearchTools
-		};
-		const result = await generateText({
-			model: this.model,
-			system: systemPrompt,
-			prompt: contextPrompt,
-			tools,
-			stopWhen: stepCountIs(this.maxStepsPerTurn)
-		});
-		const patches = [];
-		const toolCallCounts = /* @__PURE__ */ new Map();
-		for (const step of result.steps) for (const toolCall of step.toolCalls) {
-			const count = toolCallCounts.get(toolCall.toolName) ?? 0;
-			toolCallCounts.set(toolCall.toolName, count + 1);
-			if (toolCall.toolName === "generatePatches" && "input" in toolCall) {
-				const input = toolCall.input;
-				patches.push(...input.patches);
-			}
-		}
-		const toolCalls = [];
-		for (const [name, count] of toolCallCounts) toolCalls.push({
-			name,
-			count
-		});
-		const requiredRemaining = issues.filter((i) => i.severity === "required").length;
-		const optionalRemaining = issues.filter((i) => i.severity === "recommended").length;
-		const stats = {
-			inputTokens: result.usage?.inputTokens,
-			outputTokens: result.usage?.outputTokens,
-			toolCalls,
-			formProgress: {
-				answeredFields: Object.keys(form.valuesByFieldId).filter((id) => form.valuesByFieldId[id] !== null).length,
-				skippedFields: Object.keys(form.skipsByFieldId ?? {}).filter((id) => form.skipsByFieldId?.[id]?.skipped).length,
-				requiredRemaining,
-				optionalRemaining
-			},
-			prompts: {
-				system: systemPrompt,
-				context: contextPrompt
-			}
-		};
-		return {
-			patches: patches.slice(0, maxPatches),
-			stats
-		};
-	}
-};
-/**
-* Extract doc blocks of a specific tag type for a given ref.
-*/
-function getDocBlocks(docs, ref, tag) {
-	return docs.filter((d) => d.ref === ref && d.tag === tag);
-}
-/**
-* Build a composed system prompt from form instructions.
-*
-* Instruction sources (later ones augment earlier):
-* 1. Base form instructions - Doc blocks with ref=formId and tag="instructions"
-* 2. Role-specific instructions - From form.metadata.roleInstructions[targetRole]
-* 3. Per-field instructions - Doc blocks with ref=fieldId and tag="instructions"
-* 4. System defaults - DEFAULT_ROLE_INSTRUCTIONS[targetRole] or DEFAULT_SYSTEM_PROMPT
-*/
-function buildSystemPrompt(form, targetRole, issues) {
-	const sections = [];
-	sections.push(DEFAULT_SYSTEM_PROMPT);
-	const formInstructions = getDocBlocks(form.docs, form.schema.id, "instructions");
-	if (formInstructions.length > 0) {
-		sections.push("");
-		sections.push(SECTION_HEADERS.formInstructions);
-		for (const doc of formInstructions) sections.push(doc.bodyMarkdown.trim());
-	}
-	const roleInstructions = form.metadata?.roleInstructions?.[targetRole];
-	if (roleInstructions) {
-		sections.push("");
-		sections.push(SECTION_HEADERS.roleInstructions(targetRole));
-		sections.push(roleInstructions);
-	} else {
-		const defaultRoleInstr = DEFAULT_ROLE_INSTRUCTIONS[targetRole];
-		if (defaultRoleInstr) {
-			sections.push("");
-			sections.push(SECTION_HEADERS.roleGuidance);
-			sections.push(defaultRoleInstr);
-		}
-	}
-	const fieldIds = new Set(issues.filter((i) => i.scope === "field").map((i) => i.ref));
-	const fieldInstructions = [];
-	for (const fieldId of fieldIds) {
-		const fieldDocs = getDocBlocks(form.docs, fieldId, "instructions");
-		if (fieldDocs.length > 0) for (const doc of fieldDocs) fieldInstructions.push(`**${fieldId}:** ${doc.bodyMarkdown.trim()}`);
-	}
-	if (fieldInstructions.length > 0) {
-		sections.push("");
-		sections.push(SECTION_HEADERS.fieldInstructions);
-		sections.push(...fieldInstructions);
-	}
-	return sections.join("\n");
-}
-/**
-* Build a context prompt with full form state and remaining issues.
-*
-* The form markdown shows the agent exactly what's been filled so far,
-* making each turn stateless - all state is in the form itself.
-*/
-function buildContextPrompt(issues, form, maxPatches) {
-	const lines = [];
-	lines.push("# Current Form State");
-	lines.push("");
-	lines.push("Below is the complete form with all currently filled values.");
-	lines.push("Fields marked with `[ ]` or empty values still need to be filled.");
-	lines.push("");
-	lines.push("```markdown");
-	lines.push(serialize(form));
-	lines.push("```");
-	lines.push("");
-	lines.push(ISSUES_HEADER);
-	lines.push("");
-	lines.push(getIssuesIntro(maxPatches));
-	lines.push("");
-	for (const issue of issues) {
-		lines.push(`- **${issue.ref}** (${issue.scope}): ${issue.message}`);
-		lines.push(`  Severity: ${issue.severity}, Priority: P${issue.priority}`);
-		if (issue.scope === "field") {
-			const field = findField(form, issue.ref);
-			if (field) {
-				lines.push(`  Type: ${field.kind}`);
-				if ("options" in field && field.options) {
-					const optionIds = field.options.map((o) => o.id).join(", ");
-					lines.push(`  Options: ${optionIds}`);
-				}
-				if (field.kind === "checkboxes" && "checkboxMode" in field) lines.push(`  Mode: ${field.checkboxMode ?? "multi"}`);
-			}
-		}
-		lines.push("");
-	}
-	lines.push(PATCH_FORMAT_INSTRUCTIONS);
-	return lines.join("\n");
-}
-/**
-* Find a field by ID in the form.
-*/
-function findField(form, fieldId) {
-	for (const group of form.schema.groups) for (const field of group.children) if (field.id === fieldId) return field;
-	return null;
-}
-/**
-* Load web search tools for a provider.
-*
-* Uses statically imported provider modules to get web search tools.
-* Returns empty object if provider doesn't support web search.
-*/
-function loadWebSearchTools(provider) {
-	if (!getWebSearchConfig(provider)) return {};
-	switch (provider) {
-		case "openai":
-			if (openai.tools?.webSearch) return { web_search: openai.tools.webSearch({}) };
-			if (openai.tools?.webSearchPreview) return { web_search: openai.tools.webSearchPreview({}) };
-			return {};
-		case "google":
-			if (google.tools?.googleSearch) return { google_search: google.tools.googleSearch({}) };
-			return {};
-		case "xai": return {};
-		default: return {};
-	}
-}
-/**
-* Create a live agent with the given configuration.
-*/
-function createLiveAgent(config) {
-	return new LiveAgent(config);
-}
-
-//#endregion
-//#region src/harness/modelResolver.ts
-/**
-* Map of provider names to their npm package and env var.
-*/
-const PROVIDERS = {
-	anthropic: {
-		package: "@ai-sdk/anthropic",
-		envVar: "ANTHROPIC_API_KEY",
-		createFn: "createAnthropic"
-	},
-	openai: {
-		package: "@ai-sdk/openai",
-		envVar: "OPENAI_API_KEY",
-		createFn: "createOpenAI"
-	},
-	google: {
-		package: "@ai-sdk/google",
-		envVar: "GOOGLE_GENERATIVE_AI_API_KEY",
-		createFn: "createGoogleGenerativeAI"
-	},
-	xai: {
-		package: "@ai-sdk/xai",
-		envVar: "XAI_API_KEY",
-		createFn: "createXai"
-	},
-	deepseek: {
-		package: "@ai-sdk/deepseek",
-		envVar: "DEEPSEEK_API_KEY",
-		createFn: "createDeepSeek"
-	}
-};
-/**
-* Parse a model ID string into provider and model components.
-*
-* @param modelIdString - Model ID in format `provider/model-id`
-* @returns Parsed model identifier
-* @throws Error if format is invalid
-*/
-function parseModelId(modelIdString) {
-	const slashIndex = modelIdString.indexOf("/");
-	if (slashIndex === -1) throw new Error(`Invalid model ID format: "${modelIdString}". Expected format: provider/model-id (e.g., anthropic/claude-sonnet-4-5)`);
-	const provider = modelIdString.slice(0, slashIndex);
-	const modelId = modelIdString.slice(slashIndex + 1);
-	if (!provider || !modelId) throw new Error(`Invalid model ID format: "${modelIdString}". Both provider and model ID are required.`);
-	const supportedProviders = Object.keys(PROVIDERS);
-	if (!supportedProviders.includes(provider)) throw new Error(`Unknown provider: "${provider}". Supported providers: ${supportedProviders.join(", ")}`);
-	return {
-		provider,
-		modelId
-	};
-}
-/**
-* Resolve a model ID string to an AI SDK language model.
-*
-* Dynamically imports the provider package and creates the model instance.
-*
-* @param modelIdString - Model ID in format `provider/model-id`
-* @returns Resolved model with provider info
-* @throws Error if provider not installed or API key missing
-*/
-async function resolveModel(modelIdString) {
-	const { provider, modelId } = parseModelId(modelIdString);
-	const providerConfig = PROVIDERS[provider];
-	const apiKey = process.env[providerConfig.envVar];
-	if (!apiKey) throw new Error(`Missing API key for "${provider}" provider (model: ${modelIdString}).\nSet the ${providerConfig.envVar} environment variable or add it to your .env file.`);
-	let providerModule;
-	try {
-		providerModule = await import(providerConfig.package);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		if (message.includes("Cannot find module") || message.includes("ERR_MODULE_NOT_FOUND")) throw new Error(`Provider package not installed for model "${modelIdString}".\nInstall with: pnpm add ${providerConfig.package}`);
-		throw error;
-	}
-	const createFn = providerModule[providerConfig.createFn];
-	let model;
-	if (createFn && typeof createFn === "function") model = createFn({ apiKey })(modelId);
-	else {
-		const providerFn = providerModule[provider];
-		if (typeof providerFn !== "function") throw new Error(`Provider package "${providerConfig.package}" does not export expected function "${provider}" or "${providerConfig.createFn}"`);
-		model = providerFn(modelId);
-	}
-	return {
-		model,
-		provider,
-		modelId
-	};
-}
-/**
-* Get list of supported provider names.
-*/
-function getProviderNames() {
-	return Object.keys(PROVIDERS);
-}
-/**
-* Get provider info for display purposes.
-*/
-function getProviderInfo(provider) {
-	const config = PROVIDERS[provider];
-	return {
-		package: config.package,
-		envVar: config.envVar
-	};
-}
-
-//#endregion
-//#region src/harness/programmaticFill.ts
-function buildErrorResult(form, errors, warnings) {
-	return {
-		status: {
-			ok: false,
-			reason: "error",
-			message: errors.join("; ")
-		},
-		markdown: serialize(form),
-		values: { ...form.valuesByFieldId },
-		form,
-		turns: 0,
-		totalPatches: 0,
-		inputContextWarnings: warnings.length > 0 ? warnings : void 0
-	};
-}
-function buildResult(form, turns, totalPatches, status, inputContextWarnings, remainingIssues) {
-	const result = {
-		status,
-		markdown: serialize(form),
-		values: { ...form.valuesByFieldId },
-		form,
-		turns,
-		totalPatches
-	};
-	if (inputContextWarnings && inputContextWarnings.length > 0) result.inputContextWarnings = inputContextWarnings;
-	if (remainingIssues && remainingIssues.length > 0) result.remainingIssues = remainingIssues.map((issue) => ({
-		ref: issue.ref,
-		message: issue.message,
-		severity: issue.severity,
-		priority: issue.priority
-	}));
-	return result;
-}
-/**
-* Fill a form using an LLM agent.
-*
-* This is the primary programmatic entry point for markform. It encapsulates
-* the harness loop with LiveAgent and provides a single-function call for
-* form filling.
-*
-* @param options - Fill options
-* @returns Fill result with status, values, and markdown
-*
-* @example
-* ```typescript
-* import { fillForm } from 'markform';
-*
-* const result = await fillForm({
-*   form: formMarkdown,
-*   model: 'anthropic/claude-sonnet-4-5',
-*   inputContext: {
-*     company_name: 'Apple Inc.',
-*   },
-*   systemPromptAddition: `
-*     ## Additional Context
-*     ${backgroundInfo}
-*   `,
-*   onTurnComplete: (progress) => {
-*     console.log(`Turn ${progress.turnNumber}: ${progress.requiredIssuesRemaining} remaining`);
-*   },
-* });
-*
-* if (result.status.ok) {
-*   console.log('Values:', result.values);
-* }
-* ```
-*/
-async function fillForm(options) {
-	let form;
-	try {
-		form = typeof options.form === "string" ? parseForm(options.form) : structuredClone(options.form);
-	} catch (error) {
-		return {
-			status: {
-				ok: false,
-				reason: "error",
-				message: `Form parse error: ${error instanceof Error ? error.message : String(error)}`
-			},
-			markdown: typeof options.form === "string" ? options.form : "",
-			values: {},
-			form: {
-				schema: {
-					id: "",
-					groups: []
-				},
-				valuesByFieldId: {},
-				skipsByFieldId: {},
-				docs: [],
-				orderIndex: [],
-				idIndex: /* @__PURE__ */ new Map()
-			},
-			turns: 0,
-			totalPatches: 0
-		};
-	}
-	let model;
-	let provider;
-	if (!options._testAgent) try {
-		if (typeof options.model === "string") {
-			const resolved = await resolveModel(options.model);
-			model = resolved.model;
-			provider = resolved.provider;
-		} else model = options.model;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return buildErrorResult(form, [`Model resolution error: ${message}`], []);
-	}
-	let totalPatches = 0;
-	let inputContextWarnings = [];
-	if (options.inputContext) {
-		const coercionResult = coerceInputContext(form, options.inputContext);
-		if (coercionResult.errors.length > 0) return buildErrorResult(form, coercionResult.errors, coercionResult.warnings);
-		if (coercionResult.patches.length > 0) {
-			applyPatches(form, coercionResult.patches);
-			totalPatches = coercionResult.patches.length;
-		}
-		inputContextWarnings = coercionResult.warnings;
-	}
-	const maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS;
-	const maxPatchesPerTurn = options.maxPatchesPerTurn ?? DEFAULT_MAX_PATCHES_PER_TURN;
-	const maxIssues = options.maxIssues ?? DEFAULT_MAX_ISSUES;
-	const targetRoles = options.targetRoles ?? [AGENT_ROLE];
-	const harness = createHarness(form, {
-		maxTurns,
-		maxPatchesPerTurn,
-		maxIssues,
-		targetRoles,
-		fillMode: options.fillMode
-	});
-	const agent = options._testAgent ?? createLiveAgent({
-		model,
-		systemPromptAddition: options.systemPromptAddition,
-		targetRole: targetRoles[0] ?? AGENT_ROLE,
-		provider,
-		enableWebSearch: true
-	});
-	let turnCount = 0;
-	let stepResult = harness.step();
-	while (!stepResult.isComplete && !harness.hasReachedMaxTurns()) {
-		if (options.signal?.aborted) return buildResult(form, turnCount, totalPatches, {
-			ok: false,
-			reason: "cancelled"
-		}, inputContextWarnings, stepResult.issues);
-		const { patches, stats } = await agent.generatePatches(stepResult.issues, form, maxPatchesPerTurn);
-		if (options.signal?.aborted) return buildResult(form, turnCount, totalPatches, {
-			ok: false,
-			reason: "cancelled"
-		}, inputContextWarnings, stepResult.issues);
-		let llmStats;
-		if (stats) llmStats = {
-			inputTokens: stats.inputTokens,
-			outputTokens: stats.outputTokens,
-			toolCalls: stats.toolCalls.length > 0 ? stats.toolCalls : void 0
-		};
-		stepResult = harness.apply(patches, stepResult.issues, llmStats);
-		totalPatches += patches.length;
-		turnCount++;
-		if (options.onTurnComplete) try {
-			const requiredIssues = stepResult.issues.filter((i) => i.severity === "required");
-			options.onTurnComplete({
-				turnNumber: turnCount,
-				issuesShown: stepResult.issues.length,
-				patchesApplied: patches.length,
-				requiredIssuesRemaining: requiredIssues.length,
-				isComplete: stepResult.isComplete,
-				stats
-			});
-		} catch {}
-		if (!stepResult.isComplete && !harness.hasReachedMaxTurns()) stepResult = harness.step();
-	}
-	if (stepResult.isComplete) return buildResult(form, turnCount, totalPatches, { ok: true }, inputContextWarnings);
-	return buildResult(form, turnCount, totalPatches, {
-		ok: false,
-		reason: "max_turns",
-		message: `Reached maximum turns (${maxTurns})`
-	}, inputContextWarnings, stepResult.issues);
-}
-
-//#endregion
-//#region src/index.ts
-/**
-* Markform - Agent-friendly, human-readable, editable forms.
-*
-* This is the main library entry point that exports the core engine,
-* types, and utilities for working with .form.md files.
-*/
-/** Markform version. */
-const VERSION = "0.1.0";
-
-//#endregion
-export { parseForm as _, resolveModel as a, createMockAgent as c, coerceInputContext as d, coerceToFieldPatch as f, ParseError as g, serializeSession as h, getProviderNames as i, FormHarness as l, parseSession as m, fillForm as n, createLiveAgent as o, findFieldById as p, getProviderInfo as r, MockAgent as s, VERSION as t, createHarness as u };