markform 0.1.20 → 0.1.22

package/dist/{src-wR7GoftB.mjs → src-CbRnGzMK.mjs}

@@ -1,6 +1,6 @@
 
-import { L as PatchSchema, R as ProgressCountsSchema, V as RunModeSchema, pt as StructureSummarySchema } from "./coreTypes-CPKXf2dc.mjs";
-import { A as parseOptionText, B as DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN, C as extractTableContent, D as getStringAttr, E as getStringArrayAttr, F as DEFAULT_MAX_PATCHES_PER_TURN, H as DEFAULT_ROLES, I as DEFAULT_MAX_STEPS_PER_TURN, L as DEFAULT_MAX_TURNS, N as DEFAULT_MAX_ISSUES_PER_TURN, O as getValidateAttr, P as DEFAULT_MAX_PARALLEL_AGENTS, S as extractOptionItems, T as getNumberAttr, U as DEFAULT_ROLE_INSTRUCTIONS, V as DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN, _ as preprocessCommentSyntax, b as CHECKBOX_MARKERS, c as computeProgressSummary, d as serializeForm, g as detectSyntaxStyle, i as inspect, j as AGENT_ROLE, k as isTagNode, l as computeStructureSummary, lt as MarkformParseError, nt as getWebSearchConfig, ot as MarkformConfigError, r as getFieldsForRoles, t as applyPatches, w as getBooleanAttr, x as extractFenceValue, y as tryParseSentinelResponse, z as DEFAULT_PRIORITY } from "./apply-DIvm1b1s.mjs";
+import { A as MarkformSectionInputSchema, R as PatchSchema, mt as StructureSummarySchema, z as ProgressCountsSchema } from "./coreTypes-CTLr-NGd.mjs";
+import { B as DEFAULT_ROLES, C as getNumberAttr, D as isTagNode, E as getValidateAttr, F as DEFAULT_MAX_TURNS, L as DEFAULT_PRIORITY, M as DEFAULT_MAX_PARALLEL_AGENTS, N as DEFAULT_MAX_PATCHES_PER_TURN, O as parseOptionText, P as DEFAULT_MAX_STEPS_PER_TURN, R as DEFAULT_RESEARCH_MAX_ISSUES_PER_TURN, S as getBooleanAttr, T as getStringAttr, V as DEFAULT_ROLE_INSTRUCTIONS, Z as transformHarnessConfigToTs, _ as tryParseSentinelResponse, at as MarkformConfigError, b as extractOptionItems, bt as wrapApiError, c as computeProgressSummary, ct as MarkformParseError, d as serializeForm, h as preprocessCommentSyntax, i as inspect, j as DEFAULT_MAX_ISSUES_PER_TURN, k as AGENT_ROLE, l as computeStructureSummary, m as detectSyntaxStyle, r as getFieldsForRoles, t as applyPatches, tt as getWebSearchConfig, v as CHECKBOX_MARKERS, w as getStringArrayAttr, x as extractTableContent, y as extractFenceValue, z as DEFAULT_RESEARCH_MAX_PATCHES_PER_TURN } from "./apply-C7mO7VkZ.mjs";
 import { z } from "zod";
 import Markdoc from "@markdoc/markdoc";
 import YAML from "yaml";
@@ -1214,58 +1214,42 @@ const VALID_FORM_TAGS = new Set([
 	"documentation"
 ]);
 /**
-* Parse harness configuration from frontmatter.
-* YAML keys must be snake_case; they are mapped to camelCase internally.
-* Unrecognized keys produce a parse error.
+* Format Zod validation errors for user-friendly display.
 */
-function parseHarnessConfig(raw) {
-	if (!raw || typeof raw !== "object") return;
-	const config = raw;
-	const result = {};
-	const keyMap = {
-		max_turns: "maxTurns",
-		max_patches_per_turn: "maxPatchesPerTurn",
-		max_issues_per_turn: "maxIssuesPerTurn",
-		max_parallel_agents: "maxParallelAgents"
-	};
-	for (const [key, value] of Object.entries(config)) {
-		const camelKey = keyMap[key];
-		if (!camelKey) throw new MarkformParseError(`Unknown harness config key '${key}'. Valid keys: ${Object.keys(keyMap).join(", ")}`);
-		if (typeof value !== "number") throw new MarkformParseError(`Harness config key '${key}' must be a number, got ${typeof value}`);
-		result[camelKey] = value;
-	}
-	return Object.keys(result).length > 0 ? result : void 0;
+function formatZodError(error) {
+	return error.issues.map((issue) => {
+		const path = issue.path.map(String).join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	}).join("; ");
 }
 /**
 * Extract YAML frontmatter from Markdoc AST.
 * Uses Markdoc's native frontmatter extraction and parses the YAML.
+* Validates the markform section using Zod schema.
 */
 function extractFrontmatter(ast) {
 	const rawFrontmatter = ast.attributes.frontmatter;
 	if (!rawFrontmatter) return { frontmatter: {} };
 	try {
 		const frontmatter = YAML.parse(rawFrontmatter) ?? {};
-		const markformSection = frontmatter.markform;
-		if (!markformSection) return { frontmatter };
-		const harnessConfig = parseHarnessConfig(markformSection.harness);
-		let runMode;
-		const rawRunMode = markformSection.run_mode;
-		if (rawRunMode !== void 0) {
-			const parsed = RunModeSchema.safeParse(rawRunMode);
-			if (!parsed.success) throw new MarkformParseError(`Invalid run_mode: '${typeof rawRunMode === "string" ? rawRunMode : JSON.stringify(rawRunMode)}'. Must be one of: interactive, fill, research`);
-			runMode = parsed.data;
-		}
-		const description = typeof markformSection.description === "string" ? markformSection.description : void 0;
+		const rawMarkformSection = frontmatter.markform;
+		if (!rawMarkformSection) return { frontmatter };
+		const validationResult = MarkformSectionInputSchema.safeParse(rawMarkformSection);
+		if (!validationResult.success) throw new MarkformParseError(`Invalid markform frontmatter: ${formatZodError(validationResult.error)}`);
+		const markformSection = validationResult.data;
+		const harnessConfig = markformSection.harness && Object.keys(markformSection.harness).length > 0 ? transformHarnessConfigToTs(markformSection.harness) : void 0;
 		return {
 			frontmatter,
 			metadata: {
 				markformVersion: markformSection.spec ?? "MF/0.1",
-				roles: frontmatter.roles ?? [...DEFAULT_ROLES],
-				roleInstructions: frontmatter.role_instructions ?? DEFAULT_ROLE_INSTRUCTIONS,
+				...markformSection.title && { title: markformSection.title },
+				...markformSection.description && { description: markformSection.description },
+				roles: markformSection.roles ?? frontmatter.roles ?? [...DEFAULT_ROLES],
+				roleInstructions: markformSection.role_instructions ?? frontmatter.role_instructions ?? DEFAULT_ROLE_INSTRUCTIONS,
 				...harnessConfig && { harnessConfig },
-				...runMode && { runMode }
+				...markformSection.run_mode && { runMode: markformSection.run_mode }
 			},
-			description
+			description: markformSection.description
 		};
 	} catch (error) {
 		if (error instanceof MarkformParseError) throw error;
@@ -3285,10 +3269,11 @@ function generateSessionId() {
 //#endregion
 //#region src/harness/fillRecordCollector.ts
 /**
-* Thread-safe collector for FillRecord data.
+* Collector for FillRecord data from async form fill operations.
 *
-* Uses an append-only event log pattern for thread safety.
-* Events are aggregated when getRecord() is called.
+* Uses an append-only event log pattern that safely handles interleaved
+* async callbacks from parallel execution. Events are aggregated when
+* getRecord() is called.
 */
 var FillRecordCollector = class {
 	startedAt;
@@ -3331,7 +3316,8 @@ var FillRecordCollector = class {
 			turnNumber: progress.turnNumber,
 			patchesApplied: progress.patchesApplied,
 			patchesRejected: progress.rejectedPatches?.length ?? 0,
-			issuesAddressed: progress.issuesShown
+			issuesAddressed: progress.issuesShown,
+			executionId: progress.executionId
 		});
 	}
 	onLlmCallStart(call) {
@@ -3439,93 +3425,120 @@ var FillRecordCollector = class {
 		};
 	}
 	buildTimeline() {
+		const turnKey = (execId, turnNum) => `${execId}:${turnNum}`;
+		const fillStartMs = new Date(this.startedAt).getTime();
 		const turns = /* @__PURE__ */ new Map();
 		const turnStartEvents = /* @__PURE__ */ new Map();
 		const turnToolCalls = /* @__PURE__ */ new Map();
 		const turnTokens = /* @__PURE__ */ new Map();
 		for (const event of this.events) if (event.type === "turn_start") {
-			turnStartEvents.set(event.turnNumber, event);
-			turnToolCalls.set(event.turnNumber, []);
-			turnTokens.set(event.turnNumber, {
+			const key = turnKey(event.executionId, event.turnNumber);
+			turnStartEvents.set(key, event);
+			turnToolCalls.set(key, []);
+			turnTokens.set(key, {
 				input: 0,
 				output: 0
 			});
 		}
 		const activeToolsByTurn = /* @__PURE__ */ new Map();
-		let currentTurnNumber = 0;
+		const currentTurnKeyByExecutionId = /* @__PURE__ */ new Map();
 		for (const event of this.events) if (event.type === "turn_start") {
-			currentTurnNumber = event.turnNumber;
-			activeToolsByTurn.set(currentTurnNumber, /* @__PURE__ */ new Map());
+			const key = turnKey(event.executionId, event.turnNumber);
+			currentTurnKeyByExecutionId.set(event.executionId, key);
+			activeToolsByTurn.set(key, /* @__PURE__ */ new Map());
 		} else if (event.type === "tool_start") {
-			const activeTurn = this.findTurnForExecutionId(event.executionId, turnStartEvents) ?? currentTurnNumber;
-			const activeTools = activeToolsByTurn.get(activeTurn);
-			if (activeTools) {
-				const key = `${event.executionId}:${event.name}`;
-				activeTools.set(key, {
-					start: event,
-					turnNumber: activeTurn
-				});
+			const activeTurnKey = currentTurnKeyByExecutionId.get(event.executionId);
+			if (activeTurnKey) {
+				const activeTools = activeToolsByTurn.get(activeTurnKey);
+				if (activeTools) {
+					const toolKey = `${event.executionId}:${event.name}`;
+					activeTools.set(toolKey, {
+						start: event,
+						turnKey: activeTurnKey
+					});
+				}
 			}
 		} else if (event.type === "tool_end") {
-			const key = `${event.executionId}:${event.name}`;
-			let foundTurn;
-			for (const [turnNum, activeTools] of activeToolsByTurn) if (activeTools.has(key)) {
-				foundTurn = turnNum;
+			const toolKey = `${event.executionId}:${event.name}`;
+			let foundTurnKey;
+			for (const [tk, activeTools] of activeToolsByTurn) if (activeTools.has(toolKey)) {
+				foundTurnKey = tk;
 				break;
 			}
-			if (foundTurn !== void 0) {
-				const activeTools = activeToolsByTurn.get(foundTurn);
-				const startInfo = activeTools.get(key);
+			if (foundTurnKey !== void 0) {
+				const activeTools = activeToolsByTurn.get(foundTurnKey);
+				const startInfo = activeTools.get(toolKey);
 				if (startInfo) {
 					const toolCall = {
 						tool: event.name,
 						startedAt: startInfo.start.timestamp,
 						completedAt: event.timestamp,
+						startMs: new Date(startInfo.start.timestamp).getTime() - fillStartMs,
 						durationMs: event.durationMs,
 						success: !event.error,
 						input: this.normalizeInput(startInfo.start.input),
 						result: event.error ? { error: event.error } : this.extractResultCount(event.output)
 					};
-					turnToolCalls.get(foundTurn)?.push(toolCall);
-					activeTools.delete(key);
+					turnToolCalls.get(foundTurnKey)?.push(toolCall);
+					activeTools.delete(toolKey);
 				}
 			}
 		} else if (event.type === "llm_call_end") {
-			const turnNum = this.findTurnForExecutionId(event.executionId, turnStartEvents) ?? currentTurnNumber;
-			const tokens = turnTokens.get(turnNum);
-			if (tokens) {
-				tokens.input += event.inputTokens;
-				tokens.output += event.outputTokens;
+			const tk = currentTurnKeyByExecutionId.get(event.executionId);
+			if (tk) {
+				const tokens = turnTokens.get(tk);
+				if (tokens) {
+					tokens.input += event.inputTokens;
+					tokens.output += event.outputTokens;
+				}
 			}
 		}
+		const turnCompleteByKey = /* @__PURE__ */ new Map();
 		for (const event of this.events) if (event.type === "turn_complete") {
-			const startEvent = turnStartEvents.get(event.turnNumber);
-			if (startEvent) {
-				const tokens = turnTokens.get(event.turnNumber) ?? {
+			if (event.executionId) {
+				const key = turnKey(event.executionId, event.turnNumber);
+				turnCompleteByKey.set(key, event);
+			} else for (const [key, startEvent] of turnStartEvents) if (startEvent.turnNumber === event.turnNumber && !turnCompleteByKey.has(key)) {
+				turnCompleteByKey.set(key, event);
+				break;
+			}
+		}
+		for (const [key, startEvent] of turnStartEvents) {
+			const completeEvent = turnCompleteByKey.get(key);
+			if (completeEvent) {
+				const tokens = turnTokens.get(key) ?? {
 					input: 0,
 					output: 0
 				};
-				const toolCalls = turnToolCalls.get(event.turnNumber) ?? [];
+				const toolCalls = turnToolCalls.get(key) ?? [];
+				const turnStartMs = new Date(startEvent.timestamp).getTime();
 				const entry = {
-					turnNumber: event.turnNumber,
+					turnNumber: startEvent.turnNumber,
 					order: startEvent.order,
 					executionId: startEvent.executionId,
 					startedAt: startEvent.timestamp,
-					completedAt: event.timestamp,
-					durationMs: new Date(event.timestamp).getTime() - new Date(startEvent.timestamp).getTime(),
-					issuesAddressed: event.issuesAddressed,
-					patchesApplied: event.patchesApplied,
-					patchesRejected: event.patchesRejected,
+					completedAt: completeEvent.timestamp,
+					startMs: turnStartMs - fillStartMs,
+					durationMs: new Date(completeEvent.timestamp).getTime() - turnStartMs,
+					issuesAddressed: completeEvent.issuesAddressed,
+					patchesApplied: completeEvent.patchesApplied,
+					patchesRejected: completeEvent.patchesRejected,
 					tokens,
 					toolCalls
 				};
-				turns.set(event.turnNumber, entry);
+				turns.set(key, entry);
 			}
 		}
-		return Array.from(turns.values()).sort((a, b) => a.turnNumber - b.turnNumber);
+		return Array.from(turns.values()).sort((a, b) => new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime());
 	}
-	findTurnForExecutionId(executionId, turnStartEvents) {
-		for (const [turnNumber, event] of turnStartEvents) if (event.executionId === executionId) return turnNumber;
+	findTurnKeyForExecutionId(executionId, turnStartEvents) {
+		let latestKey;
+		let latestTime = "";
+		for (const [key, event] of turnStartEvents) if (event.executionId === executionId && event.timestamp > latestTime) {
+			latestKey = key;
+			latestTime = event.timestamp;
+		}
+		return latestKey;
 	}
 	normalizeInput(input) {
 		if (input && typeof input === "object" && !Array.isArray(input)) return input;
@@ -9120,6 +9133,8 @@ var LiveAgent = class {
 	webSearchTools = null;
 	additionalTools;
 	callbacks;
+	executionId;
+	toolChoice;
 	constructor(config) {
 		this.model = config.model;
 		this.maxStepsPerTurn = config.maxStepsPerTurn ?? DEFAULT_MAX_STEPS_PER_TURN;
@@ -9129,6 +9144,8 @@ var LiveAgent = class {
 		this.enableWebSearch = config.enableWebSearch;
 		this.additionalTools = config.additionalTools ?? {};
 		this.callbacks = config.callbacks;
+		this.executionId = config.executionId ?? "0-serial";
+		this.toolChoice = config.toolChoice ?? "required";
 		if (this.enableWebSearch && this.provider) this.webSearchTools = loadWebSearchTools(this.provider);
 	}
 	/**
@@ -9168,32 +9185,37 @@ var LiveAgent = class {
 			...this.webSearchTools,
 			...this.additionalTools
 		};
-		const tools = wrapToolsWithCallbacks(rawTools, this.callbacks, this.provider);
+		const tools = wrapToolsWithCallbacks(rawTools, this.callbacks, this.provider, this.executionId);
 		const modelId = this.model.modelId ?? "unknown";
 		if (this.callbacks?.onLlmCallStart) try {
 			this.callbacks.onLlmCallStart({
 				model: modelId,
-				executionId: "0-serial"
+				executionId: this.executionId
 			});
 		} catch {}
-		const result = await generateText({
-			model: this.model,
-			system: systemPrompt,
-			prompt: contextPrompt,
-			tools,
-			stopWhen: stepCountIs(this.maxStepsPerTurn)
-		});
+		let result;
+		try {
+			result = await generateText({
+				model: this.model,
+				system: systemPrompt,
+				prompt: contextPrompt,
+				tools,
+				toolChoice: this.toolChoice,
+				stopWhen: stepCountIs(this.maxStepsPerTurn)
+			});
+		} catch (error) {
+			throw wrapApiError(error, this.provider ?? "unknown", modelId);
+		}
 		if (this.callbacks?.onLlmCallEnd) try {
 			this.callbacks.onLlmCallEnd({
 				model: modelId,
 				inputTokens: result.usage?.inputTokens ?? 0,
 				outputTokens: result.usage?.outputTokens ?? 0,
-				executionId: "0-serial"
+				executionId: this.executionId
 			});
 		} catch {}
 		const patches = [];
 		const toolCallCounts = /* @__PURE__ */ new Map();
-		const executionId = "0-serial";
 		for (const step of result.steps) for (const toolCall of step.toolCalls) {
 			const count = toolCallCounts.get(toolCall.toolName) ?? 0;
 			toolCallCounts.set(toolCall.toolName, count + 1);
@@ -9204,7 +9226,7 @@ var LiveAgent = class {
 					this.callbacks.onToolStart({
 						name: FILL_FORM_TOOL_NAME,
 						input,
-						executionId
+						executionId: this.executionId
 					});
 				} catch {}
 				patches.push(...input.patches);
@@ -9213,7 +9235,7 @@ var LiveAgent = class {
 						name: FILL_FORM_TOOL_NAME,
 						output: { patchCount: input.patches.length },
 						durationMs: Date.now() - startTime,
-						executionId,
+						executionId: this.executionId,
 						error: void 0
 					});
 				} catch {}
@@ -9458,12 +9480,12 @@ function findField(form, fieldId) {
 * Only wraps tools that have an execute function.
 * Declarative tools (schema only) are passed through unchanged.
 */
-function wrapToolsWithCallbacks(tools, callbacks, provider) {
+function wrapToolsWithCallbacks(tools, callbacks, provider, executionId = "0-serial") {
 	if (!callbacks?.onToolStart && !callbacks?.onToolEnd && !callbacks?.onWebSearch) return tools;
 	const wrapped = {};
 	for (const [name, tool] of Object.entries(tools)) {
 		const execute = tool.execute;
-		if (typeof execute === "function") wrapped[name] = wrapTool(name, tool, execute, callbacks, provider);
+		if (typeof execute === "function") wrapped[name] = wrapTool(name, tool, execute, callbacks, provider, executionId);
 		else wrapped[name] = tool;
 	}
 	return wrapped;
@@ -9471,12 +9493,11 @@ function wrapToolsWithCallbacks(tools, callbacks, provider) {
 /**
 * Wrap a single tool with callbacks.
 */
-function wrapTool(name, tool, originalExecute, callbacks, provider) {
+function wrapTool(name, tool, originalExecute, callbacks, provider, executionId) {
 	return {
 		...tool,
 		execute: async (input) => {
 			const startTime = Date.now();
-			const executionId = "0-serial";
 			if (callbacks.onToolStart) try {
 				callbacks.onToolStart({
 					name,
@@ -9853,7 +9874,7 @@ var ParallelHarness = class {
 			this.config.onBatchStart?.(batch.batchId);
 			const batchIssues = inspect(this.form).issues;
 			const maxConcurrent = this.config.maxParallelAgents ?? DEFAULT_MAX_PARALLEL_AGENTS;
-			const agentPromises = [];
+			const agentFactories = [];
 			const itemFieldIds = /* @__PURE__ */ new Map();
 			for (let i = 0; i < batchItems.length; i++) {
 				const item = batchItems[i];
@@ -9861,7 +9882,7 @@ var ParallelHarness = class {
 				const targetFieldIds = getFieldIdsForItem(this.form, item);
 				itemFieldIds.set(i, targetFieldIds);
 				if (scopedIssues.length === 0) {
-					agentPromises.push(Promise.resolve({ patches: [] }));
+					agentFactories.push(() => Promise.resolve({ patches: [] }));
 					continue;
 				}
 				const request = {
@@ -9871,9 +9892,9 @@ var ParallelHarness = class {
 					issues: scopedIssues
 				};
 				const agent = this.config.agentFactory ? this.config.agentFactory(request) : primaryAgent;
-				agentPromises.push(agent.fillFormTool(scopedIssues, this.form, maxPatches));
+				agentFactories.push(() => agent.fillFormTool(scopedIssues, this.form, maxPatches));
 			}
-			const results = await runWithConcurrency(agentPromises, maxConcurrent);
+			const results = await runWithConcurrency(agentFactories, maxConcurrent);
 			const allPatches = [];
 			for (const result of results) if (result.status === "fulfilled") allPatches.push(...result.value.patches);
 			else errors.push(`Parallel agent error: ${result.reason}`);
@@ -9912,20 +9933,25 @@ var ParallelHarness = class {
 	}
 };
 /**
-* Run promises with a concurrency limit.
+* Run promise factories with a concurrency limit.
+* Takes an array of functions that create promises (factories), not already-started promises.
+* This ensures concurrency limiting actually works - promises are started lazily.
 * Returns results in the same order as input.
 */
-async function runWithConcurrency(promises, maxConcurrent) {
-	if (maxConcurrent >= promises.length) return Promise.allSettled(promises);
-	const results = new Array(promises.length);
+async function runWithConcurrency(factories, maxConcurrent) {
+	if (factories.length === 0) return [];
+	if (maxConcurrent >= factories.length) return Promise.allSettled(factories.map(async (f) => f()));
+	const results = new Array(factories.length);
 	let nextIndex = 0;
 	async function runNext() {
-		while (nextIndex < promises.length) {
+		while (nextIndex < factories.length) {
 			const idx = nextIndex++;
+			const factory = factories[idx];
+			if (!factory) continue;
 			try {
 				results[idx] = {
 					status: "fulfilled",
-					value: await promises[idx]
+					value: await factory()
 				};
 			} catch (reason) {
 				results[idx] = {
@@ -9935,7 +9961,7 @@ async function runWithConcurrency(promises, maxConcurrent) {
 			}
 		}
 	}
-	const workers = Array.from({ length: Math.min(maxConcurrent, promises.length) }, () => runNext());
+	const workers = Array.from({ length: Math.min(maxConcurrent, factories.length) }, () => runNext());
 	await Promise.all(workers);
 	return results;
 }
@@ -9949,6 +9975,43 @@ function createParallelHarness(form, config) {
 //#endregion
 //#region src/harness/programmaticFill.ts
 /**
+* Execution ID format for tracking parallel and serial execution threads.
+*
+* Format: `eid:{type}:o{order}[:{batchId}:i{index}]`
+*
+* Components:
+* - `eid:` - Prefix identifying this as an execution ID
+* - `{type}` - Either `serial` or `batch`
+* - `o{order}` - Order level (e.g., `o0`, `o10`)
+* - For batch only: `:{batchId}:i{index}` - Batch name and item index
+*
+* Examples:
+* - `eid:serial:o0` - Serial execution at order level 0
+* - `eid:batch:o0:research:i0` - First item in "research" batch at order 0
+* - `eid:batch:o0:research:i3` - Fourth item in "research" batch at order 0
+* - `eid:serial:o10` - Serial execution at order level 10
+*
+* Design principles:
+* - Self-identifying: Clear `eid:` prefix
+* - Structured: Type comes first for easy filtering
+* - Explicit: Each component has a prefix (`o` for order, `i` for index)
+* - Parseable: Can be split on `:` to extract components
+*/
+/** Prefix for all execution IDs */
+const EXECUTION_ID_PREFIX = "eid";
+/**
+* Create an execution ID for serial execution at an order level.
+*/
+function serialExecutionId(order) {
+	return `${EXECUTION_ID_PREFIX}:serial:o${order}`;
+}
+/**
+* Create an execution ID for a batch item at an order level.
+*/
+function batchExecutionId(order, batchId, itemIndex) {
+	return `${EXECUTION_ID_PREFIX}:batch:o${order}:${batchId}:i${itemIndex}`;
+}
+/**
 * Get current progress counts for a form.
 * Runs inspect to get issues, then computes progress summary.
 */
@@ -10250,7 +10313,8 @@ async function fillForm(options) {
 		enableWebSearch: options.enableWebSearch,
 		additionalTools: options.additionalTools,
 		callbacks: mergedCallbacks,
-		maxStepsPerTurn: options.maxStepsPerTurn
+		maxStepsPerTurn: options.maxStepsPerTurn,
+		toolChoice: options.toolChoice
 	});
 	let turnCount = startingTurnNumber;
 	let turnsThisCall = 0;
@@ -10361,7 +10425,8 @@ async function fillForm(options) {
 				stats,
 				issues: turnIssues,
 				patches,
-				rejectedPatches: stepResult.rejectedPatches ?? []
+				rejectedPatches: stepResult.rejectedPatches ?? [],
+				executionId: "0-serial"
 			});
 		} catch {}
 		if (!stepResult.isComplete && !harness.hasReachedMaxTurns()) stepResult = harness.step();
@@ -10402,16 +10467,20 @@ async function fillFormParallel(form, model, provider, options, initialPatches,
 	const targetRoles = options.targetRoles ?? [AGENT_ROLE];
 	let totalPatches = initialPatches;
 	let turnCount = startingTurnNumber;
-	const primaryAgent = options._testAgent ?? createLiveAgent({
-		model,
-		systemPromptAddition: options.systemPromptAddition,
-		targetRole: targetRoles[0] ?? AGENT_ROLE,
-		provider,
-		enableWebSearch: options.enableWebSearch,
-		additionalTools: options.additionalTools,
-		callbacks: mergedCallbacks,
-		maxStepsPerTurn: options.maxStepsPerTurn
-	});
+	const createAgentForExecution = (executionId) => {
+		return options._testAgent ?? createLiveAgent({
+			model,
+			systemPromptAddition: options.systemPromptAddition,
+			targetRole: targetRoles[0] ?? AGENT_ROLE,
+			provider,
+			enableWebSearch: options.enableWebSearch,
+			additionalTools: options.additionalTools,
+			callbacks: mergedCallbacks,
+			maxStepsPerTurn: options.maxStepsPerTurn,
+			executionId,
+			toolChoice: options.toolChoice
+		});
+	};
 	for (const order of plan.orderLevels) {
 		if (options.signal?.aborted) {
 			let record;
@@ -10441,7 +10510,8 @@ async function fillFormParallel(form, model, provider, options, initialPatches,
 		} catch {}
 		const serialItems = plan.looseSerial.filter((i) => i.order === order);
 		if (serialItems.length > 0) {
-			const result = await runMultiTurnForItems(form, primaryAgent, serialItems, targetRoles, maxPatchesPerTurn, maxIssuesPerTurn, maxTurnsTotal, turnCount, options, order, `${order}-serial`, mergedCallbacks);
+			const serialExecId = serialExecutionId(order);
+			const result = await runMultiTurnForItems(form, createAgentForExecution(serialExecId), serialItems, targetRoles, maxPatchesPerTurn, maxIssuesPerTurn, maxTurnsTotal, turnCount, options, order, serialExecId, mergedCallbacks);
 			totalPatches += result.patchesApplied;
 			turnCount += result.turnsUsed;
 			if (result.aborted && result.status) {
@@ -10466,17 +10536,11 @@ async function fillFormParallel(form, model, provider, options, initialPatches,
 				});
 			} catch {}
 			const results = await runWithConcurrency(batchItems.map((item, itemIndex) => {
-				return runMultiTurnForItems(form, options._testAgent ?? createLiveAgent({
-					model,
-					systemPromptAddition: options.systemPromptAddition,
-					targetRole: targetRoles[0] ?? AGENT_ROLE,
-					provider,
-					enableWebSearch: options.enableWebSearch,
-					additionalTools: options.additionalTools,
-					callbacks: mergedCallbacks,
-					maxStepsPerTurn: options.maxStepsPerTurn
-				}), [item], targetRoles, maxPatchesPerTurn, maxIssuesPerTurn, maxTurnsTotal, turnCount, options, order, `${order}-batch-${batch.batchId}-${itemIndex}`, mergedCallbacks);
-			}).map((p) => p), maxParallelAgents);
+				return () => {
+					const batchExecId = batchExecutionId(order, batch.batchId, itemIndex);
+					return runMultiTurnForItems(form, createAgentForExecution(batchExecId), [item], targetRoles, maxPatchesPerTurn, maxIssuesPerTurn, maxTurnsTotal, turnCount, options, order, batchExecId, mergedCallbacks);
+				};
+			}), maxParallelAgents);
 			let batchPatches = 0;
 			const batchErrors = [];
 			for (const result of results) if (result.status === "fulfilled") {
@@ -10608,7 +10672,8 @@ async function runMultiTurnForItems(form, agent, items, targetRoles, maxPatchesP
 				stats: response.stats,
 				issues: scopedIssues,
 				patches: response.patches,
-				rejectedPatches: previousRejections ?? []
+				rejectedPatches: previousRejections ?? [],
+				executionId
 			});
 		} catch {}
 	}
@@ -10774,6 +10839,7 @@ const ToolCallRecordSchema = z.object({
 	tool: z.string(),
 	startedAt: z.string().datetime(),
 	completedAt: z.string().datetime(),
+	startMs: z.number().int().nonnegative(),
 	durationMs: z.number().int().nonnegative(),
 	success: z.boolean(),
 	input: z.record(z.string(), z.unknown()),
@@ -10791,6 +10857,7 @@ const TimelineEntrySchema = z.object({
 	executionId: z.string(),
 	startedAt: z.string().datetime(),
 	completedAt: z.string().datetime(),
+	startMs: z.number().int().nonnegative(),
 	durationMs: z.number().int().nonnegative(),
 	issuesAddressed: z.number().int().nonnegative(),
 	patchesApplied: z.number().int().nonnegative(),
@@ -11044,8 +11111,8 @@ function validateResearchForm(form) {
 //#endregion
 //#region src/index.ts
 /** Markform version (injected at build time). */
-const VERSION = "0.1.20";
+const VERSION = "0.1.22";
 
 //#endregion
 export { FormHarness as A, serializeScopeRef as B, resolveModel as C, computeExecutionPlan as D, FillRecordCollector as E, getFieldId as F, injectCheckboxIds as G, formToJsonSchema as H, isCellRef as I, findEnclosingHeadings as J, injectHeaderIds as K, isFieldRef as L, coerceInputContext as M, coerceToFieldPatch as N, MockAgent as O, findFieldById as P, isQualifiedRef as R, getProviderNames as S, createLiveAgent as T, parseForm as U, fieldToJsonSchema as V, findAllCheckboxes as W, parseMarkdownTable as X, parseCellValue as Y, parseRawTable as Z, fillForm as _, ExecutionMetadataSchema as a, scopeIssuesForItem as b, TimelineEntrySchema as c, ToolCallRecordSchema as d, ToolStatsSchema as f, resolveHarnessConfig as g, formatFillRecordSummary as h, runResearch as i, createHarness as j, createMockAgent as k, TimingBreakdownItemSchema as l, stripUnstableFillRecordFields as m, isResearchForm as n, FillRecordSchema as o, ToolSummarySchema as p, findAllHeadings as q, validateResearchForm as r, FillRecordStatusSchema as s, VERSION as t, TimingBreakdownSchema as u, ParallelHarness as v, buildMockWireFormat as w, getProviderInfo as x, createParallelHarness as y, parseScopeRef as z };
-//# sourceMappingURL=src-wR7GoftB.mjs.map
+//# sourceMappingURL=src-CbRnGzMK.mjs.map