markform 0.1.0 → 0.1.2

package/dist/src-DBD3Dt4f.mjs

@@ -1,1785 +0,0 @@
-import { $ as PatchSchema, _ as DEFAULT_PRIORITY, f as AGENT_ROLE, h as DEFAULT_MAX_TURNS, it as SessionTranscriptSchema, 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-C0vjijlP.mjs";
-import { z } from "zod";
-import Markdoc from "@markdoc/markdoc";
-import YAML from "yaml";
-import { createHash } from "node:crypto";
-import { generateText, stepCountIs, zodSchema } from "ai";
-
-//#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 field = {
-		kind: "checkboxes",
-		id,
-		label,
-		required: getBooleanAttr(node, "required") ?? false,
-		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 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);
-		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,
-		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
-		}
-	};
-}
-/**
-* 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);
-		default: return {
-			ok: false,
-			error: `Unknown field kind: ${field.kind}`
-		};
-	}
-}
-/**
-* 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.
-	*/
-	hasReachedMaxTurns() {
-		return this.turnNumber >= this.config.maxTurns;
-	}
-	/**
-	* 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 limitedIssues = this.filterIssuesByScope(result.issues).slice(0, this.config.maxIssues);
-		const stepBudget = Math.min(this.config.maxPatchesPerTurn, limitedIssues.filter((i) => i.severity === "required").length);
-		if (result.isComplete) this.state = "complete";
-		else this.state = "wait";
-		return {
-			structureSummary: result.structureSummary,
-			progressSummary: result.progressSummary,
-			issues: limitedIssues,
-			stepBudget,
-			isComplete: result.isComplete,
-			turnNumber: this.turnNumber
-		};
-	}
-	/**
-	* 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)
-	* @returns StepResult after applying patches
-	*/
-	apply(patches, issues) {
-		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}`);
-		const result = applyPatches(this.form, patches);
-		const markdown = serialize(this.form);
-		const hash = createHash("sha256").update(markdown).digest("hex");
-		const requiredIssueCount = result.issues.filter((i) => i.severity === "required").length;
-		this.turns.push({
-			turn: this.turnNumber,
-			inspect: { issues },
-			apply: { patches },
-			after: {
-				requiredIssueCount,
-				markdownSha256: hash
-			}
-		});
-		const limitedIssues = this.filterIssuesByScope(result.issues).slice(0, this.config.maxIssues);
-		const stepBudget = Math.min(this.config.maxPatchesPerTurn, limitedIssues.filter((i) => i.severity === "required").length);
-		if (result.isComplete) this.state = "complete";
-		else if (this.turnNumber >= this.config.maxTurns) this.state = "complete";
-		else this.state = "wait";
-		return {
-			structureSummary: result.structureSummary,
-			progressSummary: result.progressSummary,
-			issues: limitedIssues,
-			stepBudget,
-			isComplete: result.isComplete,
-			turnNumber: this.turnNumber
-		};
-	}
-	/**
-	* 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() {
-		const markdown = serialize(this.form);
-		return createHash("sha256").update(markdown).digest("hex");
-	}
-	/**
-	* 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.
-	*/
-	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 completedValue = this.completedValues[fieldId];
-			if (!completedValue) continue;
-			const field = this.fieldMap.get(fieldId);
-			if (!field) continue;
-			const patch = this.createPatch(fieldId, field, completedValue);
-			if (patch) {
-				patches.push(patch);
-				addressedFields.add(fieldId);
-			}
-		}
-		return Promise.resolve(patches);
-	}
-	/**
-	* 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
-			};
-			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/liveAgent.ts
-/**
-* Live agent that uses an LLM to generate patches.
-*/
-var LiveAgent = class {
-	model;
-	maxStepsPerTurn;
-	systemPromptAddition;
-	targetRole;
-	constructor(config) {
-		this.model = config.model;
-		this.maxStepsPerTurn = config.maxStepsPerTurn ?? 3;
-		this.systemPromptAddition = config.systemPromptAddition;
-		this.targetRole = config.targetRole ?? AGENT_ROLE;
-	}
-	/**
-	* Generate patches using the LLM.
-	*
-	* Calls the model with the current form state and issues,
-	* and extracts patches from the tool calls.
-	*/
-	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;
-		const generatePatchesTool = {
-			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.",
-			inputSchema: zodSchema(z.object({ patches: z.array(PatchSchema).max(maxPatches).describe("Array of patches. Each patch sets a value for one field.") }))
-		};
-		const result = await generateText({
-			model: this.model,
-			system: systemPrompt,
-			prompt: contextPrompt,
-			tools: { generatePatches: generatePatchesTool },
-			stopWhen: stepCountIs(this.maxStepsPerTurn)
-		});
-		const patches = [];
-		for (const step of result.steps) for (const toolCall of step.toolCalls) if (toolCall.toolName === "generatePatches" && "input" in toolCall) {
-			const input = toolCall.input;
-			patches.push(...input.patches);
-		}
-		return patches.slice(0, maxPatches);
-	}
-};
-/**
-* Default system prompt for the live agent.
-*/
-const DEFAULT_SYSTEM_PROMPT = `You are a form-filling assistant. Your task is to analyze form issues and generate patches to fill in the required fields.
-
-Guidelines:
-1. Focus on required fields first (severity: "required")
-2. Use realistic but generic values when specific data is not provided
-3. Match the expected field types exactly
-4. For string fields: use appropriate text
-5. For number fields: use appropriate numeric values
-6. For single_select: choose one valid option ID
-7. For multi_select: choose one or more valid option IDs
-8. For checkboxes: set appropriate states (done/todo for simple, yes/no for explicit)
-
-Always use the generatePatches tool to submit your field values.`;
-/**
-* 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("# Form Instructions");
-		for (const doc of formInstructions) sections.push(doc.bodyMarkdown.trim());
-	}
-	const roleInstructions = form.metadata?.roleInstructions?.[targetRole];
-	if (roleInstructions) {
-		sections.push("");
-		sections.push(`# Instructions for ${targetRole} role`);
-		sections.push(roleInstructions);
-	} else {
-		const defaultRoleInstr = DEFAULT_ROLE_INSTRUCTIONS[targetRole];
-		if (defaultRoleInstr) {
-			sections.push("");
-			sections.push(`# Role guidance`);
-			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("# Field-specific instructions");
-		sections.push(...fieldInstructions);
-	}
-	return sections.join("\n");
-}
-/**
-* Build a context prompt with issues and form information.
-*/
-function buildContextPrompt(issues, form, maxPatches) {
-	const lines = [];
-	lines.push("# Current Form Issues");
-	lines.push("");
-	lines.push(`You need to address up to ${maxPatches} issues. Here are the current issues:`);
-	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("# Instructions");
-	lines.push("");
-	lines.push("Use the generatePatches tool to submit patches for the fields above.");
-	lines.push("Each patch should match the field type:");
-	lines.push("- string: { op: \"set_string\", fieldId: \"...\", value: \"...\" }");
-	lines.push("- number: { op: \"set_number\", fieldId: \"...\", value: 123 }");
-	lines.push("- string_list: { op: \"set_string_list\", fieldId: \"...\", items: [\"...\", \"...\"] }");
-	lines.push("- single_select: { op: \"set_single_select\", fieldId: \"...\", selected: \"option_id\" }");
-	lines.push("- multi_select: { op: \"set_multi_select\", fieldId: \"...\", selected: [\"opt1\", \"opt2\"] }");
-	lines.push("- checkboxes: { op: \"set_checkboxes\", fieldId: \"...\", values: { \"opt1\": \"done\", \"opt2\": \"todo\" } }");
-	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;
-}
-/**
-* 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: {},
-				docs: [],
-				orderIndex: [],
-				idIndex: /* @__PURE__ */ new Map()
-			},
-			turns: 0,
-			totalPatches: 0
-		};
-	}
-	let model;
-	if (!options._testAgent) try {
-		if (typeof options.model === "string") model = (await resolveModel(options.model)).model;
-		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
-	});
-	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 = await agent.generatePatches(stepResult.issues, form, maxPatchesPerTurn);
-		if (options.signal?.aborted) return buildResult(form, turnCount, totalPatches, {
-			ok: false,
-			reason: "cancelled"
-		}, inputContextWarnings, stepResult.issues);
-		stepResult = harness.apply(patches, stepResult.issues);
-		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
-			});
-		} catch {}
-		if (!stepResult.isComplete) 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 };