markform 0.1.0 → 0.1.2

package/dist/{apply-C0vjijlP.mjs → apply-BfAGTHMh.mjs}

@@ -1,385 +1,114 @@
-import { z } from "zod";
+import { resolve } from "node:path";
 
-//#region src/engine/coreTypes.ts
+//#region src/llms.ts
 /**
-* Core types and Zod schemas for Markform.
+* LLM-related settings and configuration.
 *
-* This module defines all TypeScript types and their corresponding Zod schemas
-* for forms, fields, values, validation, patches, and session transcripts.
-*/
-const IdSchema = z.string().min(1);
-const OptionIdSchema = z.string().min(1);
-const ValidatorRefSchema = z.union([z.string(), z.object({ id: z.string() }).passthrough()]);
-const MultiCheckboxStateSchema = z.enum([
-	"todo",
-	"done",
-	"incomplete",
-	"active",
-	"na"
-]);
-const SimpleCheckboxStateSchema = z.enum(["todo", "done"]);
-const ExplicitCheckboxValueSchema = z.enum([
-	"unfilled",
-	"yes",
-	"no"
-]);
-const CheckboxValueSchema = z.union([MultiCheckboxStateSchema, ExplicitCheckboxValueSchema]);
-const CheckboxModeSchema = z.enum([
-	"multi",
-	"simple",
-	"explicit"
-]);
-const FillModeSchema = z.enum(["continue", "overwrite"]);
-const ApprovalModeSchema = z.enum(["none", "blocking"]);
-const FieldKindSchema = z.enum([
-	"string",
-	"number",
-	"string_list",
-	"checkboxes",
-	"single_select",
-	"multi_select"
-]);
-const FieldPriorityLevelSchema = z.enum([
-	"high",
-	"medium",
-	"low"
-]);
-const OptionSchema = z.object({
-	id: IdSchema,
-	label: z.string()
-});
-const FieldBaseSchemaPartial = {
-	id: IdSchema,
-	label: z.string(),
-	required: z.boolean(),
-	priority: FieldPriorityLevelSchema,
-	role: z.string(),
-	validate: z.array(ValidatorRefSchema).optional()
+* This module centralizes LLM provider and model configuration,
+* including suggested models and web search support.
+*/
+/**
+* Suggested LLM models for the fill command, organized by provider.
+* These are shown in help/error messages and model selection prompts.
+*/
+const SUGGESTED_LLMS = {
+	openai: [
+		"gpt-5-mini",
+		"gpt-5-nano",
+		"gpt-5.2",
+		"gpt-5.2-pro",
+		"o3",
+		"o3-mini"
+	],
+	anthropic: [
+		"claude-opus-4-5",
+		"claude-sonnet-4-5",
+		"claude-haiku-4-5"
+	],
+	google: [
+		"gemini-3-flash",
+		"gemini-3-pro-preview",
+		"gemini-2.5-flash"
+	],
+	xai: ["grok-4", "grok-4.1-fast"],
+	deepseek: ["deepseek-chat", "deepseek-reasoner"]
 };
-const StringFieldSchema = z.object({
-	...FieldBaseSchemaPartial,
-	kind: z.literal("string"),
-	multiline: z.boolean().optional(),
-	pattern: z.string().optional(),
-	minLength: z.number().int().nonnegative().optional(),
-	maxLength: z.number().int().nonnegative().optional()
-});
-const NumberFieldSchema = z.object({
-	...FieldBaseSchemaPartial,
-	kind: z.literal("number"),
-	min: z.number().optional(),
-	max: z.number().optional(),
-	integer: z.boolean().optional()
-});
-const StringListFieldSchema = z.object({
-	...FieldBaseSchemaPartial,
-	kind: z.literal("string_list"),
-	minItems: z.number().int().nonnegative().optional(),
-	maxItems: z.number().int().nonnegative().optional(),
-	itemMinLength: z.number().int().nonnegative().optional(),
-	itemMaxLength: z.number().int().nonnegative().optional(),
-	uniqueItems: z.boolean().optional()
-});
-const CheckboxesFieldSchema = z.object({
-	...FieldBaseSchemaPartial,
-	kind: z.literal("checkboxes"),
-	checkboxMode: CheckboxModeSchema,
-	minDone: z.number().int().optional(),
-	options: z.array(OptionSchema),
-	approvalMode: ApprovalModeSchema
-});
-const SingleSelectFieldSchema = z.object({
-	...FieldBaseSchemaPartial,
-	kind: z.literal("single_select"),
-	options: z.array(OptionSchema)
-});
-const MultiSelectFieldSchema = z.object({
-	...FieldBaseSchemaPartial,
-	kind: z.literal("multi_select"),
-	options: z.array(OptionSchema),
-	minSelections: z.number().int().nonnegative().optional(),
-	maxSelections: z.number().int().nonnegative().optional()
-});
-const FieldSchema = z.discriminatedUnion("kind", [
-	StringFieldSchema,
-	NumberFieldSchema,
-	StringListFieldSchema,
-	CheckboxesFieldSchema,
-	SingleSelectFieldSchema,
-	MultiSelectFieldSchema
-]);
-const FieldGroupSchema = z.object({
-	kind: z.literal("field_group"),
-	id: IdSchema,
-	title: z.string().optional(),
-	validate: z.array(ValidatorRefSchema).optional(),
-	children: z.array(FieldSchema)
-});
-const FormSchemaSchema = z.object({
-	id: IdSchema,
-	title: z.string().optional(),
-	groups: z.array(FieldGroupSchema)
-});
-const StringValueSchema = z.object({
-	kind: z.literal("string"),
-	value: z.string().nullable()
-});
-const NumberValueSchema = z.object({
-	kind: z.literal("number"),
-	value: z.number().nullable()
-});
-const StringListValueSchema = z.object({
-	kind: z.literal("string_list"),
-	items: z.array(z.string())
-});
-const CheckboxesValueSchema = z.object({
-	kind: z.literal("checkboxes"),
-	values: z.record(OptionIdSchema, CheckboxValueSchema)
-});
-const SingleSelectValueSchema = z.object({
-	kind: z.literal("single_select"),
-	selected: OptionIdSchema.nullable()
-});
-const MultiSelectValueSchema = z.object({
-	kind: z.literal("multi_select"),
-	selected: z.array(OptionIdSchema)
-});
-const FieldValueSchema = z.discriminatedUnion("kind", [
-	StringValueSchema,
-	NumberValueSchema,
-	StringListValueSchema,
-	CheckboxesValueSchema,
-	SingleSelectValueSchema,
-	MultiSelectValueSchema
-]);
-const DocumentationTagSchema = z.enum([
-	"description",
-	"instructions",
-	"documentation"
-]);
-const DocumentationBlockSchema = z.object({
-	tag: DocumentationTagSchema,
-	ref: z.string(),
-	bodyMarkdown: z.string()
-});
-const FormMetadataSchema = z.object({
-	markformVersion: z.string(),
-	roles: z.array(z.string()).min(1),
-	roleInstructions: z.record(z.string(), z.string())
-});
-const SeveritySchema = z.enum([
-	"error",
-	"warning",
-	"info"
-]);
-const SourcePositionSchema = z.object({
-	line: z.number().int().positive(),
-	col: z.number().int().positive()
-});
-const SourceRangeSchema = z.object({
-	start: SourcePositionSchema,
-	end: SourcePositionSchema
-});
-const ValidationIssueSchema = z.object({
-	severity: SeveritySchema,
-	message: z.string(),
-	code: z.string().optional(),
-	ref: IdSchema.optional(),
-	path: z.string().optional(),
-	range: SourceRangeSchema.optional(),
-	validatorId: z.string().optional(),
-	source: z.enum([
-		"builtin",
-		"code",
-		"llm"
-	])
-});
-const IssueReasonSchema = z.enum([
-	"validation_error",
-	"required_missing",
-	"checkbox_incomplete",
-	"min_items_not_met",
-	"optional_empty"
-]);
-const IssueScopeSchema = z.enum([
-	"form",
-	"group",
-	"field",
-	"option"
-]);
-const InspectIssueSchema = z.object({
-	ref: z.union([IdSchema, z.string()]),
-	scope: IssueScopeSchema,
-	reason: IssueReasonSchema,
-	message: z.string(),
-	severity: z.enum(["required", "recommended"]),
-	priority: z.number().int().positive(),
-	blockedBy: IdSchema.optional()
-});
-const ProgressStateSchema = z.enum([
-	"empty",
-	"incomplete",
-	"invalid",
-	"complete"
-]);
-const CheckboxProgressCountsSchema = z.object({
-	total: z.number().int().nonnegative(),
-	todo: z.number().int().nonnegative(),
-	done: z.number().int().nonnegative(),
-	incomplete: z.number().int().nonnegative(),
-	active: z.number().int().nonnegative(),
-	na: z.number().int().nonnegative(),
-	unfilled: z.number().int().nonnegative(),
-	yes: z.number().int().nonnegative(),
-	no: z.number().int().nonnegative()
-});
-const FieldProgressSchema = z.object({
-	kind: FieldKindSchema,
-	required: z.boolean(),
-	submitted: z.boolean(),
-	state: ProgressStateSchema,
-	valid: z.boolean(),
-	issueCount: z.number().int().nonnegative(),
-	checkboxProgress: CheckboxProgressCountsSchema.optional()
-});
-const ProgressCountsSchema = z.object({
-	totalFields: z.number().int().nonnegative(),
-	requiredFields: z.number().int().nonnegative(),
-	submittedFields: z.number().int().nonnegative(),
-	completeFields: z.number().int().nonnegative(),
-	incompleteFields: z.number().int().nonnegative(),
-	invalidFields: z.number().int().nonnegative(),
-	emptyRequiredFields: z.number().int().nonnegative(),
-	emptyOptionalFields: z.number().int().nonnegative()
-});
-const ProgressSummarySchema = z.object({
-	counts: ProgressCountsSchema,
-	fields: z.record(IdSchema, FieldProgressSchema)
-});
-const StructureSummarySchema = z.object({
-	groupCount: z.number().int().nonnegative(),
-	fieldCount: z.number().int().nonnegative(),
-	optionCount: z.number().int().nonnegative(),
-	fieldCountByKind: z.record(FieldKindSchema, z.number().int().nonnegative()),
-	groupsById: z.record(IdSchema, z.literal("field_group")),
-	fieldsById: z.record(IdSchema, FieldKindSchema),
-	optionsById: z.record(z.string(), z.object({
-		parentFieldId: IdSchema,
-		parentFieldKind: FieldKindSchema
-	}))
-});
-const InspectResultSchema = z.object({
-	structureSummary: StructureSummarySchema,
-	progressSummary: ProgressSummarySchema,
-	issues: z.array(InspectIssueSchema),
-	isComplete: z.boolean(),
-	formState: ProgressStateSchema
-});
-const ApplyResultSchema = z.object({
-	applyStatus: z.enum(["applied", "rejected"]),
-	structureSummary: StructureSummarySchema,
-	progressSummary: ProgressSummarySchema,
-	issues: z.array(InspectIssueSchema),
-	isComplete: z.boolean(),
-	formState: ProgressStateSchema
-});
-const SetStringPatchSchema = z.object({
-	op: z.literal("set_string"),
-	fieldId: IdSchema,
-	value: z.string().nullable()
-});
-const SetNumberPatchSchema = z.object({
-	op: z.literal("set_number"),
-	fieldId: IdSchema,
-	value: z.number().nullable()
-});
-const SetStringListPatchSchema = z.object({
-	op: z.literal("set_string_list"),
-	fieldId: IdSchema,
-	items: z.array(z.string())
-});
-const SetCheckboxesPatchSchema = z.object({
-	op: z.literal("set_checkboxes"),
-	fieldId: IdSchema,
-	values: z.record(OptionIdSchema, CheckboxValueSchema)
-});
-const SetSingleSelectPatchSchema = z.object({
-	op: z.literal("set_single_select"),
-	fieldId: IdSchema,
-	selected: OptionIdSchema.nullable()
-});
-const SetMultiSelectPatchSchema = z.object({
-	op: z.literal("set_multi_select"),
-	fieldId: IdSchema,
-	selected: z.array(OptionIdSchema)
-});
-const ClearFieldPatchSchema = z.object({
-	op: z.literal("clear_field"),
-	fieldId: IdSchema
-});
-const PatchSchema = z.discriminatedUnion("op", [
-	SetStringPatchSchema,
-	SetNumberPatchSchema,
-	SetStringListPatchSchema,
-	SetCheckboxesPatchSchema,
-	SetSingleSelectPatchSchema,
-	SetMultiSelectPatchSchema,
-	ClearFieldPatchSchema
-]);
-const StepResultSchema = z.object({
-	structureSummary: StructureSummarySchema,
-	progressSummary: ProgressSummarySchema,
-	issues: z.array(InspectIssueSchema),
-	stepBudget: z.number().int().nonnegative(),
-	isComplete: z.boolean(),
-	turnNumber: z.number().int().positive()
-});
-const HarnessConfigSchema = z.object({
-	maxIssues: z.number().int().positive(),
-	maxPatchesPerTurn: z.number().int().positive(),
-	maxTurns: z.number().int().positive(),
-	maxFieldsPerTurn: z.number().int().positive().optional(),
-	maxGroupsPerTurn: z.number().int().positive().optional(),
-	targetRoles: z.array(z.string()).optional(),
-	fillMode: FillModeSchema.optional()
-});
-const SessionTurnSchema = z.object({
-	turn: z.number().int().positive(),
-	inspect: z.object({ issues: z.array(InspectIssueSchema) }),
-	apply: z.object({ patches: z.array(PatchSchema) }),
-	after: z.object({
-		requiredIssueCount: z.number().int().nonnegative(),
-		markdownSha256: z.string()
-	})
-});
-const SessionFinalSchema = z.object({
-	expectComplete: z.boolean(),
-	expectedCompletedForm: z.string()
-});
-const SessionTranscriptSchema = z.object({
-	sessionVersion: z.string(),
-	mode: z.enum(["mock", "live"]),
-	form: z.object({ path: z.string() }),
-	validators: z.object({ code: z.string().optional() }).optional(),
-	mock: z.object({ completedMock: z.string() }).optional(),
-	live: z.object({ modelId: z.string() }).optional(),
-	harness: HarnessConfigSchema,
-	turns: z.array(SessionTurnSchema),
-	final: SessionFinalSchema
-});
-const MarkformFrontmatterSchema = z.object({
-	markformVersion: z.string(),
-	formSummary: StructureSummarySchema,
-	formProgress: ProgressSummarySchema,
-	formState: ProgressStateSchema
-});
+/**
+* Format suggested LLMs for display in help/error messages.
+*/
+function formatSuggestedLlms() {
+	const lines = ["Available providers and example models:"];
+	for (const [provider, models] of Object.entries(SUGGESTED_LLMS)) {
+		lines.push(`  ${provider}/`);
+		for (const model of models) lines.push(`    - ${provider}/${model}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Web search configuration per provider.
+*
+* Tool names are from Vercel AI SDK provider documentation:
+* - openai: https://ai-sdk.dev/providers/ai-sdk-providers/openai
+* - anthropic: https://ai-sdk.dev/providers/ai-sdk-providers/anthropic
+* - google: https://ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai
+* - xai: https://ai-sdk.dev/providers/ai-sdk-providers/xai
+* - deepseek: https://ai-sdk.dev/providers/ai-sdk-providers/deepseek (no tools)
+*/
+const WEB_SEARCH_CONFIG = {
+	openai: {
+		supported: true,
+		toolName: "webSearch"
+	},
+	anthropic: {
+		supported: true,
+		toolName: "webSearch_20250305"
+	},
+	google: {
+		supported: true,
+		toolName: "googleSearch"
+	},
+	xai: {
+		supported: true,
+		toolName: "webSearch"
+	},
+	deepseek: { supported: false }
+};
+/**
+* Check if a provider supports native web search.
+*/
+function hasWebSearchSupport(provider) {
+	return WEB_SEARCH_CONFIG[provider]?.supported ?? false;
+}
+/**
+* Get web search tool configuration for a provider.
+* Returns undefined if provider doesn't support web search.
+*/
+function getWebSearchConfig(provider) {
+	const config = WEB_SEARCH_CONFIG[provider];
+	return config?.supported ? config : void 0;
+}
 
 //#endregion
 //#region src/settings.ts
+/**
+* Global settings and constants for Markform.
+*
+* This file consolidates non-changing default values that were previously
+* scattered across the codebase. These are NOT runtime configurable - they
+* are compile-time constants.
+*/
+/**
+* The current Markform spec version in full notation (e.g., "MF/0.1").
+* This is distinct from npm package version and tracks the format that
+* .form.md files conform to.
+*/
+const MF_SPEC_VERSION = "MF/0.1";
 /** Default role for fields without explicit role attribute */
 const AGENT_ROLE = "agent";
 /** Role for human-filled fields in interactive mode */
 const USER_ROLE = "user";
+/** Default roles list for forms without explicit roles in frontmatter */
+const DEFAULT_ROLES = [USER_ROLE, AGENT_ROLE];
 /** Default instructions per role (used when form doesn't specify role_instructions) */
 const DEFAULT_ROLE_INSTRUCTIONS = {
 	[USER_ROLE]: "Fill in the fields you have direct knowledge of.",
@@ -418,6 +147,22 @@ const DEFAULT_PRIORITY = "medium";
 */
 const DEFAULT_PORT = 3344;
 /**
+* Default forms directory for CLI output (relative to cwd).
+* Commands write form outputs here to avoid cluttering the workspace.
+*/
+const DEFAULT_FORMS_DIR = "./forms";
+/**
+* Resolve the forms directory path to an absolute path.
+* Uses the provided override or falls back to DEFAULT_FORMS_DIR.
+*
+* @param override Optional override path from CLI --forms-dir option
+* @param cwd Base directory for resolving relative paths (defaults to process.cwd())
+* @returns Absolute path to the forms directory
+*/
+function getFormsDir(override, cwd = process.cwd()) {
+	return resolve(cwd, override ?? DEFAULT_FORMS_DIR);
+}
+/**
 * Default maximum turns for the fill harness.
 * Prevents runaway loops during agent execution.
 */
@@ -427,55 +172,129 @@ const DEFAULT_MAX_TURNS = 100;
 */
 const DEFAULT_MAX_PATCHES_PER_TURN = 20;
 /**
-* Default maximum issues to show per step.
+* Default maximum issues to show per turn.
+* Note: Renamed from DEFAULT_MAX_ISSUES for naming consistency with other per-turn limits.
 */
-const DEFAULT_MAX_ISSUES = 10;
+const DEFAULT_MAX_ISSUES_PER_TURN = 10;
 /**
-* Suggested LLM models for the fill command, organized by provider.
-* These are shown in help/error messages. Only includes models from the
-* authoritative models.yaml configuration.
+* Default maximum issues to show per turn in research mode.
+* Lower than general fill to keep research responses focused.
 */
-const SUGGESTED_LLMS = {
-	openai: [
-		"gpt-5-mini",
-		"gpt-5-nano",
-		"gpt-5.1",
-		"gpt-5-pro",
-		"gpt-5.2",
-		"gpt-5.2-pro"
-	],
-	anthropic: [
-		"claude-opus-4-5",
-		"claude-opus-4-1",
-		"claude-sonnet-4-5",
-		"claude-sonnet-4-0",
-		"claude-haiku-4-5"
-	],
-	google: [
-		"gemini-2.5-pro",
-		"gemini-2.5-flash",
-		"gemini-2.0-flash",
-		"gemini-2.0-flash-lite",
-		"gemini-3-pro-preview"
-	],
-	xai: ["grok-4", "grok-4-fast"],
-	deepseek: ["deepseek-chat", "deepseek-reasoner"]
+const DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN = 5;
+/**
+* Default maximum patches per turn in research mode.
+*/
+const DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN = 10;
+/**
+* Export format extensions used by the export command and exportMultiFormat.
+* These are the primary output formats when exporting forms.
+*/
+const EXPORT_EXTENSIONS = {
+	form: ".form.md",
+	raw: ".raw.md",
+	yaml: ".yml",
+	json: ".json"
 };
 /**
-* Format suggested LLMs for display in help/error messages.
+* Report extension - generated by the report command.
+* Separate from exports as it's a filtered human-readable output.
 */
-function formatSuggestedLlms() {
-	const lines = ["Available providers and example models:"];
-	for (const [provider, models] of Object.entries(SUGGESTED_LLMS)) {
-		lines.push(`  ${provider}/`);
-		for (const model of models) lines.push(`    - ${provider}/${model}`);
+const REPORT_EXTENSION = ".report.md";
+/**
+* All recognized markform file extensions.
+* Combines export formats with report format.
+*/
+const ALL_EXTENSIONS = {
+	...EXPORT_EXTENSIONS,
+	report: REPORT_EXTENSION
+};
+/**
+* Detect file type from path based on extension.
+* Used by serve command to dispatch to appropriate renderer.
+*/
+function detectFileType(filePath) {
+	if (filePath.endsWith(ALL_EXTENSIONS.form)) return "form";
+	if (filePath.endsWith(ALL_EXTENSIONS.raw)) return "raw";
+	if (filePath.endsWith(ALL_EXTENSIONS.report)) return "report";
+	if (filePath.endsWith(ALL_EXTENSIONS.yaml)) return "yaml";
+	if (filePath.endsWith(ALL_EXTENSIONS.json)) return "json";
+	if (filePath.endsWith(".md")) return "raw";
+	return "unknown";
+}
+/**
+* Derive export path by replacing any known extension with the target format.
+* Only works with export formats (form, raw, yaml, json), not report.
+*/
+function deriveExportPath(basePath, format) {
+	let base = basePath;
+	for (const ext of Object.values(ALL_EXTENSIONS)) if (base.endsWith(ext)) {
+		base = base.slice(0, -ext.length);
+		break;
 	}
-	return lines.join("\n");
+	return base + EXPORT_EXTENSIONS[format];
 }
 
 //#endregion
 //#region src/engine/serialize.ts
 /**
+* Find the maximum run of fence characters at line starts (indent ≤ 3 spaces).
+* Lines with 4+ space indent are inside code blocks so don't break fences.
+*/
+function maxRunAtLineStart(value, char) {
+	const escaped = char === "`" ? "`" : "~";
+	const pattern = new RegExp(`^( {0,3})${escaped}+`, "gm");
+	let maxRun = 0;
+	let match;
+	while ((match = pattern.exec(value)) !== null) {
+		const indent = match[1]?.length ?? 0;
+		const runLength = match[0].length - indent;
+		if (runLength > maxRun) maxRun = runLength;
+	}
+	return maxRun;
+}
+/**
+* Pick the optimal fence character and length for a value.
+* Also detects if process=false is needed for Markdoc tags.
+*/
+function pickFence(value) {
+	const hasMarkdocTags = value.includes("{%");
+	const maxBackticks = maxRunAtLineStart(value, "`");
+	const maxTildes = maxRunAtLineStart(value, "~");
+	let char;
+	let maxRun;
+	if (maxBackticks <= maxTildes) {
+		char = "`";
+		maxRun = maxBackticks;
+	} else {
+		char = "~";
+		maxRun = maxTildes;
+	}
+	const len = Math.max(3, maxRun + 1);
+	return {
+		char,
+		len,
+		processFalse: hasMarkdocTags
+	};
+}
+/**
+* Format a value fence block with the given content.
+* Uses smart fence selection to avoid collision with code blocks in content.
+*/
+function formatValueFence(content) {
+	const { char, len, processFalse } = pickFence(content);
+	const fence = char.repeat(len);
+	return `\n${fence}value${processFalse ? " {% process=false %}" : ""}\n${content}\n${fence}\n`;
+}
+/**
+* Get sentinel value content for skipped/aborted fields with reason.
+* Returns the fence block if there's a reason, empty string otherwise.
+*/
+function getSentinelContent(response) {
+	if (response?.state === "skipped" && response.reason) return formatValueFence(`%SKIP% (${response.reason})`);
+	if (response?.state === "aborted" && response.reason) return formatValueFence(`%ABORT% (${response.reason})`);
+	return "";
+}
+/**
 * Serialize an attribute value to Markdoc format.
 */
 function serializeAttrValue(value) {
@@ -521,7 +340,7 @@ function getMarker(state) {
 /**
 * Serialize a string field.
 */
-function serializeStringField(field, value) {
+function serializeStringField(field, response) {
 	const attrs = {
 		id: field.id,
 		label: field.label
@@ -534,15 +353,22 @@ function serializeStringField(field, value) {
 	if (field.minLength !== void 0) attrs.minLength = field.minLength;
 	if (field.maxLength !== void 0) attrs.maxLength = field.maxLength;
 	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
 	const attrStr = serializeAttrs(attrs);
 	let content = "";
-	if (value?.value) content = `\n\`\`\`value\n${value.value}\n\`\`\`\n`;
+	if (response?.state === "answered" && response.value) {
+		const value = response.value;
+		if (value.value) content = formatValueFence(value.value);
+	}
+	const sentinelContent = getSentinelContent(response);
+	if (sentinelContent) content = sentinelContent;
 	return `{% string-field ${attrStr} %}${content}{% /string-field %}`;
 }
 /**
 * Serialize a number field.
 */
-function serializeNumberField(field, value) {
+function serializeNumberField(field, response) {
 	const attrs = {
 		id: field.id,
 		label: field.label
@@ -554,15 +380,22 @@ function serializeNumberField(field, value) {
 	if (field.max !== void 0) attrs.max = field.max;
 	if (field.integer) attrs.integer = field.integer;
 	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
 	const attrStr = serializeAttrs(attrs);
 	let content = "";
-	if (value?.value !== null && value?.value !== void 0) content = `\n\`\`\`value\n${value.value}\n\`\`\`\n`;
+	if (response?.state === "answered" && response.value) {
+		const value = response.value;
+		if (value.value !== null && value.value !== void 0) content = formatValueFence(String(value.value));
+	}
+	const sentinelContent = getSentinelContent(response);
+	if (sentinelContent) content = sentinelContent;
 	return `{% number-field ${attrStr} %}${content}{% /number-field %}`;
 }
 /**
 * Serialize a string-list field.
 */
-function serializeStringListField(field, value) {
+function serializeStringListField(field, response) {
 	const attrs = {
 		id: field.id,
 		label: field.label
@@ -576,9 +409,16 @@ function serializeStringListField(field, value) {
 	if (field.itemMaxLength !== void 0) attrs.itemMaxLength = field.itemMaxLength;
 	if (field.uniqueItems) attrs.uniqueItems = field.uniqueItems;
 	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
 	const attrStr = serializeAttrs(attrs);
 	let content = "";
-	if (value?.items && value.items.length > 0) content = `\n\`\`\`value\n${value.items.join("\n")}\n\`\`\`\n`;
+	if (response?.state === "answered" && response.value) {
+		const value = response.value;
+		if (value.items && value.items.length > 0) content = formatValueFence(value.items.join("\n"));
+	}
+	const sentinelContent = getSentinelContent(response);
+	if (sentinelContent) content = sentinelContent;
 	return `{% string-list ${attrStr} %}${content}{% /string-list %}`;
 }
 /**
@@ -595,7 +435,7 @@ function serializeOptions(options, selected) {
 /**
 * Serialize a single-select field.
 */
-function serializeSingleSelectField(field, value) {
+function serializeSingleSelectField(field, response) {
 	const attrs = {
 		id: field.id,
 		label: field.label
@@ -604,7 +444,11 @@ function serializeSingleSelectField(field, value) {
 	if (field.priority !== DEFAULT_PRIORITY) attrs.priority = field.priority;
 	if (field.role !== AGENT_ROLE) attrs.role = field.role;
 	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
 	const attrStr = serializeAttrs(attrs);
+	let value;
+	if (response?.state === "answered" && response.value) value = response.value;
 	const selected = {};
 	for (const opt of field.options) selected[opt.id] = opt.id === value?.selected ? "done" : "todo";
 	return `{% single-select ${attrStr} %}\n${serializeOptions(field.options, selected)}\n{% /single-select %}`;
@@ -612,7 +456,7 @@ function serializeSingleSelectField(field, value) {
 /**
 * Serialize a multi-select field.
 */
-function serializeMultiSelectField(field, value) {
+function serializeMultiSelectField(field, response) {
 	const attrs = {
 		id: field.id,
 		label: field.label
@@ -623,7 +467,11 @@ function serializeMultiSelectField(field, value) {
 	if (field.minSelections !== void 0) attrs.minSelections = field.minSelections;
 	if (field.maxSelections !== void 0) attrs.maxSelections = field.maxSelections;
 	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
 	const attrStr = serializeAttrs(attrs);
+	let value;
+	if (response?.state === "answered" && response.value) value = response.value;
 	const selected = {};
 	const selectedSet = new Set(value?.selected ?? []);
 	for (const opt of field.options) selected[opt.id] = selectedSet.has(opt.id) ? "done" : "todo";
@@ -632,7 +480,7 @@ function serializeMultiSelectField(field, value) {
 /**
 * Serialize a checkboxes field.
 */
-function serializeCheckboxesField(field, value) {
+function serializeCheckboxesField(field, response) {
 	const attrs = {
 		id: field.id,
 		label: field.label
@@ -644,20 +492,132 @@ function serializeCheckboxesField(field, value) {
 	if (field.minDone !== void 0) attrs.minDone = field.minDone;
 	if (field.approvalMode !== "none") attrs.approvalMode = field.approvalMode;
 	if (field.validate) attrs.validate = field.validate;
-	return `{% checkboxes ${serializeAttrs(attrs)} %}\n${serializeOptions(field.options, value?.values ?? {})}\n{% /checkboxes %}`;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
+	const attrStr = serializeAttrs(attrs);
+	let value;
+	if (response?.state === "answered" && response.value) value = response.value;
+	return `{% checkboxes ${attrStr} %}\n${serializeOptions(field.options, value?.values ?? {})}\n{% /checkboxes %}`;
+}
+/**
+* Serialize a url-field.
+*/
+function serializeUrlField(field, response) {
+	const attrs = {
+		id: field.id,
+		label: field.label
+	};
+	if (field.required) attrs.required = field.required;
+	if (field.priority !== DEFAULT_PRIORITY) attrs.priority = field.priority;
+	if (field.role !== AGENT_ROLE) attrs.role = field.role;
+	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
+	const attrStr = serializeAttrs(attrs);
+	let content = "";
+	if (response?.state === "answered" && response.value) {
+		const value = response.value;
+		if (value.value) content = formatValueFence(value.value);
+	}
+	const sentinelContent = getSentinelContent(response);
+	if (sentinelContent) content = sentinelContent;
+	return `{% url-field ${attrStr} %}${content}{% /url-field %}`;
+}
+/**
+* Serialize a url-list field.
+*/
+function serializeUrlListField(field, response) {
+	const attrs = {
+		id: field.id,
+		label: field.label
+	};
+	if (field.required) attrs.required = field.required;
+	if (field.priority !== DEFAULT_PRIORITY) attrs.priority = field.priority;
+	if (field.role !== AGENT_ROLE) attrs.role = field.role;
+	if (field.minItems !== void 0) attrs.minItems = field.minItems;
+	if (field.maxItems !== void 0) attrs.maxItems = field.maxItems;
+	if (field.uniqueItems) attrs.uniqueItems = field.uniqueItems;
+	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
+	const attrStr = serializeAttrs(attrs);
+	let content = "";
+	if (response?.state === "answered" && response.value) {
+		const value = response.value;
+		if (value.items && value.items.length > 0) content = formatValueFence(value.items.join("\n"));
+	}
+	const sentinelContent = getSentinelContent(response);
+	if (sentinelContent) content = sentinelContent;
+	return `{% url-list ${attrStr} %}${content}{% /url-list %}`;
+}
+/**
+* Serialize a date-field.
+*/
+function serializeDateField(field, response) {
+	const attrs = {
+		id: field.id,
+		label: field.label
+	};
+	if (field.required) attrs.required = field.required;
+	if (field.priority !== DEFAULT_PRIORITY) attrs.priority = field.priority;
+	if (field.role !== AGENT_ROLE) attrs.role = field.role;
+	if (field.min !== void 0) attrs.min = field.min;
+	if (field.max !== void 0) attrs.max = field.max;
+	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
+	const attrStr = serializeAttrs(attrs);
+	let content = "";
+	if (response?.state === "answered" && response.value) {
+		const value = response.value;
+		if (value.value) content = formatValueFence(value.value);
+	}
+	const sentinelContent = getSentinelContent(response);
+	if (sentinelContent) content = sentinelContent;
+	return `{% date-field ${attrStr} %}${content}{% /date-field %}`;
+}
+/**
+* Serialize a year-field.
+*/
+function serializeYearField(field, response) {
+	const attrs = {
+		id: field.id,
+		label: field.label
+	};
+	if (field.required) attrs.required = field.required;
+	if (field.priority !== DEFAULT_PRIORITY) attrs.priority = field.priority;
+	if (field.role !== AGENT_ROLE) attrs.role = field.role;
+	if (field.min !== void 0) attrs.min = field.min;
+	if (field.max !== void 0) attrs.max = field.max;
+	if (field.validate) attrs.validate = field.validate;
+	if (field.report !== void 0) attrs.report = field.report;
+	if (response?.state === "skipped" || response?.state === "aborted") attrs.state = response.state;
+	const attrStr = serializeAttrs(attrs);
+	let content = "";
+	if (response?.state === "answered" && response.value) {
+		const value = response.value;
+		if (value.value !== null && value.value !== void 0) content = formatValueFence(String(value.value));
+	}
+	const sentinelContent = getSentinelContent(response);
+	if (sentinelContent) content = sentinelContent;
+	return `{% year-field ${attrStr} %}${content}{% /year-field %}`;
 }
 /**
 * Serialize a field to Markdoc format.
 */
-function serializeField(field, values) {
-	const value = values[field.id];
+function serializeField(field, responses) {
+	const response = responses[field.id];
 	switch (field.kind) {
-		case "string": return serializeStringField(field, value);
-		case "number": return serializeNumberField(field, value);
-		case "string_list": return serializeStringListField(field, value);
-		case "single_select": return serializeSingleSelectField(field, value);
-		case "multi_select": return serializeMultiSelectField(field, value);
-		case "checkboxes": return serializeCheckboxesField(field, value);
+		case "string": return serializeStringField(field, response);
+		case "number": return serializeNumberField(field, response);
+		case "string_list": return serializeStringListField(field, response);
+		case "single_select": return serializeSingleSelectField(field, response);
+		case "multi_select": return serializeMultiSelectField(field, response);
+		case "checkboxes": return serializeCheckboxesField(field, response);
+		case "url": return serializeUrlField(field, response);
+		case "url_list": return serializeUrlListField(field, response);
+		case "date": return serializeDateField(field, response);
+		case "year": return serializeYearField(field, response);
 	}
 }
 /**
@@ -665,16 +625,39 @@ function serializeField(field, values) {
 * Uses the semantic tag name (description, instructions, documentation).
 */
 function serializeDocBlock(doc) {
-	const attrStr = serializeAttrs({ ref: doc.ref });
+	const attrs = { ref: doc.ref };
+	if (doc.report !== void 0) attrs.report = doc.report;
+	const attrStr = serializeAttrs(attrs);
 	return `{% ${doc.tag} ${attrStr} %}\n${doc.bodyMarkdown}\n{% /${doc.tag} %}`;
 }
 /**
+* Serialize notes in sorted order.
+* Notes are sorted numerically by ID suffix (n1, n2, n10 not n1, n10, n2).
+*/
+function serializeNotes(notes) {
+	if (notes.length === 0) return "";
+	const sorted = [...notes].sort((a, b) => {
+		return (Number.parseInt(a.id.replace(/^n/, ""), 10) || 0) - (Number.parseInt(b.id.replace(/^n/, ""), 10) || 0);
+	});
+	const lines = [];
+	for (const note of sorted) {
+		const attrStr = serializeAttrs({
+			id: note.id,
+			ref: note.ref,
+			role: note.role
+		});
+		lines.push(`{% note ${attrStr} %}\n${note.text}\n{% /note %}`);
+	}
+	return lines.join("\n\n");
+}
+/**
 * Serialize a field group.
 */
-function serializeFieldGroup(group, values, docs) {
+function serializeFieldGroup(group, responses, docs) {
 	const attrs = { id: group.id };
 	if (group.title) attrs.title = group.title;
 	if (group.validate) attrs.validate = group.validate;
+	if (group.report !== void 0) attrs.report = group.report;
 	const lines = [`{% field-group ${serializeAttrs(attrs)} %}`];
 	const docsByRef = /* @__PURE__ */ new Map();
 	for (const doc of docs) {
@@ -684,7 +667,7 @@ function serializeFieldGroup(group, values, docs) {
 	}
 	for (const field of group.children) {
 		lines.push("");
-		lines.push(serializeField(field, values));
+		lines.push(serializeField(field, responses));
 		const fieldDocs = docsByRef.get(field.id);
 		if (fieldDocs) for (const doc of fieldDocs) {
 			lines.push("");
@@ -698,7 +681,7 @@ function serializeFieldGroup(group, values, docs) {
 /**
 * Serialize a form schema.
 */
-function serializeFormSchema(schema, values, docs) {
+function serializeFormSchema(schema, responses, docs, notes) {
 	const attrs = { id: schema.id };
 	if (schema.title) attrs.title = schema.title;
 	const lines = [`{% form ${serializeAttrs(attrs)} %}`];
@@ -715,7 +698,12 @@ function serializeFormSchema(schema, values, docs) {
 	}
 	for (const group of schema.groups) {
 		lines.push("");
-		lines.push(serializeFieldGroup(group, values, docs));
+		lines.push(serializeFieldGroup(group, responses, docs));
+	}
+	const notesContent = serializeNotes(notes);
+	if (notesContent) {
+		lines.push("");
+		lines.push(notesContent);
 	}
 	lines.push("");
 	lines.push("{% /form %}");
@@ -731,8 +719,8 @@ function serializeFormSchema(schema, values, docs) {
 function serialize(form, opts) {
 	return `${`---
 markform:
-  markform_version: "${opts?.markformVersion ?? "0.1.0"}"
----`}\n\n${serializeFormSchema(form.schema, form.valuesByFieldId, form.docs)}\n`;
+  spec: "${opts?.specVersion ?? MF_SPEC_VERSION}"
+---`}\n\n${serializeFormSchema(form.schema, form.responsesByFieldId, form.docs, form.notes)}\n`;
 }
 /** Map checkbox state to GFM marker for raw markdown output */
 const STATE_TO_GFM_MARKER = {
@@ -748,10 +736,11 @@ const STATE_TO_GFM_MARKER = {
 /**
 * Serialize a field value to raw markdown (human-readable).
 */
-function serializeFieldRaw(field, values) {
-	const value = values[field.id];
+function serializeFieldRaw(field, responses) {
+	const response = responses[field.id];
 	const lines = [];
 	lines.push(`**${field.label}:**`);
+	const value = response?.state === "answered" ? response.value : void 0;
 	switch (field.kind) {
 		case "string": {
 			const strValue = value;
@@ -794,6 +783,30 @@ function serializeFieldRaw(field, values) {
 			}
 			break;
 		}
+		case "url": {
+			const urlValue = value;
+			if (urlValue?.value) lines.push(urlValue.value);
+			else lines.push("_(empty)_");
+			break;
+		}
+		case "url_list": {
+			const urlListValue = value;
+			if (urlListValue?.items && urlListValue.items.length > 0) for (const item of urlListValue.items) lines.push(`- ${item}`);
+			else lines.push("_(empty)_");
+			break;
+		}
+		case "date": {
+			const dateValue = value;
+			if (dateValue?.value) lines.push(dateValue.value);
+			else lines.push("_(empty)_");
+			break;
+		}
+		case "year": {
+			const yearValue = value;
+			if (yearValue?.value !== null && yearValue?.value !== void 0) lines.push(String(yearValue.value));
+			else lines.push("_(empty)_");
+			break;
+		}
 	}
 	return lines.join("\n");
 }
@@ -834,7 +847,70 @@ function serializeRawMarkdown(form) {
 			lines.push("");
 		}
 		for (const field of group.children) {
-			lines.push(serializeFieldRaw(field, form.valuesByFieldId));
+			lines.push(serializeFieldRaw(field, form.responsesByFieldId));
+			lines.push("");
+			const fieldDocs = docsByRef.get(field.id);
+			if (fieldDocs) for (const doc of fieldDocs) {
+				lines.push(doc.bodyMarkdown.trim());
+				lines.push("");
+			}
+		}
+	}
+	return lines.join("\n").trim() + "\n";
+}
+/**
+* Check if a documentation block should be included in reports.
+* Default: instructions are excluded, everything else is included.
+*/
+function shouldIncludeDoc(doc) {
+	if (doc.report !== void 0) return doc.report;
+	return doc.tag !== "instructions";
+}
+/**
+* Serialize a form to filtered markdown for reports.
+*
+* Produces clean, readable markdown with filtered content based on `report` attribute:
+* - Fields with report=false are excluded
+* - Groups with report=false are excluded
+* - Documentation blocks with report=false are excluded
+* - Instructions blocks are excluded by default (unless report=true)
+*
+* @param form - The parsed form to serialize
+* @returns Filtered plain markdown string suitable for sharing
+*/
+function serializeReportMarkdown(form) {
+	const lines = [];
+	const docsByRef = /* @__PURE__ */ new Map();
+	for (const doc of form.docs) {
+		if (!shouldIncludeDoc(doc)) continue;
+		const list = docsByRef.get(doc.ref) ?? [];
+		list.push(doc);
+		docsByRef.set(doc.ref, list);
+	}
+	if (form.schema.title) {
+		lines.push(`# ${form.schema.title}`);
+		lines.push("");
+	}
+	const formDocs = docsByRef.get(form.schema.id);
+	if (formDocs) for (const doc of formDocs) {
+		lines.push(doc.bodyMarkdown.trim());
+		lines.push("");
+	}
+	for (const group of form.schema.groups) {
+		if (group.report === false) continue;
+		const visibleFields = group.children.filter((field) => field.report !== false);
+		if (visibleFields.length === 0 && !group.title) continue;
+		if (group.title) {
+			lines.push(`## ${group.title}`);
+			lines.push("");
+		}
+		const groupDocs = docsByRef.get(group.id);
+		if (groupDocs) for (const doc of groupDocs) {
+			lines.push(doc.bodyMarkdown.trim());
+			lines.push("");
+		}
+		for (const field of visibleFields) {
+			lines.push(serializeFieldRaw(field, form.responsesByFieldId));
 			lines.push("");
 			const fieldDocs = docsByRef.get(field.id);
 			if (fieldDocs) for (const doc of fieldDocs) {
@@ -861,7 +937,11 @@ function computeStructureSummary(schema) {
 		string_list: 0,
 		checkboxes: 0,
 		single_select: 0,
-		multi_select: 0
+		multi_select: 0,
+		url: 0,
+		url_list: 0,
+		date: 0,
+		year: 0
 	};
 	const groupsById = {};
 	const fieldsById = {};
@@ -922,6 +1002,16 @@ function isFieldSubmitted(field, value) {
 			}
 			return false;
 		}
+		case "url": {
+			const v = value;
+			return v.value !== null && v.value.trim() !== "";
+		}
+		case "url_list": return value.items.length > 0;
+		case "date": {
+			const v = value;
+			return v.value !== null && v.value.trim() !== "";
+		}
+		case "year": return value.value !== null;
 	}
 }
 /**
@@ -951,45 +1041,33 @@ function computeCheckboxProgress(field, value) {
 	return result;
 }
 /**
-* Check if a checkboxes field is complete based on its mode.
+* Compute whether a field is empty (has no value).
 */
-function isCheckboxesComplete(field, value) {
-	if (!value) return false;
-	const mode = field.checkboxMode ?? "multi";
-	for (const opt of field.options) {
-		const state = value.values[opt.id];
-		if (mode === "explicit") {
-			if (state === "unfilled") return false;
-		} else if (mode === "multi") {
-			if (state === "todo" || state === "incomplete" || state === "active") return false;
-		}
-	}
-	return true;
-}
-/**
-* Compute the progress state for a field.
-*/
-function computeFieldState(field, value, issueCount) {
-	if (!isFieldSubmitted(field, value)) return "empty";
-	if (issueCount > 0) return "invalid";
-	if (field.kind === "checkboxes" && value?.kind === "checkboxes") {
-		if (!isCheckboxesComplete(field, value)) return "incomplete";
-	}
-	return "complete";
+function isFieldEmpty(field, value) {
+	return !isFieldSubmitted(field, value);
 }
 /**
 * Compute progress for a single field.
 */
-function computeFieldProgress(field, value, issues) {
-	const issueCount = issues.filter((i) => i.ref === field.id).length;
-	const submitted = isFieldSubmitted(field, value);
-	const valid = issueCount === 0;
-	const state = computeFieldState(field, value, issueCount);
+function computeFieldProgress(field, response, notes, issues) {
+	const fieldIssues = issues.filter((i) => i.ref === field.id);
+	const issueCount = fieldIssues.length;
+	const value = response.value;
+	const empty = isFieldEmpty(field, value);
+	let valid = true;
+	if (response.state === "skipped" || response.state === "aborted") valid = issueCount === 0;
+	else if (empty) valid = fieldIssues.filter((i) => i.reason !== "required_missing").length === 0;
+	else valid = issueCount === 0;
+	const fieldNotes = notes.filter((n) => n.ref === field.id);
+	const hasNotes = fieldNotes.length > 0;
+	const noteCount = fieldNotes.length;
 	const progress = {
 		kind: field.kind,
 		required: field.required,
-		submitted,
-		state,
+		answerState: response.state,
+		hasNotes,
+		noteCount,
+		empty,
 		valid,
 		issueCount
 	};
@@ -1000,34 +1078,42 @@ function computeFieldProgress(field, value, issues) {
 * Compute a progress summary for a form.
 *
 * @param schema - The form schema
-* @param values - Current field values
+* @param responsesByFieldId - Current field responses (state + optional value)
+* @param notes - Notes attached to fields/groups/form
 * @param issues - Validation issues (from inspect)
 * @returns Progress summary with field states and counts
 */
-function computeProgressSummary(schema, values, issues) {
+function computeProgressSummary(schema, responsesByFieldId, notes, issues) {
 	const fields = {};
 	const counts = {
 		totalFields: 0,
 		requiredFields: 0,
-		submittedFields: 0,
-		completeFields: 0,
-		incompleteFields: 0,
+		unansweredFields: 0,
+		answeredFields: 0,
+		skippedFields: 0,
+		abortedFields: 0,
+		validFields: 0,
 		invalidFields: 0,
+		emptyFields: 0,
+		filledFields: 0,
 		emptyRequiredFields: 0,
-		emptyOptionalFields: 0
+		totalNotes: notes.length
 	};
 	for (const group of schema.groups) for (const field of group.children) {
-		const value = values[field.id];
-		const progress = computeFieldProgress(field, value, issues);
+		const progress = computeFieldProgress(field, responsesByFieldId[field.id] ?? { state: "unanswered" }, notes, issues);
 		fields[field.id] = progress;
 		counts.totalFields++;
 		if (progress.required) counts.requiredFields++;
-		if (progress.submitted) counts.submittedFields++;
-		if (progress.state === "complete") counts.completeFields++;
-		if (progress.state === "incomplete") counts.incompleteFields++;
-		if (progress.state === "invalid") counts.invalidFields++;
-		if (progress.state === "empty") if (progress.required) counts.emptyRequiredFields++;
-		else counts.emptyOptionalFields++;
+		if (progress.answerState === "answered") counts.answeredFields++;
+		else if (progress.answerState === "skipped") counts.skippedFields++;
+		else if (progress.answerState === "aborted") counts.abortedFields++;
+		else if (progress.answerState === "unanswered") counts.unansweredFields++;
+		if (progress.valid) counts.validFields++;
+		else counts.invalidFields++;
+		if (progress.empty) {
+			counts.emptyFields++;
+			if (progress.required) counts.emptyRequiredFields++;
+		} else counts.filledFields++;
 	}
 	return {
 		counts,
@@ -1041,32 +1127,47 @@ function computeProgressSummary(schema, values, issues) {
 * @returns The overall form state
 */
 function computeFormState(progress) {
+	if (progress.counts.abortedFields > 0) return "invalid";
 	if (progress.counts.invalidFields > 0) return "invalid";
-	if (progress.counts.incompleteFields > 0) return "incomplete";
 	if (progress.counts.emptyRequiredFields === 0) return "complete";
-	if (progress.counts.submittedFields > 0) return "incomplete";
+	if (progress.counts.answeredFields > 0) return "incomplete";
 	return "empty";
 }
 /**
 * Determine if the form is complete (ready for submission).
 *
+* A form is complete when:
+* 1. No aborted fields (aborted fields block completion)
+* 2. No required fields are empty
+* 3. No fields have validation errors
+* 4. No fields are in incomplete state (e.g., partial checkbox completion)
+* 5. All fields must be addressed (answered + skipped == total)
+*
+* Every field must be explicitly addressed - either filled with a value or
+* skipped with a reason. This ensures agents fully process all fields.
+*
 * @param progress - The progress summary
 * @returns True if the form is complete
 */
 function isFormComplete(progress) {
-	return progress.counts.invalidFields === 0 && progress.counts.incompleteFields === 0 && progress.counts.emptyRequiredFields === 0;
+	const { counts } = progress;
+	if (counts.abortedFields > 0) return false;
+	const baseComplete = counts.invalidFields === 0 && counts.emptyRequiredFields === 0;
+	const allFieldsAccountedFor = counts.answeredFields + counts.skippedFields === counts.totalFields;
+	return baseComplete && allFieldsAccountedFor;
 }
 /**
 * Compute all summaries for a parsed form.
 *
 * @param schema - The form schema
-* @param values - Current field values
+* @param responsesByFieldId - Current field responses (state + optional value)
+* @param notes - Notes attached to fields/groups/form
 * @param issues - Validation issues
 * @returns All computed summaries
 */
-function computeAllSummaries(schema, values, issues) {
+function computeAllSummaries(schema, responsesByFieldId, notes, issues) {
 	const structureSummary = computeStructureSummary(schema);
-	const progressSummary = computeProgressSummary(schema, values, issues);
+	const progressSummary = computeProgressSummary(schema, responsesByFieldId, notes, issues);
 	return {
 		structureSummary,
 		progressSummary,
@@ -1332,10 +1433,195 @@ function validateCheckboxesField(field, value) {
 	return issues;
 }
 /**
+* Check if a string is a valid URL.
+* Uses URL constructor for validation (RFC 3986 compliant).
+*/
+function isValidUrl(str) {
+	try {
+		const url = new URL(str);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+/**
+* Validate a URL field.
+*/
+function validateUrlField(field, value) {
+	const issues = [];
+	const urlValue = value?.value ?? null;
+	if (field.required && (urlValue === null || urlValue.trim() === "")) {
+		issues.push({
+			severity: "error",
+			message: `Required field "${field.label}" is empty`,
+			ref: field.id,
+			source: "builtin"
+		});
+		return issues;
+	}
+	if (urlValue === null || urlValue === "") return issues;
+	if (!isValidUrl(urlValue)) issues.push({
+		severity: "error",
+		message: `"${field.label}" is not a valid URL`,
+		ref: field.id,
+		source: "builtin"
+	});
+	return issues;
+}
+/**
+* Validate a URL list field.
+*/
+function validateUrlListField(field, value) {
+	const issues = [];
+	const items = value?.items ?? [];
+	if (field.required && items.length === 0) {
+		issues.push({
+			severity: "error",
+			message: `Required field "${field.label}" is empty`,
+			ref: field.id,
+			source: "builtin"
+		});
+		return issues;
+	}
+	if (items.length === 0) return issues;
+	if (field.minItems !== void 0 && items.length < field.minItems) issues.push({
+		severity: "error",
+		message: `"${field.label}" must have at least ${field.minItems} items (got ${items.length})`,
+		ref: field.id,
+		source: "builtin"
+	});
+	if (field.maxItems !== void 0 && items.length > field.maxItems) issues.push({
+		severity: "error",
+		message: `"${field.label}" must have at most ${field.maxItems} items (got ${items.length})`,
+		ref: field.id,
+		source: "builtin"
+	});
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		if (item !== void 0 && !isValidUrl(item)) issues.push({
+			severity: "error",
+			message: `Item ${i + 1} in "${field.label}" is not a valid URL`,
+			ref: field.id,
+			source: "builtin"
+		});
+	}
+	if (field.uniqueItems) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const item of items) {
+			if (seen.has(item)) {
+				issues.push({
+					severity: "error",
+					message: `Duplicate URL "${item}" in "${field.label}"`,
+					ref: field.id,
+					source: "builtin"
+				});
+				break;
+			}
+			seen.add(item);
+		}
+	}
+	return issues;
+}
+/**
+* Check if a string is a valid ISO 8601 date (YYYY-MM-DD).
+*/
+function isValidDate(str) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(str)) return false;
+	const date = new Date(str);
+	if (Number.isNaN(date.getTime())) return false;
+	const [year, month, day] = str.split("-").map(Number);
+	return date.getUTCFullYear() === year && date.getUTCMonth() === (month ?? 0) - 1 && date.getUTCDate() === day;
+}
+/**
+* Parse a date string to compare for min/max validation.
+* Returns date value or null if invalid.
+*/
+function parseDateForComparison(str) {
+	if (!isValidDate(str)) return null;
+	return new Date(str).getTime();
+}
+/**
+* Validate a date field.
+*/
+function validateDateField(field, value) {
+	const issues = [];
+	const dateValue = value?.value ?? null;
+	if (field.required && (dateValue === null || dateValue.trim() === "")) {
+		issues.push({
+			severity: "error",
+			message: `Required field "${field.label}" is empty`,
+			ref: field.id,
+			source: "builtin"
+		});
+		return issues;
+	}
+	if (dateValue === null || dateValue === "") return issues;
+	if (!isValidDate(dateValue)) {
+		issues.push({
+			severity: "error",
+			message: `"${field.label}" is not a valid date (expected YYYY-MM-DD)`,
+			ref: field.id,
+			source: "builtin"
+		});
+		return issues;
+	}
+	const dateTime = parseDateForComparison(dateValue);
+	if (field.min !== void 0) {
+		const minTime = parseDateForComparison(field.min);
+		if (minTime !== null && dateTime !== null && dateTime < minTime) issues.push({
+			severity: "error",
+			message: `"${field.label}" must be on or after ${field.min} (got ${dateValue})`,
+			ref: field.id,
+			source: "builtin"
+		});
+	}
+	if (field.max !== void 0) {
+		const maxTime = parseDateForComparison(field.max);
+		if (maxTime !== null && dateTime !== null && dateTime > maxTime) issues.push({
+			severity: "error",
+			message: `"${field.label}" must be on or before ${field.max} (got ${dateValue})`,
+			ref: field.id,
+			source: "builtin"
+		});
+	}
+	return issues;
+}
+/**
+* Validate a year field.
+*/
+function validateYearField(field, value) {
+	const issues = [];
+	const yearValue = value?.value ?? null;
+	if (field.required && yearValue === null) {
+		issues.push({
+			severity: "error",
+			message: `Required field "${field.label}" is empty`,
+			ref: field.id,
+			source: "builtin"
+		});
+		return issues;
+	}
+	if (yearValue === null) return issues;
+	if (field.min !== void 0 && yearValue < field.min) issues.push({
+		severity: "error",
+		message: `"${field.label}" must be at least ${field.min} (got ${yearValue})`,
+		ref: field.id,
+		source: "builtin"
+	});
+	if (field.max !== void 0 && yearValue > field.max) issues.push({
+		severity: "error",
+		message: `"${field.label}" must be at most ${field.max} (got ${yearValue})`,
+		ref: field.id,
+		source: "builtin"
+	});
+	return issues;
+}
+/**
 * Validate a single field.
 */
-function validateField(field, values) {
-	const value = values[field.id];
+function validateField(field, responses) {
+	const response = responses[field.id];
+	const value = response?.state === "answered" ? response.value : void 0;
 	switch (field.kind) {
 		case "string": return validateStringField(field, value);
 		case "number": return validateNumberField(field, value);
@@ -1343,6 +1629,10 @@ function validateField(field, values) {
 		case "single_select": return validateSingleSelectField(field, value);
 		case "multi_select": return validateMultiSelectField(field, value);
 		case "checkboxes": return validateCheckboxesField(field, value);
+		case "url": return validateUrlField(field, value);
+		case "url_list": return validateUrlListField(field, value);
+		case "date": return validateDateField(field, value);
+		case "year": return validateYearField(field, value);
 	}
 }
 /**
@@ -1362,10 +1652,12 @@ function parseValidatorRef(ref) {
 /**
 * Run code validators for a field.
 */
-function runCodeValidators(field, schema, values, registry) {
+function runCodeValidators(field, schema, responses, registry) {
 	if (!field.validate) return [];
 	const refs = Array.isArray(field.validate) ? field.validate : [field.validate];
 	const issues = [];
+	const values = {};
+	for (const [id, response] of Object.entries(responses)) if (response.state === "answered" && response.value !== void 0) values[id] = response.value;
 	for (const ref of refs) {
 		const { id, params } = parseValidatorRef(ref);
 		const validator = registry[id];
@@ -1404,10 +1696,12 @@ function runCodeValidators(field, schema, values, registry) {
 /**
 * Run code validators for a field group.
 */
-function runGroupValidators(group, schema, values, registry) {
+function runGroupValidators(group, schema, responses, registry) {
 	if (!group.validate) return [];
 	const refs = Array.isArray(group.validate) ? group.validate : [group.validate];
 	const issues = [];
+	const values = {};
+	for (const [id, response] of Object.entries(responses)) if (response.state === "answered" && response.value !== void 0) values[id] = response.value;
 	for (const ref of refs) {
 		const { id, params } = parseValidatorRef(ref);
 		const validator = registry[id];
@@ -1455,10 +1749,10 @@ function validate(form, opts) {
 	const registry = opts?.validatorRegistry ?? {};
 	for (const group of form.schema.groups) {
 		for (const field of group.children) {
-			issues.push(...validateField(field, form.valuesByFieldId));
-			if (!opts?.skipCodeValidators) issues.push(...runCodeValidators(field, form.schema, form.valuesByFieldId, registry));
+			issues.push(...validateField(field, form.responsesByFieldId));
+			if (!opts?.skipCodeValidators) issues.push(...runCodeValidators(field, form.schema, form.responsesByFieldId, registry));
 		}
-		if (!opts?.skipCodeValidators) issues.push(...runGroupValidators(group, form.schema, form.valuesByFieldId, registry));
+		if (!opts?.skipCodeValidators) issues.push(...runGroupValidators(group, form.schema, form.responsesByFieldId, registry));
 	}
 	return {
 		issues,
@@ -1485,14 +1779,14 @@ function validate(form, opts) {
 function inspect(form, options = {}) {
 	const validationInspectIssues = convertValidationIssues(validate(form, { skipCodeValidators: options.skipCodeValidators }).issues, form);
 	const structureSummary = computeStructureSummary(form.schema);
-	const progressSummary = computeProgressSummary(form.schema, form.valuesByFieldId, validationInspectIssues);
+	const progressSummary = computeProgressSummary(form.schema, form.responsesByFieldId, form.notes, validationInspectIssues);
 	const formState = computeFormState(progressSummary);
-	const filteredIssues = filterIssuesByRole(sortAndAssignPriorities(addOptionalEmptyIssues(validationInspectIssues, form, progressSummary.fields), form), form, options.targetRoles);
+	const issues = filterIssuesByRole(sortAndAssignPriorities(addOptionalEmptyIssues(validationInspectIssues, form, progressSummary.fields), form), form, options.targetRoles);
 	return {
 		structureSummary,
 		progressSummary,
-		issues: filteredIssues,
-		isComplete: !filteredIssues.some((i) => i.severity === "required"),
+		issues,
+		isComplete: issues.length === 0,
 		formState
 	};
 }
@@ -1511,26 +1805,31 @@ function convertValidationIssues(validationIssues, form) {
 }
 /**
 * Add issues for empty optional fields that don't already have issues.
+* Fields that have been explicitly skipped do not get optional_empty issues.
 */
 function addOptionalEmptyIssues(existingIssues, form, fieldProgress) {
 	const issues = [...existingIssues];
 	const fieldsWithIssues = new Set(existingIssues.map((i) => i.ref));
-	for (const [fieldId, progress] of Object.entries(fieldProgress)) if (progress.state === "empty" && !fieldsWithIssues.has(fieldId) && !isRequiredField(fieldId, form)) issues.push({
-		ref: fieldId,
-		scope: "field",
-		reason: "optional_empty",
-		message: "Optional field has no value",
-		severity: "recommended",
-		priority: 0
-	});
+	for (const [fieldId, progress] of Object.entries(fieldProgress)) {
+		if (progress.answerState === "skipped" || progress.answerState === "aborted") continue;
+		if (progress.empty && !fieldsWithIssues.has(fieldId) && !isRequiredField(fieldId, form)) issues.push({
+			ref: fieldId,
+			scope: "field",
+			reason: "optional_empty",
+			message: "Optional field has no value",
+			severity: "recommended",
+			priority: 0
+		});
+	}
 	return issues;
 }
 /**
 * Map ValidationIssue to InspectIssue reason code.
 */
 function mapValidationToInspectReason(vi) {
-	if (vi.code === "REQUIRED_EMPTY" || vi.message.toLowerCase().includes("required") && vi.message.toLowerCase().includes("empty")) return "required_missing";
-	if (vi.code === "INVALID_CHECKBOX_STATE" || vi.code === "CHECKBOXES_INCOMPLETE" || vi.message.toLowerCase().includes("checkbox")) return "checkbox_incomplete";
+	const msg = vi.message.toLowerCase();
+	if (vi.code === "REQUIRED_EMPTY" || msg.includes("required") && msg.includes("empty") || msg.includes("required") && msg.includes("no selection") || msg.includes("required") && msg.includes("no selections") || msg.includes("must be answered") || msg.includes("must be completed") || msg.includes("must be checked")) return "required_missing";
+	if (vi.code === "INVALID_CHECKBOX_STATE" || vi.code === "CHECKBOXES_INCOMPLETE" || msg.includes("checkbox")) return "checkbox_incomplete";
 	if (vi.code === "MULTI_SELECT_TOO_FEW" || vi.code === "STRING_LIST_MIN_ITEMS" || vi.message.includes("at least")) return "min_items_not_met";
 	return "validation_error";
 }
@@ -1672,7 +1971,9 @@ function isCheckboxComplete(form, fieldId) {
 	const field = findFieldById(form, fieldId);
 	if (field?.kind !== "checkboxes") return true;
 	const checkboxField = field;
-	const value = form.valuesByFieldId[fieldId];
+	const response = form.responsesByFieldId[fieldId];
+	if (response?.state !== "answered") return false;
+	const value = response.value;
 	if (value?.kind !== "checkboxes") return false;
 	const values = value.values;
 	const optionIds = checkboxField.options.map((o) => o.id);
@@ -1748,10 +2049,25 @@ function findField(form, fieldId) {
 * Validate a single patch against the form schema.
 */
 function validatePatch(form, patch, index) {
-	const field = findField(form, patch.fieldId);
+	if (patch.op === "add_note") {
+		if (!form.idIndex.has(patch.ref)) return {
+			patchIndex: index,
+			message: `Reference "${patch.ref}" not found in form`
+		};
+		return null;
+	}
+	if (patch.op === "remove_note") {
+		if (!form.notes.some((n) => n.id === patch.noteId)) return {
+			patchIndex: index,
+			message: `Note with id '${patch.noteId}' not found`
+		};
+		return null;
+	}
+	const fieldId = patch.fieldId;
+	const field = findField(form, fieldId);
 	if (!field) return {
 		patchIndex: index,
-		message: `Field "${patch.fieldId}" not found`
+		message: `Field "${fieldId}" not found`
 	};
 	switch (patch.op) {
 		case "set_string":
@@ -1812,7 +2128,38 @@ function validatePatch(form, patch, index) {
 			};
 			break;
 		}
+		case "set_url":
+			if (field.kind !== "url") return {
+				patchIndex: index,
+				message: `Cannot apply set_url to ${field.kind} field "${field.id}"`
+			};
+			break;
+		case "set_url_list":
+			if (field.kind !== "url_list") return {
+				patchIndex: index,
+				message: `Cannot apply set_url_list to ${field.kind} field "${field.id}"`
+			};
+			break;
+		case "set_date":
+			if (field.kind !== "date") return {
+				patchIndex: index,
+				message: `Cannot apply set_date to ${field.kind} field "${field.id}"`
+			};
+			break;
+		case "set_year":
+			if (field.kind !== "year") return {
+				patchIndex: index,
+				message: `Cannot apply set_year to ${field.kind} field "${field.id}"`
+			};
+			break;
 		case "clear_field": break;
+		case "skip_field":
+			if (field.required) return {
+				patchIndex: index,
+				message: `Cannot skip required field "${field.id}"`
+			};
+			break;
+		case "abort_field": break;
 	}
 	return null;
 }
@@ -1831,133 +2178,234 @@ function validatePatches(form, patches) {
 	return errors;
 }
 /**
+* Generate a unique note ID for the form.
+*/
+function generateNoteId(form) {
+	const existingIds = new Set(form.notes.map((n) => n.id));
+	let counter = 1;
+	while (existingIds.has(`n${counter}`)) counter++;
+	return `n${counter}`;
+}
+/**
 * Apply a set_string patch.
 */
-function applySetString(values, patch) {
-	values[patch.fieldId] = {
-		kind: "string",
-		value: patch.value
+function applySetString(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "string",
+			value: patch.value
+		}
 	};
 }
 /**
 * Apply a set_number patch.
 */
-function applySetNumber(values, patch) {
-	values[patch.fieldId] = {
-		kind: "number",
-		value: patch.value
+function applySetNumber(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "number",
+			value: patch.value
+		}
 	};
 }
 /**
 * Apply a set_string_list patch.
 */
-function applySetStringList(values, patch) {
-	values[patch.fieldId] = {
-		kind: "string_list",
-		items: patch.items
+function applySetStringList(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "string_list",
+			items: patch.items
+		}
 	};
 }
 /**
 * Apply a set_single_select patch.
 */
-function applySetSingleSelect(values, patch) {
-	values[patch.fieldId] = {
-		kind: "single_select",
-		selected: patch.selected
+function applySetSingleSelect(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "single_select",
+			selected: patch.selected
+		}
 	};
 }
 /**
 * Apply a set_multi_select patch.
 */
-function applySetMultiSelect(values, patch) {
-	values[patch.fieldId] = {
-		kind: "multi_select",
-		selected: patch.selected
+function applySetMultiSelect(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "multi_select",
+			selected: patch.selected
+		}
 	};
 }
 /**
 * Apply a set_checkboxes patch (merges with existing values).
 */
-function applySetCheckboxes(values, patch) {
+function applySetCheckboxes(responses, patch) {
 	const merged = {
-		...values[patch.fieldId]?.values ?? {},
+		...(responses[patch.fieldId]?.value)?.values ?? {},
 		...patch.values
 	};
-	values[patch.fieldId] = {
-		kind: "checkboxes",
-		values: merged
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "checkboxes",
+			values: merged
+		}
+	};
+}
+/**
+* Apply a set_url patch.
+*/
+function applySetUrl(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "url",
+			value: patch.value
+		}
+	};
+}
+/**
+* Apply a set_url_list patch.
+*/
+function applySetUrlList(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "url_list",
+			items: patch.items
+		}
+	};
+}
+/**
+* Apply a set_date patch.
+*/
+function applySetDate(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "date",
+			value: patch.value
+		}
+	};
+}
+/**
+* Apply a set_year patch.
+*/
+function applySetYear(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "answered",
+		value: {
+			kind: "year",
+			value: patch.value
+		}
 	};
 }
 /**
 * Apply a clear_field patch.
 */
-function applyClearField(form, values, patch) {
-	const field = findField(form, patch.fieldId);
-	if (!field) return;
-	switch (field.kind) {
-		case "string":
-			values[patch.fieldId] = {
-				kind: "string",
-				value: null
-			};
-			break;
-		case "number":
-			values[patch.fieldId] = {
-				kind: "number",
-				value: null
-			};
-			break;
-		case "string_list":
-			values[patch.fieldId] = {
-				kind: "string_list",
-				items: []
-			};
-			break;
-		case "single_select":
-			values[patch.fieldId] = {
-				kind: "single_select",
-				selected: null
-			};
-			break;
-		case "multi_select":
-			values[patch.fieldId] = {
-				kind: "multi_select",
-				selected: []
-			};
-			break;
-		case "checkboxes":
-			values[patch.fieldId] = {
-				kind: "checkboxes",
-				values: {}
-			};
-			break;
-	}
+function applyClearField(responses, patch) {
+	responses[patch.fieldId] = { state: "unanswered" };
 }
 /**
-* Apply a single patch to the values.
+* Apply a skip_field patch.
+* Marks the field as skipped and stores reason in FieldResponse.reason.
 */
-function applyPatch(form, values, patch) {
+function applySkipField(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "skipped",
+		...patch.reason && { reason: patch.reason }
+	};
+}
+/**
+* Apply an abort_field patch.
+* Marks the field as aborted and stores reason in FieldResponse.reason.
+*/
+function applyAbortField(responses, patch) {
+	responses[patch.fieldId] = {
+		state: "aborted",
+		...patch.reason && { reason: patch.reason }
+	};
+}
+/**
+* Apply an add_note patch.
+* Adds a note to the form.
+*/
+function applyAddNote(form, patch) {
+	const noteId = generateNoteId(form);
+	form.notes.push({
+		id: noteId,
+		ref: patch.ref,
+		role: patch.role,
+		text: patch.text
+	});
+}
+/**
+* Apply a remove_note patch.
+* Removes a specific note by ID.
+*/
+function applyRemoveNote(form, patch) {
+	const index = form.notes.findIndex((n) => n.id === patch.noteId);
+	if (index >= 0) form.notes.splice(index, 1);
+}
+/**
+* Apply a single patch to the form.
+*/
+function applyPatch(form, responses, patch) {
 	switch (patch.op) {
 		case "set_string":
-			applySetString(values, patch);
+			applySetString(responses, patch);
 			break;
 		case "set_number":
-			applySetNumber(values, patch);
+			applySetNumber(responses, patch);
 			break;
 		case "set_string_list":
-			applySetStringList(values, patch);
+			applySetStringList(responses, patch);
 			break;
 		case "set_single_select":
-			applySetSingleSelect(values, patch);
+			applySetSingleSelect(responses, patch);
 			break;
 		case "set_multi_select":
-			applySetMultiSelect(values, patch);
+			applySetMultiSelect(responses, patch);
 			break;
 		case "set_checkboxes":
-			applySetCheckboxes(values, patch);
+			applySetCheckboxes(responses, patch);
+			break;
+		case "set_url":
+			applySetUrl(responses, patch);
+			break;
+		case "set_url_list":
+			applySetUrlList(responses, patch);
+			break;
+		case "set_date":
+			applySetDate(responses, patch);
+			break;
+		case "set_year":
+			applySetYear(responses, patch);
 			break;
 		case "clear_field":
-			applyClearField(form, values, patch);
+			applyClearField(responses, patch);
+			break;
+		case "skip_field":
+			applySkipField(responses, patch);
+			break;
+		case "abort_field":
+			applyAbortField(responses, patch);
+			break;
+		case "add_note":
+			applyAddNote(form, patch);
+			break;
+		case "remove_note":
+			applyRemoveNote(form, patch);
 			break;
 	}
 }
@@ -1989,8 +2437,8 @@ function convertToInspectIssues(form) {
 */
 function applyPatches(form, patches) {
 	if (validatePatches(form, patches).length > 0) {
-		const summaries$1 = computeAllSummaries(form.schema, form.valuesByFieldId, []);
 		const issues$1 = convertToInspectIssues(form);
+		const summaries$1 = computeAllSummaries(form.schema, form.responsesByFieldId, form.notes, issues$1);
 		return {
 			applyStatus: "rejected",
 			structureSummary: summaries$1.structureSummary,
@@ -2000,11 +2448,14 @@ function applyPatches(form, patches) {
 			formState: summaries$1.formState
 		};
 	}
-	const newValues = { ...form.valuesByFieldId };
-	for (const patch of patches) applyPatch(form, newValues, patch);
-	form.valuesByFieldId = newValues;
+	const newResponses = { ...form.responsesByFieldId };
+	const newNotes = [...form.notes];
+	form.notes;
+	form.notes = newNotes;
+	for (const patch of patches) applyPatch(form, newResponses, patch);
+	form.responsesByFieldId = newResponses;
 	const issues = convertToInspectIssues(form);
-	const summaries = computeAllSummaries(form.schema, newValues, issues);
+	const summaries = computeAllSummaries(form.schema, newResponses, newNotes, issues);
 	return {
 		applyStatus: "applied",
 		structureSummary: summaries.structureSummary,
@@ -2016,4 +2467,4 @@ function applyPatches(form, patches) {
 }
 
 //#endregion
-export { PatchSchema as $, DocumentationBlockSchema as A, IdSchema as B, ApplyResultSchema as C, StructureSummarySchema as Ct, CheckboxesFieldSchema as D, CheckboxValueSchema as E, FieldProgressSchema as F, MarkformFrontmatterSchema as G, InspectResultSchema as H, FieldSchema as I, MultiSelectValueSchema as J, MultiCheckboxStateSchema as K, FieldValueSchema as L, ExplicitCheckboxValueSchema as M, FieldGroupSchema as N, CheckboxesValueSchema as O, FieldKindSchema as P, OptionSchema as Q, FormSchemaSchema as R, parseRolesFlag as S, StringValueSchema as St, CheckboxProgressCountsSchema as T, ValidatorRefSchema as Tt, IssueReasonSchema as U, InspectIssueSchema as V, IssueScopeSchema as W, NumberValueSchema as X, NumberFieldSchema as Y, OptionIdSchema as Z, DEFAULT_PRIORITY as _, SourceRangeSchema as _t, computeAllSummaries as a, SessionTurnSchema as at, USER_ROLE as b, StringListFieldSchema as bt, computeStructureSummary as c, SetNumberPatchSchema as ct, serializeRawMarkdown as d, SetStringPatchSchema as dt, ProgressCountsSchema as et, AGENT_ROLE as f, SeveritySchema as ft, DEFAULT_PORT as g, SourcePositionSchema as gt, DEFAULT_MAX_TURNS as h, SingleSelectValueSchema as ht, validate as i, SessionTranscriptSchema as it, DocumentationTagSchema as j, ClearFieldPatchSchema as k, isFormComplete as l, SetSingleSelectPatchSchema as lt, DEFAULT_MAX_PATCHES_PER_TURN as m, SingleSelectFieldSchema as mt, getFieldsForRoles as n, ProgressSummarySchema as nt, computeFormState as o, SetCheckboxesPatchSchema as ot, DEFAULT_MAX_ISSUES as p, SimpleCheckboxStateSchema as pt, MultiSelectFieldSchema as q, inspect as r, SessionFinalSchema as rt, computeProgressSummary as s, SetMultiSelectPatchSchema as st, applyPatches as t, ProgressStateSchema as tt, serialize as u, SetStringListPatchSchema as ut, DEFAULT_ROLE_INSTRUCTIONS as v, StepResultSchema as vt, CheckboxModeSchema as w, ValidationIssueSchema as wt, formatSuggestedLlms as x, StringListValueSchema as xt, SUGGESTED_LLMS as y, StringFieldSchema as yt, HarnessConfigSchema as z };
+export { SUGGESTED_LLMS as A, DEFAULT_ROLE_INSTRUCTIONS as C, detectFileType as D, deriveExportPath as E, formatSuggestedLlms as M, getWebSearchConfig as N, getFormsDir as O, hasWebSearchSupport as P, DEFAULT_ROLES as S, USER_ROLE as T, DEFAULT_MAX_TURNS as _, computeAllSummaries as a, DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN as b, computeStructureSummary as c, serializeRawMarkdown as d, serializeReportMarkdown as f, DEFAULT_MAX_PATCHES_PER_TURN as g, DEFAULT_MAX_ISSUES_PER_TURN as h, validate as i, WEB_SEARCH_CONFIG as j, parseRolesFlag as k, isFormComplete as l, DEFAULT_FORMS_DIR as m, getFieldsForRoles as n, computeFormState as o, AGENT_ROLE as p, inspect as r, computeProgressSummary as s, applyPatches as t, serialize as u, DEFAULT_PORT as v, REPORT_EXTENSION as w, DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN as x, DEFAULT_PRIORITY as y };