substrate-ai 0.17.0 → 0.17.1

package/dist/{run-DZwHUMeE.js → run-Bku8fmY3.js}

@@ -4046,7 +4046,7 @@ minimatch.unescape = unescape;
 
 //#endregion
 //#region src/modules/repo-map/query.ts
-const DEFAULT_MAX_TOKENS = 2e3;
+const DEFAULT_MAX_TOKENS$1 = 2e3;
 /** Chars per token heuristic (same as ContextInjector) */
 const CHARS_PER_TOKEN = 4;
 /** Overhead chars per symbol line: `:lineNumber symbolType \n` */
@@ -4062,7 +4062,7 @@ var RepoMapQueryEngine = class {
 	}
 	async query(q) {
 		const start = Date.now();
-		const maxTokens = q.maxTokens ?? DEFAULT_MAX_TOKENS;
+		const maxTokens = q.maxTokens ?? DEFAULT_MAX_TOKENS$1;
 		const hasFilesFilter = (q.files?.length ?? 0) > 0;
 		const hasSymbolsFilter = (q.symbols?.length ?? 0) > 0;
 		const hasTypesFilter = (q.types?.length ?? 0) > 0;
@@ -4912,9 +4912,9 @@ const coerceToString = z.preprocess((val) => {
 */
 const DevStoryResultSchema = z.object({
 	result: z.preprocess((val) => val === "failure" ? "failed" : val, z.enum(["success", "failed"])),
-	ac_met: z.array(coerceToString),
-	ac_failures: z.array(coerceToString),
-	files_modified: z.array(z.string()),
+	ac_met: z.array(coerceToString).default([]),
+	ac_failures: z.array(coerceToString).default([]),
+	files_modified: z.array(z.string()).default([]),
 	tests: z.preprocess((val) => {
 		if (typeof val === "string") {
 			const lower = val.toLowerCase();
@@ -4936,7 +4936,11 @@ const DevStoryResultSchema = z.object({
 * as strings (`"42"` instead of `42`). This handles the conversion.
 */
 const coerceOptionalNumber = z.preprocess((val) => typeof val === "string" ? Number(val) : val, z.number().optional());
-const coerceNumber = z.preprocess((val) => typeof val === "string" ? Number(val) : val, z.number());
+const coerceNumber = z.preprocess((val) => {
+	if (typeof val === "string") return Number(val);
+	if (Array.isArray(val)) return val.length;
+	return val;
+}, z.number());
 /**
 * Schema for a single issue in the code review output.
 */
@@ -4956,13 +4960,13 @@ const CodeReviewIssueSchema = z.object({
 * status determination backed by concrete evidence from the diff.
 */
 const AcChecklistEntrySchema = z.object({
-	ac_id: z.string(),
+	ac_id: z.string().default(""),
 	status: z.enum([
 		"met",
 		"not_met",
 		"partial"
-	]),
-	evidence: z.string()
+	]).default("met"),
+	evidence: z.string().default("")
 });
 /**
 * Compute the verdict from the issue list using deterministic rules.
@@ -28737,228 +28741,2440 @@ const ajv = new import_ajv.default({
 	allErrors: true,
 	coerceTypes: false
 });
-
-//#endregion
-//#region packages/factory/dist/handlers/start.js
 /**
-* Handler for start nodes.
-* No side effects — edge selection drives the next step.
-*
-* Story 42-9.
+* Registry for tool definitions. Provides lookup, validation, and execution.
 */
-/** Handler for start nodes; no side effects; edge selection drives next step. */
-const startHandler = async (_node, _context, _graph) => {
-	return { status: "SUCCESS" };
+var ToolRegistry = class {
+	_tools = new Map();
+	register(tool) {
+		this._tools.set(tool.name, tool);
+	}
+	async execute(name, args, env) {
+		const tool = this._tools.get(name);
+		if (!tool) return {
+			content: `Unknown tool: ${name}`,
+			isError: true
+		};
+		const validate$1 = ajv.compile(tool.inputSchema);
+		const valid = validate$1(args);
+		if (!valid) {
+			const errors = validate$1.errors ?? [];
+			const messages = errors.map((e) => {
+				const path$2 = e.instancePath ?? e.dataPath ?? "";
+				return `${path$2} ${e.message ?? ""}`.trim();
+			}).join(", ");
+			return {
+				content: `Validation failed for tool '${name}': ${messages}`,
+				isError: true
+			};
+		}
+		try {
+			const result = await tool.executor(args, env);
+			const content = tool.outputTruncation !== void 0 && result.length > tool.outputTruncation ? result.slice(0, tool.outputTruncation) + "\n[truncated]" : result;
+			return {
+				content,
+				isError: false
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return {
+				content: message,
+				isError: true
+			};
+		}
+	}
+	get(name) {
+		return this._tools.get(name);
+	}
+	getDefinitions() {
+		return Array.from(this._tools.values());
+	}
 };
 
 //#endregion
-//#region packages/factory/dist/handlers/exit.js
-/**
-* Handler for exit/terminal nodes.
-* Signals successful graph completion with no side effects.
-*
-* Story 42-9.
-*/
-/** Handler for exit/terminal nodes; signals successful graph completion. */
-const exitHandler = async (_node, _context, _graph) => {
-	return { status: "SUCCESS" };
+//#region packages/factory/dist/agent/types.js
+const DEFAULT_SESSION_CONFIG = {
+	max_turns: 0,
+	max_tool_rounds_per_input: 0,
+	default_command_timeout_ms: 1e4,
+	max_command_timeout_ms: 6e5,
+	reasoning_effort: null,
+	tool_output_limits: new Map(),
+	enable_loop_detection: true,
+	loop_detection_window: 10,
+	truncation_mode: "head_tail",
+	max_output_lines: 500
+};
+const SessionState = {
+	IDLE: "IDLE",
+	PROCESSING: "PROCESSING",
+	AWAITING_INPUT: "AWAITING_INPUT",
+	CLOSED: "CLOSED"
+};
+const EventKind = {
+	SESSION_START: "SESSION_START",
+	SESSION_END: "SESSION_END",
+	USER_INPUT: "USER_INPUT",
+	PROCESSING_END: "PROCESSING_END",
+	ASSISTANT_TEXT_START: "ASSISTANT_TEXT_START",
+	ASSISTANT_TEXT_DELTA: "ASSISTANT_TEXT_DELTA",
+	ASSISTANT_TEXT_END: "ASSISTANT_TEXT_END",
+	TOOL_CALL_START: "TOOL_CALL_START",
+	TOOL_CALL_OUTPUT_DELTA: "TOOL_CALL_OUTPUT_DELTA",
+	TOOL_CALL_END: "TOOL_CALL_END",
+	STEERING_INJECTED: "STEERING_INJECTED",
+	TURN_LIMIT: "TURN_LIMIT",
+	LOOP_DETECTION: "LOOP_DETECTION",
+	WARNING: "WARNING",
+	ERROR: "ERROR"
 };
 
 //#endregion
-//#region packages/factory/dist/handlers/conditional.js
+//#region packages/factory/dist/agent/truncation.js
 /**
-* Handler for conditional/branching nodes.
-* Routing is delegated entirely to edge selection (story 42-12).
-* This handler does nothing — it simply returns SUCCESS so the executor
-* can proceed to edge evaluation.
+* Default per-tool character output limits.
+* Tools not listed here fall back to DEFAULT_FALLBACK_CHAR_LIMIT (10,000).
 *
-* Story 42-9.
-*/
-/**
-* Handler for conditional/branching nodes; routing is delegated entirely to
-* edge selection (story 42-12); this handler does nothing.
+* Note: shell is 30K (not 10K as in the AC) — shell output often contains build logs,
+* test results, and compiler errors that need more context for effective debugging.
+* The 10K AC value was based on interactive shell use; 30K reflects agentic workloads.
 */
-const conditionalHandler = async (_node, _context, _graph) => {
-	return { status: "SUCCESS" };
+const DEFAULT_TOOL_LIMITS = {
+	read_file: 5e4,
+	shell: 3e4,
+	grep: 2e4,
+	glob: 2e4
 };
+/** Fallback character limit for tools not in DEFAULT_TOOL_LIMITS */
+const DEFAULT_FALLBACK_CHAR_LIMIT = 1e4;
+/** Maximum lines before Phase 2 line-based truncation is applied */
+const DEFAULT_LINE_LIMIT = 500;
+function truncateByChars(output, limit, mode) {
+	if (output.length <= limit) return output;
+	if (mode === "tail") return output.slice(-limit);
+	const half = Math.floor(limit / 2);
+	const removed = output.length - limit;
+	return output.slice(0, half) + `\n\n[... ${removed} characters truncated from middle. Full output available in event stream.]\n\n` + output.slice(-half);
+}
+function truncateByLines(output, maxLines, mode) {
+	const lines = output.split("\n");
+	if (lines.length <= maxLines) return output;
+	if (mode === "tail") return lines.slice(-maxLines).join("\n");
+	const headCount = Math.ceil(maxLines / 2);
+	const tailCount = Math.floor(maxLines / 2);
+	const removed = lines.length - maxLines;
+	return lines.slice(0, headCount).join("\n") + `\n[... ${removed} lines truncated from middle ...]\n` + lines.slice(-tailCount).join("\n");
+}
+/**
+* Truncates tool output to fit within LLM context windows using a two-phase pipeline.
+*
+* Phase 1 (character-based): Applies per-tool character limits in head_tail or tail mode.
+* Phase 2 (line-based): Applies max_output_lines limit in head_tail or tail mode.
+*
+* If output is within both limits, returns the original string unchanged.
+*/
+function truncateToolOutput(output, toolName, config) {
+	const charLimit = config.tool_output_limits.get(toolName) ?? DEFAULT_TOOL_LIMITS[toolName] ?? DEFAULT_FALLBACK_CHAR_LIMIT;
+	const mode = config.truncation_mode ?? "head_tail";
+	const maxLines = config.max_output_lines ?? DEFAULT_LINE_LIMIT;
+	const afterPhase1 = truncateByChars(output, charLimit, mode);
+	return truncateByLines(afterPhase1, maxLines, mode);
+}
 
 //#endregion
-//#region packages/factory/dist/stylesheet/resolver.js
-/**
-* Specificity-based resolver for the model stylesheet.
-*
-* Given a parsed stylesheet and a graph node, `resolveNodeStyles` determines
-* which LLM routing properties apply to that node by:
-*   1. Filtering rules to only those whose selector matches the node.
-*   2. Sorting matching rules by specificity ascending (stable sort so that
-*      equal-specificity rules preserve source order).
-*   3. Iterating the sorted list and letting each rule overwrite properties
-*      — the last rule at the highest specificity wins; for ties the rule
-*      appearing later in the original stylesheet wins.
-*
-* **Caller contract**: `resolveNodeStyles` does NOT enforce the "explicit node
-* attribute wins" rule.  The caller (executor / node preparation layer) is
-* responsible for the final merge:
-* ```typescript
-* const resolved = resolveNodeStyles(node, stylesheet)
-* const finalModel = node.llmModel || resolved.llmModel || graph.defaultLlmModel || ''
-* ```
-*
-* Story 42-7.
-*/
-/**
-* Return `true` if the given `selector` matches the provided `node`.
-*
-* Matching rules:
-* - `universal`: always matches every node.
-* - `shape`: matches when `node.shape === selector.value`.
-* - `class`: matches when the node's `class` field, split on commas and
-*   trimmed, contains `selector.value` (case-sensitive).
-* - `id`: matches when `node.id === selector.value`.
-*/
-function matchesNode(node, selector) {
-	switch (selector.type) {
-		case "universal": return true;
-		case "shape": return node.shape === selector.value;
-		case "class": {
-			const tokens = node.class.split(",").map((t) => t.trim());
-			return tokens.includes(selector.value);
+//#region packages/factory/dist/agent/loop-detection.js
+var LoopDetector = class {
+	_config;
+	_window = [];
+	constructor(config) {
+		this._config = config;
+	}
+	/**
+	* Record a tool call and check for a repeating pattern.
+	* Returns true if a loop is detected (window is full and a repeating pattern found).
+	* Returns false if detection is disabled, window is not yet full, or no pattern is found.
+	*/
+	record(toolName, toolArgs) {
+		if (!this._config.enabled) return false;
+		const sig = createHash("sha256").update(`${toolName}:${JSON.stringify(toolArgs)}`).digest("hex");
+		this._window.push(sig);
+		if (this._window.length > this._config.windowSize) this._window.shift();
+		if (this._window.length < this._config.windowSize) return false;
+		return this._detectPattern();
+	}
+	/**
+	* Check whether the current window contains a repeating pattern of length 1, 2, or 3.
+	* Pattern length N is only checked if windowSize % N === 0.
+	*/
+	_detectPattern() {
+		const w = this._window;
+		const n$1 = this._config.windowSize;
+		for (const patternLen of [
+			1,
+			2,
+			3
+		]) {
+			if (n$1 % patternLen !== 0) continue;
+			const pattern = w.slice(0, patternLen);
+			let allMatch = true;
+			for (let i = patternLen; i < n$1; i += patternLen) {
+				for (let j$1 = 0; j$1 < patternLen; j$1++) if (w[i + j$1] !== pattern[j$1]) {
+					allMatch = false;
+					break;
+				}
+				if (!allMatch) break;
+			}
+			if (allMatch) return true;
 		}
-		case "id": return node.id === selector.value;
-		default: return false;
+		return false;
 	}
-}
-/**
-* Resolve LLM routing properties for a single graph node using the parsed stylesheet.
-*
-* @param node       - The graph node to resolve properties for.
-* @param stylesheet - A parsed stylesheet (array of `StylesheetRule` in source order).
-* @returns A `ResolvedNodeStyles` object containing only the properties that
-*   were resolved from matching rules.  Properties absent from matching rules
-*   are omitted (not set to `undefined` explicitly).
-*
-* **Important**: this function does NOT check the node's own attributes.
-* Callers must give explicit node attributes (`node.llmModel`, etc.) priority
-* over the values returned here.
-*/
-function resolveNodeStyles(node, stylesheet) {
-	const matchingRules = stylesheet.filter((rule) => matchesNode(node, rule.selector));
-	matchingRules.sort((a, b) => a.selector.specificity - b.selector.specificity);
-	const resolved = {};
-	for (const rule of matchingRules) for (const decl of rule.declarations) if (decl.property === "llm_model") resolved.llmModel = decl.value;
-	else if (decl.property === "llm_provider") resolved.llmProvider = decl.value;
-	else if (decl.property === "reasoning_effort") resolved.reasoningEffort = decl.value;
-	return resolved;
-}
+};
 
 //#endregion
-//#region packages/factory/dist/handlers/codergen-handler.js
-const DEFAULT_MODEL = "claude-sonnet-4-5";
-const DEFAULT_PROVIDER = "anthropic";
-const DEFAULT_REASONING_EFFORT = "medium";
+//#region packages/factory/dist/agent/loop.js
+/** Build a ToolRegistry from a ProviderProfile's tool definitions. */
+function buildRegistryFromProfile(profile) {
+	const registry = new ToolRegistry();
+	for (const tool of profile.tools()) registry.register(tool);
+	return registry;
+}
 /**
-* Replace all `{{key}}` placeholders in `template` with the corresponding
-* values from `context`.  Missing keys resolve to empty string `""` without
-* throwing.
-*
-* @param template - The prompt template string (may contain `{{variable}}` tokens).
-* @param context  - The graph context to read values from.
-* @returns The fully-interpolated prompt string.
-*/
-function interpolatePrompt(template, context) {
-	return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
-		return context.getString(key, "");
-	});
+* Convert session history turns to LLMMessage array for the LLM request.
+* SystemTurns are skipped (system prompt is provided separately via ProviderProfile).
+*/
+function convertHistoryToMessages(history) {
+	const messages = [];
+	for (const turn of history) switch (turn.type) {
+		case "user":
+		case "steering":
+			messages.push({
+				role: "user",
+				content: [{
+					kind: "text",
+					text: turn.content
+				}]
+			});
+			break;
+		case "assistant":
+			if (turn.tool_calls.length > 0) {
+				const parts = [];
+				if (turn.content) parts.push({
+					kind: "text",
+					text: turn.content
+				});
+				for (const tc of turn.tool_calls) parts.push({
+					kind: "tool_call",
+					toolCall: {
+						id: tc.id,
+						name: tc.name,
+						arguments: tc.arguments,
+						...tc.rawArguments !== void 0 ? { rawArguments: tc.rawArguments } : {}
+					}
+				});
+				messages.push({
+					role: "assistant",
+					content: parts
+				});
+			} else messages.push({
+				role: "assistant",
+				content: [{
+					kind: "text",
+					text: turn.content
+				}]
+			});
+			break;
+		case "tool_results":
+			messages.push({
+				role: "user",
+				content: turn.results.map((r) => ({
+					kind: "tool_result",
+					toolResult: {
+						toolCallId: r.tool_call_id,
+						content: r.content,
+						isError: r.is_error
+					}
+				}))
+			});
+			break;
+		case "system": break;
+	}
+	return messages;
 }
 /**
-* Resolve the LLM routing properties for a graph node.
-*
-* Priority (highest wins):
-*   1. Node-level attributes (`node.llmModel`, `node.llmProvider`, `node.reasoningEffort`)
-*   2. Stylesheet-resolved values via `resolveNodeStyles`
-*   3. Per-option defaults (`options.defaultModel`, etc.)
-*   4. System defaults (`claude-sonnet-4-5`, `anthropic`, `medium`)
+* Build LLMRequest from the current session state.
 */
-function resolveModel(node, stylesheet, options) {
-	const stylesheetResolved = stylesheet ? resolveNodeStyles(node, stylesheet) : {};
-	const llm_model = node.llmModel || stylesheetResolved.llmModel || options?.defaultModel || DEFAULT_MODEL;
-	const llm_provider = node.llmProvider || stylesheetResolved.llmProvider || options?.defaultProvider || DEFAULT_PROVIDER;
-	const reasoning_effort = node.reasoningEffort || stylesheetResolved.reasoningEffort || options?.defaultReasoningEffort || DEFAULT_REASONING_EFFORT;
-	return {
-		llm_model,
-		llm_provider,
-		reasoning_effort
+function buildLLMRequest(session) {
+	const profile = session.providerProfile;
+	const config = session.config;
+	const tools = profile.tools().map((t) => ({
+		name: t.name,
+		description: t.description,
+		parameters: t.inputSchema
+	}));
+	const providerOptions = profile.provider_options();
+	const { max_tokens, temperature,...rest } = providerOptions;
+	const req = {
+		model: profile.model,
+		systemPrompt: profile.build_system_prompt(),
+		messages: convertHistoryToMessages(session.history),
+		tools,
+		toolChoice: "auto"
 	};
+	if (max_tokens !== void 0) req.maxTokens = max_tokens;
+	if (temperature !== void 0) req.temperature = temperature;
+	if (config.reasoning_effort) req.reasoningEffort = config.reasoning_effort;
+	if (Object.keys(rest).length > 0) req.extra = rest;
+	return req;
 }
-/**
-* Returns `true` for errors that are transient and should trigger a
-* `NEEDS_RETRY` outcome:
-*   - HTTP status 429 (rate limit)
-*   - Errors whose message contains `"timeout"`, `"ETIMEDOUT"`,
-*     `"ECONNRESET"`, or `"ECONNREFUSED"`
-*
-* All other errors are non-transient and map to `FAILURE`.
-*/
-function isTransientError(error) {
-	if (error == null) return false;
-	const status = error.status ?? error.statusCode;
-	if (status === 429) return true;
-	const message = error.message;
-	if (typeof message === "string") {
-		if (message.includes("timeout") || message.includes("ETIMEDOUT") || message.includes("ECONNRESET") || message.includes("ECONNREFUSED")) return true;
+var CodingAgentSession = class {
+	id;
+	state;
+	history;
+	config;
+	llmClient;
+	providerProfile;
+	executionEnv;
+	_steeringQueue;
+	_followupQueue;
+	_emitter;
+	_abortController;
+	_toolRegistry;
+	constructor(options) {
+		this.id = randomUUID();
+		this.state = SessionState.IDLE;
+		this.history = [];
+		this._steeringQueue = [];
+		this._followupQueue = [];
+		this._emitter = new EventEmitter();
+		this._emitter.setMaxListeners(50);
+		this._abortController = new AbortController();
+		this.llmClient = options.llmClient;
+		this.providerProfile = options.providerProfile;
+		this.executionEnv = options.executionEnv;
+		this.config = {
+			...DEFAULT_SESSION_CONFIG,
+			...options.config,
+			tool_output_limits: options.config?.tool_output_limits ?? new Map(),
+			truncation_mode: options.config?.truncation_mode ?? "head_tail",
+			max_output_lines: options.config?.max_output_lines ?? DEFAULT_LINE_LIMIT
+		};
+		this._toolRegistry = buildRegistryFromProfile(options.providerProfile);
+		this._emit(EventKind.SESSION_START, { session_id: this.id });
 	}
-	return false;
-}
-/**
-* Create a codergen node handler configured with the given options.
-*
-* @param options - Optional configuration (stylesheet, default model/provider/effort).
-* @returns A `NodeHandler` that:
-*   1. Interpolates the node's prompt (or label) against GraphContext.
-*   2. Resolves LLM routing properties.
-*   3. Calls the LLM client from `\@substrate-ai/core`.
-*   4. Returns a `SUCCESS` outcome with the response in `contextUpdates`,
-*      `NEEDS_RETRY` for transient errors, or `FAILURE` for others.
-*/
-function createCodergenHandler(options) {
-	return async (node, context, _graph) => {
-		const template = node.prompt || node.label || "";
-		const interpolatedPrompt = interpolatePrompt(template, context);
-		if (options?.backend) return options.backend.run(node, interpolatedPrompt, context);
-		if (node.backend === "direct" && options?.directBackend) return options.directBackend.run(node, interpolatedPrompt, context);
-		const { llm_model, llm_provider, reasoning_effort } = resolveModel(node, options?.stylesheet, options);
-		try {
-			const result = await callLLM({
-				model: llm_model,
-				provider: llm_provider,
-				reasoningEffort: reasoning_effort,
-				prompt: interpolatedPrompt
-			});
-			const responseText = result.text;
-			return {
-				status: "SUCCESS",
-				notes: responseText,
-				contextUpdates: { [`${node.id}_output`]: responseText }
-			};
-		} catch (error) {
-			if (isTransientError(error)) return {
-				status: "NEEDS_RETRY",
-				error
-			};
-			return {
-				status: "FAILURE",
-				error
+	/** Subscribe to session events. */
+	on(kind, handler) {
+		this._emitter.on(kind, handler);
+	}
+	/** Transition to CLOSED state and emit SESSION_END. */
+	close() {
+		this.state = SessionState.CLOSED;
+		this._emit(EventKind.SESSION_END, {});
+	}
+	/** Abort the current operation and close the session. */
+	abort() {
+		this._abortController.abort();
+		this.close();
+	}
+	/**
+	* Push a steering message onto the steering queue.
+	* It will be injected into history (as a SteeringTurn) before the next LLM call.
+	* Safe to call from any state (IDLE, PROCESSING, CLOSED); if CLOSED, the message
+	* is queued but will never be drained.
+	*/
+	steer(message) {
+		this._steeringQueue.push(message);
+	}
+	/**
+	* Push a follow-up message onto the follow-up queue.
+	* After the current processInput cycle completes naturally (no more tool calls),
+	* the first queued follow-up triggers a new processInput cycle recursively.
+	* PROCESSING_END is not emitted until all follow-ups are exhausted.
+	* Safe to call from any state.
+	*/
+	follow_up(message) {
+		this._followupQueue.push(message);
+	}
+	/**
+	* Construct and emit a SessionEvent.
+	* Internal — underscore prefix signals non-public API.
+	*/
+	_emit(kind, data = {}) {
+		const event = {
+			kind,
+			timestamp: new Date(),
+			session_id: this.id,
+			data
+		};
+		this._emitter.emit(kind, event);
+	}
+	/**
+	* Dequeue all steering messages, append as SteeringTurns, emit STEERING_INJECTED.
+	* Called before each LLM call and after tool execution.
+	* Story 48-8 will extend this method.
+	*/
+	_drainSteering() {
+		while (this._steeringQueue.length > 0) {
+			const content = this._steeringQueue.shift();
+			const turn = {
+				type: "steering",
+				content,
+				timestamp: new Date()
 			};
+			this.history.push(turn);
+			this._emit(EventKind.STEERING_INJECTED, { content });
 		}
-	};
-}
-
-//#endregion
-//#region packages/factory/dist/handlers/tool.js
-/**
-* Duck-typing guard: returns true if `parsed` conforms to the ScenarioRunResult
-* shape (has summary.total and summary.passed as numbers).
-*
+	}
+	/**
+	* Process a user input string through the agentic loop.
+	*
+	* Appends a UserTurn, then repeatedly calls the LLM and executes tool calls
+	* until natural completion (no tool calls) or a configured limit is hit.
+	*
+	* After natural completion, drains the follow-up queue (FIFO) by recursively
+	* calling processInput for each queued message. PROCESSING_END is only emitted
+	* when the follow-up queue is fully exhausted.
+	*/
+	async processInput(userInput) {
+		this.state = SessionState.PROCESSING;
+		const userTurn = {
+			type: "user",
+			content: userInput,
+			timestamp: new Date()
+		};
+		this.history.push(userTurn);
+		this._emit(EventKind.USER_INPUT, { content: userInput });
+		let roundCount = 0;
+		const loopDetector = new LoopDetector({
+			windowSize: this.config.loop_detection_window,
+			enabled: this.config.enable_loop_detection
+		});
+		try {
+			while (true) {
+				const totalTurns = this.history.length;
+				if (this.config.max_turns > 0 && totalTurns >= this.config.max_turns) {
+					this._emit(EventKind.TURN_LIMIT, {
+						total_turns: totalTurns,
+						reason: "max_turns"
+					});
+					break;
+				}
+				if (this.config.max_tool_rounds_per_input > 0 && roundCount >= this.config.max_tool_rounds_per_input) {
+					this._emit(EventKind.TURN_LIMIT, {
+						round: roundCount,
+						reason: "max_tool_rounds_per_input"
+					});
+					break;
+				}
+				if (this._abortController.signal.aborted) break;
+				this._drainSteering();
+				const response = await this.llmClient.complete(buildLLMRequest(this));
+				const assistantTurn = {
+					type: "assistant",
+					content: response.content,
+					tool_calls: response.toolCalls ?? [],
+					reasoning: null,
+					usage: response.usage,
+					response_id: response.id ?? null,
+					timestamp: new Date()
+				};
+				this.history.push(assistantTurn);
+				this._emit(EventKind.ASSISTANT_TEXT_END, {
+					text: response.content,
+					reasoning: null
+				});
+				if (!response.toolCalls || response.toolCalls.length === 0) {
+					if (this._followupQueue.length > 0) {
+						const nextInput = this._followupQueue.shift();
+						await this.processInput(nextInput);
+						return;
+					}
+					break;
+				}
+				roundCount++;
+				const toolResults = await this._executeToolCalls(response.toolCalls);
+				const toolResultsTurn = {
+					type: "tool_results",
+					results: toolResults,
+					timestamp: new Date()
+				};
+				this.history.push(toolResultsTurn);
+				let loopTriggered = false;
+				for (const tc of response.toolCalls) {
+					const detected = loopDetector.record(tc.name, tc.arguments);
+					if (detected) loopTriggered = true;
+				}
+				this._drainSteering();
+				if (loopTriggered) {
+					const warningMessage = `Loop detected: the last ${this.config.loop_detection_window} tool calls follow a repeating pattern. Try a different approach.`;
+					const loopTurn = {
+						type: "steering",
+						content: warningMessage,
+						timestamp: new Date()
+					};
+					this.history.push(loopTurn);
+					this._emit(EventKind.LOOP_DETECTION, { message: warningMessage });
+				}
+			}
+			this.state = SessionState.IDLE;
+			this._emit(EventKind.PROCESSING_END, {});
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this._emit(EventKind.ERROR, { message });
+			this.state = SessionState.CLOSED;
+			throw err;
+		}
+	}
+	/** Dispatch tool calls in parallel or sequentially based on provider profile. */
+	async _executeToolCalls(toolCalls) {
+		if (this.providerProfile.supports_parallel_tool_calls && toolCalls.length > 1) return Promise.all(toolCalls.map((tc) => this._executeSingleTool(tc)));
+		else {
+			const results = [];
+			for (const tc of toolCalls) results.push(await this._executeSingleTool(tc));
+			return results;
+		}
+	}
+	/** Execute a single tool call: lookup, emit events, delegate to registry, truncate. */
+	async _executeSingleTool(toolCall) {
+		this._emit(EventKind.TOOL_CALL_START, {
+			tool_name: toolCall.name,
+			call_id: toolCall.id
+		});
+		const toolDef = this._toolRegistry.get(toolCall.name);
+		if (!toolDef) {
+			const errorContent = `Unknown tool: ${toolCall.name}`;
+			this._emit(EventKind.TOOL_CALL_END, {
+				call_id: toolCall.id,
+				output: errorContent,
+				is_error: true
+			});
+			return {
+				tool_call_id: toolCall.id,
+				content: errorContent,
+				is_error: true
+			};
+		}
+		const toolResult = await this._toolRegistry.execute(toolCall.name, toolCall.arguments, this.executionEnv);
+		const rawOutput = toolResult.content;
+		const truncatedOutput = truncateToolOutput(rawOutput, toolCall.name, this.config);
+		this._emit(EventKind.TOOL_CALL_END, {
+			call_id: toolCall.id,
+			output: rawOutput,
+			is_error: toolResult.isError
+		});
+		return {
+			tool_call_id: toolCall.id,
+			content: truncatedOutput,
+			is_error: toolResult.isError
+		};
+	}
+};
+/**
+* Create a new CodingAgentSession.
+* SESSION_START is emitted synchronously during construction.
+*/
+function createSession(options) {
+	return new CodingAgentSession(options);
+}
+
+//#endregion
+//#region packages/factory/dist/backend/direct-backend.js
+var DirectCodergenBackend = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async run(node, prompt, _context) {
+		const { llmClient, providerProfile, executionEnv, config, onEvent } = this.options;
+		const sessionOptions = {
+			llmClient,
+			providerProfile,
+			executionEnv
+		};
+		if (config !== void 0) sessionOptions.config = config;
+		const session = createSession(sessionOptions);
+		let turnLimitHit = false;
+		if (onEvent) for (const kind of Object.values(EventKind)) session.on(kind, onEvent);
+		session.on(EventKind.TURN_LIMIT, () => {
+			turnLimitHit = true;
+		});
+		try {
+			await session.processInput(prompt);
+		} catch (err) {
+			const failureReason = err instanceof Error ? err.message : String(err);
+			return {
+				status: "FAILURE",
+				failureReason
+			};
+		} finally {
+			session.close();
+		}
+		if (turnLimitHit) return {
+			status: "FAILURE",
+			failureReason: "turn limit exceeded"
+		};
+		const finalAssistantTurn = [...session.history].reverse().find((t) => t.type === "assistant");
+		if (!finalAssistantTurn || finalAssistantTurn.type !== "assistant") return { status: "SUCCESS" };
+		return {
+			status: "SUCCESS",
+			contextUpdates: { [`${node.id}_output`]: finalAssistantTurn.content }
+		};
+	}
+};
+function createDirectCodergenBackend(options) {
+	return new DirectCodergenBackend(options);
+}
+
+//#endregion
+//#region packages/factory/dist/llm/model-registry.js
+const DEFAULT_PATTERNS = [
+	{
+		pattern: /^claude-/i,
+		provider: "anthropic"
+	},
+	{
+		pattern: /^gpt-/i,
+		provider: "openai"
+	},
+	{
+		pattern: /^o\d(-|$)/i,
+		provider: "openai"
+	},
+	{
+		pattern: /^gemini-/i,
+		provider: "gemini"
+	}
+];
+var ModelRegistry = class {
+	patterns = [...DEFAULT_PATTERNS];
+	/**
+	* Register a glob-style pattern (supports `*` wildcard) mapped to a provider name.
+	* Custom patterns are prepended so they override defaults.
+	*/
+	register(globPattern, provider) {
+		const escaped = globPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+		this.patterns.unshift({
+			pattern: new RegExp(`^${escaped}$`, "i"),
+			provider
+		});
+	}
+	/**
+	* Resolve a model string to a provider name.
+	* Returns `null` if no pattern matches.
+	*/
+	resolve(model) {
+		for (const { pattern, provider } of this.patterns) if (pattern.test(model)) return provider;
+		return null;
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/llm/middleware/types.js
+/**
+* Composes middleware into a single next-function.
+* First middleware in the array is the outermost wrapper (runs first / last to finish).
+* Implemented via reduceRight so the array order matches onion semantics.
+*/
+function buildMiddlewareChain(middleware, base) {
+	return middleware.reduceRight((next, mw) => (req) => mw(req, next), base);
+}
+
+//#endregion
+//#region packages/factory/dist/llm/client.js
+var LLMClient = class {
+	adapters = new Map();
+	modelRegistry = new ModelRegistry();
+	_middleware = [];
+	constructor(adapters) {
+		if (adapters) for (const [name, adapter] of Object.entries(adapters)) this.registerProvider(name, adapter);
+	}
+	registerProvider(name, adapter) {
+		this.adapters.set(name, adapter);
+	}
+	registerModelPattern(pattern, providerName) {
+		this.modelRegistry.register(pattern, providerName);
+	}
+	/**
+	* Register a middleware function that wraps every `complete()` call.
+	* Returns `this` for chaining.
+	*/
+	use(mw) {
+		this._middleware.push(mw);
+		return this;
+	}
+	resolveAdapter(model) {
+		const providerName = this.modelRegistry.resolve(model);
+		const registered = [...this.adapters.keys()];
+		if (!providerName) throw new Error(`No provider matched model "${model}". Registered providers: ${registered.join(", ") || "(none)"}`);
+		const adapter = this.adapters.get(providerName);
+		if (!adapter) throw new Error(`Provider "${providerName}" matched model "${model}" but is not registered. Registered providers: ${registered.join(", ") || "(none)"}`);
+		return adapter;
+	}
+	async complete(request) {
+		const baseNext = (req) => this.resolveAdapter(req.model).complete(req);
+		const chain = buildMiddlewareChain(this._middleware, baseNext);
+		return chain(request);
+	}
+	async *stream(request) {
+		yield* this.resolveAdapter(request.model).stream(request);
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/llm/types.js
+/**
+* Error thrown by provider adapters that includes the HTTP status code.
+* The retry middleware uses `statusCode` to determine if an error is retryable
+* (429, 500, 502, 503) vs non-retryable (400, 401, 403, 404).
+*/
+var LLMError = class extends Error {
+	statusCode;
+	provider;
+	constructor(message, statusCode, provider) {
+		super(message);
+		this.statusCode = statusCode;
+		this.provider = provider;
+		this.name = "LLMError";
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/llm/providers/anthropic.js
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1e3;
+const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+const PROMPT_CACHING_BETA = "prompt-caching-2024-07-31";
+function mapStopReason(raw) {
+	switch (raw) {
+		case "end_turn":
+		case "stop_sequence": return "stop";
+		case "max_tokens": return "length";
+		case "tool_use": return "tool_calls";
+		default: return "other";
+	}
+}
+function reasoningBudget(effort) {
+	switch (effort) {
+		case "low": return 1024;
+		case "medium": return 8192;
+		case "high": return 32e3;
+	}
+}
+var AnthropicAdapter = class {
+	name = "anthropic";
+	apiKey;
+	baseUrl;
+	anthropicVersion;
+	fetch;
+	constructor(options) {
+		this.apiKey = options.apiKey;
+		this.baseUrl = options.baseUrl ?? "https://api.anthropic.com";
+		this.anthropicVersion = options.anthropicVersion ?? DEFAULT_ANTHROPIC_VERSION;
+		this.fetch = options.fetch ?? globalThis.fetch;
+	}
+	async complete(request) {
+		const { body, betaHeaders } = this.buildRequestBody(request);
+		const headers = this.buildHeaders(betaHeaders);
+		const url = `${this.baseUrl}/v1/messages`;
+		for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+			const response = await this.fetch(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body)
+			});
+			if (response.status === 429) {
+				if (attempt === MAX_RETRIES) throw new LLMError(`[anthropic] Rate limit exceeded after ${MAX_RETRIES} retries`, 429, "anthropic");
+				const retryAfterStr = response.headers.get("Retry-After");
+				const retryAfter = retryAfterStr !== null ? parseInt(retryAfterStr, 10) * 1e3 : 0;
+				const backoff = Math.max(retryAfter, BASE_DELAY_MS * 2 ** attempt);
+				await new Promise((resolve$6) => setTimeout(resolve$6, backoff));
+				continue;
+			}
+			if (!response.ok) {
+				const errorBody = await response.json().catch(() => ({}));
+				const errorObj = errorBody?.error;
+				const message = typeof errorObj?.message === "string" ? errorObj.message : response.statusText;
+				throw new LLMError(`[anthropic] ${response.status}: ${message}`, response.status, "anthropic");
+			}
+			const raw = await response.json();
+			return this.parseResponse(raw, request.model);
+		}
+		throw new Error("[anthropic] Unexpected end of retry loop");
+	}
+	async *stream(_request) {
+		throw new Error("streaming not yet implemented");
+	}
+	buildRequestBody(request) {
+		const betaHeaders = [];
+		const anthropicExtra = request.extra?.anthropic;
+		const autoCache = anthropicExtra !== void 0 ? anthropicExtra["auto_cache"] !== false : true;
+		const extraBetas = anthropicExtra?.["beta_headers"];
+		if (Array.isArray(extraBetas)) for (const b of extraBetas) betaHeaders.push(b);
+		let systemBlocks;
+		if (request.systemPrompt) {
+			const block = {
+				type: "text",
+				text: request.systemPrompt
+			};
+			systemBlocks = [block];
+		}
+		const messages = this.translateMessages(request.messages);
+		const toolChoiceIsNone = request.toolChoice === "none";
+		let tools;
+		let toolChoice;
+		if (!toolChoiceIsNone && request.tools && request.tools.length > 0) {
+			tools = this.translateTools(request.tools);
+			toolChoice = this.mapToolChoice(request.toolChoice);
+		}
+		let cachingInjected = false;
+		if (autoCache) {
+			if (systemBlocks && systemBlocks.length > 0) {
+				const lastBlock = systemBlocks[systemBlocks.length - 1];
+				if (lastBlock && !("cache_control" in lastBlock && lastBlock.cache_control)) {
+					lastBlock.cache_control = { type: "ephemeral" };
+					cachingInjected = true;
+				}
+			}
+			if (tools && tools.length > 0) {
+				const lastTool = tools[tools.length - 1];
+				if (lastTool && !lastTool.cache_control) {
+					lastTool.cache_control = { type: "ephemeral" };
+					cachingInjected = true;
+				}
+			}
+		}
+		if (cachingInjected && !betaHeaders.includes(PROMPT_CACHING_BETA)) betaHeaders.push(PROMPT_CACHING_BETA);
+		const body = {
+			model: request.model,
+			max_tokens: request.maxTokens ?? DEFAULT_MAX_TOKENS,
+			messages
+		};
+		if (systemBlocks) body.system = systemBlocks;
+		if (tools) body.tools = tools;
+		if (toolChoice) body.tool_choice = toolChoice;
+		if (request.temperature !== void 0) body.temperature = request.temperature;
+		if (request.reasoningEffort) body.thinking = {
+			type: "enabled",
+			budget_tokens: reasoningBudget(request.reasoningEffort)
+		};
+		return {
+			body,
+			betaHeaders
+		};
+	}
+	buildHeaders(betaHeaders) {
+		const headers = {
+			"Content-Type": "application/json",
+			"x-api-key": this.apiKey,
+			"anthropic-version": this.anthropicVersion
+		};
+		if (betaHeaders.length > 0) headers["anthropic-beta"] = betaHeaders.join(",");
+		return headers;
+	}
+	translateMessages(messages) {
+		const filtered = messages.filter((m) => m.role !== "system");
+		const translated = filtered.map((msg) => {
+			if (msg.role === "tool") {
+				const content$1 = msg.content.map((part) => {
+					if (part.toolResult) return {
+						type: "tool_result",
+						tool_use_id: part.toolResult.toolCallId,
+						content: part.toolResult.content,
+						is_error: part.toolResult.isError
+					};
+					return {
+						type: "text",
+						text: part.text ?? ""
+					};
+				});
+				return {
+					role: "user",
+					content: content$1
+				};
+			}
+			const role = msg.role;
+			const content = msg.content.map((part) => {
+				if (part.kind === "text") return {
+					type: "text",
+					text: part.text ?? ""
+				};
+				if (part.kind === "tool_call" && part.toolCall) return {
+					type: "tool_use",
+					id: part.toolCall.id,
+					name: part.toolCall.name,
+					input: part.toolCall.arguments
+				};
+				if (part.kind === "tool_result" && part.toolResult) return {
+					type: "tool_result",
+					tool_use_id: part.toolResult.toolCallId,
+					content: part.toolResult.content,
+					is_error: part.toolResult.isError
+				};
+				return {
+					type: "text",
+					text: part.text ?? ""
+				};
+			});
+			return {
+				role,
+				content
+			};
+		});
+		const merged = [];
+		for (const msg of translated) {
+			const last = merged[merged.length - 1];
+			if (last !== void 0 && last.role === msg.role) last.content = [...last.content, ...msg.content];
+			else merged.push({
+				role: msg.role,
+				content: [...msg.content]
+			});
+		}
+		return merged;
+	}
+	translateTools(tools) {
+		return tools.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			input_schema: tool.parameters
+		}));
+	}
+	mapToolChoice(toolChoice) {
+		if (!toolChoice || toolChoice === "none") return void 0;
+		if (toolChoice === "auto") return { type: "auto" };
+		if (toolChoice === "required") return { type: "any" };
+		if (typeof toolChoice === "object" && toolChoice.type === "function") return {
+			type: "tool",
+			name: toolChoice.name
+		};
+		return void 0;
+	}
+	parseResponse(raw, model) {
+		let content = "";
+		const toolCalls = [];
+		for (const block of raw.content) if (block.type === "text") content += block.text;
+		else if (block.type === "tool_use") toolCalls.push({
+			id: block.id,
+			name: block.name,
+			arguments: block.input,
+			rawArguments: JSON.stringify(block.input)
+		});
+		const stopReason = mapStopReason(raw.stop_reason);
+		const usage = {
+			inputTokens: raw.usage.input_tokens,
+			outputTokens: raw.usage.output_tokens,
+			totalTokens: raw.usage.input_tokens + raw.usage.output_tokens,
+			...raw.usage.cache_read_input_tokens !== void 0 ? { cacheReadTokens: raw.usage.cache_read_input_tokens } : {},
+			...raw.usage.cache_creation_input_tokens !== void 0 ? { cacheWriteTokens: raw.usage.cache_creation_input_tokens } : {}
+		};
+		return {
+			content,
+			toolCalls,
+			usage,
+			model: raw.model ?? model,
+			stopReason,
+			providerMetadata: { raw },
+			id: raw.id
+		};
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/llm/providers/openai.js
+var OpenAIAdapter = class {
+	name = "openai";
+	apiKey;
+	baseUrl;
+	orgId;
+	projectId;
+	timeout;
+	constructor(options = {}) {
+		const apiKey = options.apiKey ?? process.env["OPENAI_API_KEY"];
+		if (!apiKey) throw new Error("OPENAI_API_KEY is required");
+		this.apiKey = apiKey;
+		const rawBaseUrl = options.baseUrl ?? process.env["OPENAI_BASE_URL"] ?? "https://api.openai.com/v1";
+		this.baseUrl = rawBaseUrl.replace(/\/$/, "");
+		this.orgId = options.orgId ?? process.env["OPENAI_ORG_ID"];
+		this.projectId = options.projectId ?? process.env["OPENAI_PROJECT_ID"];
+		this.timeout = options.timeout ?? 3e5;
+	}
+	_defaultHeaders() {
+		const headers = {
+			Authorization: `Bearer ${this.apiKey}`,
+			"Content-Type": "application/json"
+		};
+		if (this.orgId) headers["OpenAI-Organization"] = this.orgId;
+		if (this.projectId) headers["OpenAI-Project"] = this.projectId;
+		return headers;
+	}
+	_translateContentParts(content, role) {
+		const parts = [];
+		for (const part of content) if (part.kind === "text" && part.text !== void 0) if (role === "user") parts.push({
+			type: "input_text",
+			text: part.text
+		});
+		else parts.push({
+			type: "output_text",
+			text: part.text
+		});
+		else if (part.kind === "tool_call" && part.toolCall) parts.push({
+			type: "function_call",
+			call_id: part.toolCall.id,
+			name: part.toolCall.name,
+			arguments: part.toolCall.rawArguments ?? JSON.stringify(part.toolCall.arguments)
+		});
+		return parts;
+	}
+	_translateMessages(request, body) {
+		if (request.systemPrompt) body.instructions = request.systemPrompt;
+		const input = [];
+		for (const msg of request.messages) {
+			if (msg.role === "system") continue;
+			if (msg.role === "user") input.push({
+				type: "message",
+				role: "user",
+				content: this._translateContentParts(msg.content, "user")
+			});
+			else if (msg.role === "assistant") input.push({
+				type: "message",
+				role: "assistant",
+				content: this._translateContentParts(msg.content, "assistant")
+			});
+			else if (msg.role === "tool") {
+				const callId = msg.toolCallId ?? this._extractToolCallId(msg);
+				const output = this._extractToolOutput(msg);
+				input.push({
+					type: "function_call_output",
+					call_id: callId,
+					output
+				});
+			}
+		}
+		body.input = input;
+	}
+	_extractToolCallId(msg) {
+		for (const part of msg.content) if (part.kind === "tool_result" && part.toolResult?.toolCallId) return part.toolResult.toolCallId;
+		return "";
+	}
+	_extractToolOutput(msg) {
+		for (const part of msg.content) if (part.kind === "text" && part.text !== void 0) return part.text;
+		for (const part of msg.content) if (part.kind === "tool_result" && part.toolResult?.content !== void 0) return String(part.toolResult.content);
+		return "";
+	}
+	_translateTools(request, body) {
+		if (request.tools && request.tools.length > 0) body.tools = request.tools.map((t) => ({
+			type: "function",
+			function: {
+				name: t.name,
+				description: t.description,
+				parameters: t.parameters
+			}
+		}));
+		if (request.toolChoice !== void 0) {
+			if (typeof request.toolChoice === "string") body.tool_choice = request.toolChoice;
+			else if (request.toolChoice.type === "function") body.tool_choice = {
+				type: "function",
+				function: { name: request.toolChoice.name }
+			};
+		}
+	}
+	_parseUsage(usage) {
+		const inputTokens = usage.input_tokens;
+		const outputTokens = usage.output_tokens;
+		const totalTokens = inputTokens + outputTokens;
+		const result = {
+			inputTokens,
+			outputTokens,
+			totalTokens
+		};
+		const reasoningTokens = usage.output_tokens_details?.reasoning_tokens;
+		if (reasoningTokens !== void 0 && reasoningTokens > 0) result.reasoningTokens = reasoningTokens;
+		const cacheReadTokens = usage.input_tokens_details?.cached_tokens;
+		if (cacheReadTokens !== void 0 && cacheReadTokens > 0) result.cacheReadTokens = cacheReadTokens;
+		return result;
+	}
+	_mapStopReason(response, hasToolCalls) {
+		if (response.status === "completed") return hasToolCalls ? "tool_calls" : "stop";
+		if (response.status === "incomplete") {
+			const reason = response.incomplete_details?.reason;
+			if (reason === "max_output_tokens") return "length";
+			if (reason === "content_filter") return "content_filter";
+		}
+		return "other";
+	}
+	async complete(request) {
+		const body = {
+			model: request.model,
+			input: []
+		};
+		this._translateMessages(request, body);
+		this._translateTools(request, body);
+		if (request.maxTokens !== void 0) body.max_output_tokens = request.maxTokens;
+		if (request.temperature !== void 0) body.temperature = request.temperature;
+		if (request.reasoningEffort !== void 0) body.reasoning = { effort: request.reasoningEffort };
+		if (request.extra?.openai) Object.assign(body, request.extra.openai);
+		const controller = new AbortController();
+		const timer = setTimeout(() => {
+			controller.abort();
+		}, this.timeout);
+		let rawResponse;
+		try {
+			rawResponse = await fetch(`${this.baseUrl}/responses`, {
+				method: "POST",
+				headers: this._defaultHeaders(),
+				body: JSON.stringify(body),
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+		if (!rawResponse.ok) {
+			let errorMessage = `OpenAI API error: ${rawResponse.status}`;
+			try {
+				const errorBody = await rawResponse.json();
+				if (errorBody.error?.message) errorMessage = `OpenAI API error ${rawResponse.status}: ${errorBody.error.message}`;
+			} catch {}
+			throw new LLMError(errorMessage, rawResponse.status, "openai");
+		}
+		const data = await rawResponse.json();
+		let content = "";
+		const toolCalls = [];
+		for (const item of data.output) if (item.type === "message") {
+			for (const part of item.content) if (part.type === "output_text") content += part.text;
+		} else if (item.type === "function_call") {
+			let parsedArgs = {};
+			try {
+				parsedArgs = JSON.parse(item.arguments);
+			} catch {}
+			toolCalls.push({
+				id: item.call_id,
+				name: item.name,
+				arguments: parsedArgs,
+				rawArguments: item.arguments
+			});
+		}
+		const stopReason = this._mapStopReason(data, toolCalls.length > 0);
+		const usage = this._parseUsage(data.usage);
+		return {
+			content,
+			toolCalls,
+			usage,
+			model: data.model,
+			stopReason,
+			providerMetadata: { id: data.id },
+			id: data.id
+		};
+	}
+	async *stream(request) {
+		const body = {
+			model: request.model,
+			input: [],
+			stream: true
+		};
+		this._translateMessages(request, body);
+		this._translateTools(request, body);
+		if (request.maxTokens !== void 0) body.max_output_tokens = request.maxTokens;
+		if (request.temperature !== void 0) body.temperature = request.temperature;
+		if (request.reasoningEffort !== void 0) body.reasoning = { effort: request.reasoningEffort };
+		if (request.extra) Object.assign(body, request.extra);
+		const controller = new AbortController();
+		const timer = setTimeout(() => {
+			controller.abort();
+		}, this.timeout);
+		let rawResponse;
+		try {
+			rawResponse = await fetch(`${this.baseUrl}/responses`, {
+				method: "POST",
+				headers: this._defaultHeaders(),
+				body: JSON.stringify(body),
+				signal: controller.signal
+			});
+		} catch (err) {
+			clearTimeout(timer);
+			throw err;
+		}
+		if (!rawResponse.ok) {
+			clearTimeout(timer);
+			let errorMessage = `OpenAI API error: ${rawResponse.status}`;
+			try {
+				const errorBody = await rawResponse.json();
+				if (errorBody.error?.message) errorMessage = `OpenAI API error ${rawResponse.status}: ${errorBody.error.message}`;
+			} catch {}
+			throw new LLMError(errorMessage, rawResponse.status, "openai");
+		}
+		try {
+			const text = await rawResponse.text();
+			const lines = text.split("\n");
+			let started = false;
+			let currentEventName = "";
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (trimmed.startsWith("event: ")) currentEventName = trimmed.slice(7).trim();
+				else if (trimmed.startsWith("data: ")) {
+					const dataStr = trimmed.slice(6).trim();
+					if (dataStr === "[DONE]") break;
+					let eventData;
+					try {
+						eventData = JSON.parse(dataStr);
+					} catch {
+						continue;
+					}
+					if (!started) {
+						started = true;
+						yield { type: "message_start" };
+					}
+					if (currentEventName === "response.output_text.delta") yield {
+						type: "text_delta",
+						delta: eventData["delta"] ?? ""
+					};
+					else if (currentEventName === "response.function_call_arguments.delta") {
+						const itemId = eventData["item_id"];
+						const toolCallDelta = { rawArguments: eventData["delta"] ?? "" };
+						if (itemId !== void 0) toolCallDelta.id = itemId;
+						yield {
+							type: "tool_call_delta",
+							toolCall: toolCallDelta
+						};
+					} else if (currentEventName === "response.output_item.done") {
+						const itemType = eventData["type"];
+						if (itemType === "function_call") {
+							const rawArgs = eventData["arguments"] ?? "";
+							let parsedArgs = {};
+							try {
+								parsedArgs = JSON.parse(rawArgs);
+							} catch {}
+							const callId = eventData["call_id"];
+							const callName = eventData["name"];
+							const doneToolCall = { arguments: parsedArgs };
+							if (callId !== void 0) doneToolCall.id = callId;
+							if (callName !== void 0) doneToolCall.name = callName;
+							yield {
+								type: "tool_call_delta",
+								toolCall: doneToolCall
+							};
+						}
+					} else if (currentEventName === "response.completed" || currentEventName === "response.created") {
+						if (currentEventName === "response.completed") {
+							const completedResponse = eventData["response"] ?? eventData;
+							const hasToolCalls = Array.isArray(completedResponse.output) && completedResponse.output.some((o) => o.type === "function_call");
+							const stopReason = this._mapStopReason(completedResponse, hasToolCalls);
+							yield {
+								type: "message_stop",
+								usage: this._parseUsage(completedResponse.usage),
+								finishReason: { reason: stopReason }
+							};
+						}
+					}
+				}
+			}
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/llm/providers/gemini.js
+var GeminiAdapter = class {
+	name = "gemini";
+	apiKey;
+	baseUrl;
+	timeout;
+	constructor(options = {}) {
+		const apiKey = options.apiKey ?? process.env["GEMINI_API_KEY"] ?? process.env["GOOGLE_API_KEY"];
+		if (!apiKey) throw new Error("GEMINI_API_KEY is required");
+		this.apiKey = apiKey;
+		const rawBaseUrl = options.baseUrl ?? process.env["GEMINI_BASE_URL"] ?? "https://generativelanguage.googleapis.com";
+		this.baseUrl = rawBaseUrl.replace(/\/$/, "");
+		this.timeout = options.timeout ?? 3e5;
+	}
+	_buildUrl(model, streaming) {
+		const action = streaming ? "streamGenerateContent" : "generateContent";
+		let url = `${this.baseUrl}/v1beta/models/${model}:${action}?key=${this.apiKey}`;
+		if (streaming) url += "&alt=sse";
+		return url;
+	}
+	_wrapResponse(content) {
+		try {
+			const parsed = JSON.parse(content);
+			if (typeof parsed === "object" && parsed !== null) return parsed;
+		} catch {}
+		return { result: content };
+	}
+	_translateParts(content) {
+		const parts = [];
+		for (const part of content) if (part.kind === "text" && part.text !== void 0) parts.push({ text: part.text });
+		else if (part.kind === "tool_call" && part.toolCall) parts.push({ functionCall: {
+			name: part.toolCall.name,
+			args: part.toolCall.arguments
+		} });
+		return parts;
+	}
+	/**
+	* Scan all messages to build a mapping from synthetic tool call IDs to function names.
+	* This is needed to translate tool-result messages back into Gemini's functionResponse format.
+	*/
+	_buildToolCallIdMap(messages) {
+		const idToName = new Map();
+		for (const msg of messages) if (msg.role === "assistant") {
+			for (const part of msg.content) if (part.kind === "tool_call" && part.toolCall) idToName.set(part.toolCall.id, part.toolCall.name);
+		}
+		return idToName;
+	}
+	_translateMessages(request, body) {
+		if (request.systemPrompt) body.systemInstruction = { parts: [{ text: request.systemPrompt }] };
+		const idToName = this._buildToolCallIdMap(request.messages);
+		const contents = [];
+		for (const msg of request.messages) {
+			if (msg.role === "system") continue;
+			if (msg.role === "user") contents.push({
+				role: "user",
+				parts: this._translateParts(msg.content)
+			});
+			else if (msg.role === "assistant") contents.push({
+				role: "model",
+				parts: this._translateParts(msg.content)
+			});
+			else if (msg.role === "tool") {
+				const toolResultParts = [];
+				for (const part of msg.content) if (part.kind === "tool_result" && part.toolResult) {
+					const { toolCallId, content } = part.toolResult;
+					const functionName = idToName.get(toolCallId) ?? toolCallId;
+					toolResultParts.push({ functionResponse: {
+						name: functionName,
+						response: this._wrapResponse(String(content))
+					} });
+				}
+				if (toolResultParts.length === 0) {
+					const callId = msg.toolCallId ?? "";
+					const functionName = idToName.get(callId) ?? callId;
+					const textContent = msg.content.filter((p) => p.kind === "text").map((p) => p.text ?? "").join("");
+					toolResultParts.push({ functionResponse: {
+						name: functionName,
+						response: this._wrapResponse(textContent)
+					} });
+				}
+				contents.push({
+					role: "user",
+					parts: toolResultParts
+				});
+			}
+		}
+		body.contents = contents;
+	}
+	_translateTools(request, body) {
+		if (request.tools && request.tools.length > 0) body.tools = [{ functionDeclarations: request.tools.map((t) => ({
+			name: t.name,
+			description: t.description,
+			parameters: t.parameters
+		})) }];
+		if (request.toolChoice !== void 0) {
+			if (request.toolChoice === "auto") body.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+			else if (request.toolChoice === "none") body.toolConfig = { functionCallingConfig: { mode: "NONE" } };
+			else if (request.toolChoice === "required") body.toolConfig = { functionCallingConfig: { mode: "ANY" } };
+			else if (typeof request.toolChoice === "object" && request.toolChoice.type === "function") body.toolConfig = { functionCallingConfig: {
+				mode: "ANY",
+				allowedFunctionNames: [request.toolChoice.name]
+			} };
+		}
+	}
+	_parseUsage(usageMetadata) {
+		const inputTokens = usageMetadata.promptTokenCount ?? 0;
+		const outputTokens = usageMetadata.candidatesTokenCount ?? 0;
+		const totalTokens = inputTokens + outputTokens;
+		const result = {
+			inputTokens,
+			outputTokens,
+			totalTokens
+		};
+		if (usageMetadata.thoughtsTokenCount !== void 0 && usageMetadata.thoughtsTokenCount > 0) result.reasoningTokens = usageMetadata.thoughtsTokenCount;
+		if (usageMetadata.cachedContentTokenCount !== void 0 && usageMetadata.cachedContentTokenCount > 0) result.cacheReadTokens = usageMetadata.cachedContentTokenCount;
+		return result;
+	}
+	_mapStopReason(finishReason, hasToolCalls) {
+		if (hasToolCalls) return "tool_calls";
+		switch (finishReason) {
+			case "STOP": return "stop";
+			case "MAX_TOKENS": return "length";
+			case "SAFETY":
+			case "RECITATION": return "content_filter";
+			default: return "other";
+		}
+	}
+	async complete(request) {
+		const body = { contents: [] };
+		this._translateMessages(request, body);
+		this._translateTools(request, body);
+		const generationConfig = {};
+		if (request.maxTokens !== void 0) generationConfig.maxOutputTokens = request.maxTokens;
+		if (request.temperature !== void 0) generationConfig.temperature = request.temperature;
+		if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
+		if (request.extra?.gemini) Object.assign(body, request.extra.gemini);
+		const controller = new AbortController();
+		const timer = setTimeout(() => {
+			controller.abort();
+		}, this.timeout);
+		let rawResponse;
+		try {
+			rawResponse = await fetch(this._buildUrl(request.model, false), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(body),
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+		if (!rawResponse.ok) {
+			let errorMessage = `[gemini] ${rawResponse.status}`;
+			try {
+				const errorBody = await rawResponse.json();
+				if (errorBody.error?.message) errorMessage = `[gemini] ${rawResponse.status}: ${errorBody.error.message}`;
+			} catch {}
+			throw new LLMError(errorMessage, rawResponse.status, "gemini");
+		}
+		const data = await rawResponse.json();
+		const candidate = data.candidates?.[0];
+		const parts = candidate?.content?.parts ?? [];
+		const syntheticIdMap = new Map();
+		const toolCalls = [];
+		let content = "";
+		for (const part of parts) if ("text" in part && part.text !== void 0) {
+			const thoughtPart = part;
+			if (!thoughtPart.thought) content += thoughtPart.text;
+		} else if ("functionCall" in part) {
+			const synthId = `call_${randomUUID()}`;
+			syntheticIdMap.set(synthId, part.functionCall.name);
+			toolCalls.push({
+				id: synthId,
+				name: part.functionCall.name,
+				arguments: part.functionCall.args ?? {},
+				rawArguments: JSON.stringify(part.functionCall.args)
+			});
+		}
+		const stopReason = this._mapStopReason(candidate?.finishReason, toolCalls.length > 0);
+		const usage = this._parseUsage(data.usageMetadata ?? {
+			promptTokenCount: 0,
+			candidatesTokenCount: 0
+		});
+		return {
+			content,
+			toolCalls,
+			usage,
+			model: request.model,
+			stopReason,
+			providerMetadata: { model: data.modelVersion ?? request.model }
+		};
+	}
+	async *stream(request) {
+		const body = { contents: [] };
+		this._translateMessages(request, body);
+		this._translateTools(request, body);
+		const generationConfig = {};
+		if (request.maxTokens !== void 0) generationConfig.maxOutputTokens = request.maxTokens;
+		if (request.temperature !== void 0) generationConfig.temperature = request.temperature;
+		if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
+		if (request.extra) Object.assign(body, request.extra);
+		const controller = new AbortController();
+		const timer = setTimeout(() => {
+			controller.abort();
+		}, this.timeout);
+		let rawResponse;
+		try {
+			rawResponse = await fetch(this._buildUrl(request.model, true), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(body),
+				signal: controller.signal
+			});
+		} catch (err) {
+			clearTimeout(timer);
+			throw err;
+		}
+		if (!rawResponse.ok) {
+			clearTimeout(timer);
+			let errorMessage = `[gemini] ${rawResponse.status}`;
+			try {
+				const errorBody = await rawResponse.json();
+				if (errorBody.error?.message) errorMessage = `[gemini] ${rawResponse.status}: ${errorBody.error.message}`;
+			} catch {}
+			throw new LLMError(errorMessage, rawResponse.status, "gemini");
+		}
+		try {
+			const text = await rawResponse.text();
+			const lines = text.split("\n");
+			let started = false;
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed.startsWith("data: ")) continue;
+				const dataStr = trimmed.slice(6).trim();
+				if (dataStr === "[DONE]") break;
+				let chunk;
+				try {
+					chunk = JSON.parse(dataStr);
+				} catch {
+					continue;
+				}
+				if (!started) {
+					started = true;
+					yield { type: "message_start" };
+				}
+				const candidateParts = chunk.candidates?.[0]?.content?.parts ?? [];
+				for (const part of candidateParts) if ("text" in part && part.text !== void 0) {
+					const thoughtPart = part;
+					if (!thoughtPart.thought) yield {
+						type: "text_delta",
+						delta: thoughtPart.text
+					};
+				} else if ("functionCall" in part) {
+					const synthId = `call_${randomUUID()}`;
+					yield {
+						type: "tool_call_delta",
+						toolCall: {
+							id: synthId,
+							name: part.functionCall.name,
+							arguments: part.functionCall.args ?? {}
+						}
+					};
+				}
+				if (chunk.usageMetadata) {
+					const finishReason = chunk.candidates?.[0]?.finishReason;
+					const hasToolCalls = candidateParts.some((p) => "functionCall" in p);
+					const stopReason = this._mapStopReason(finishReason, hasToolCalls);
+					yield {
+						type: "message_stop",
+						usage: this._parseUsage(chunk.usageMetadata),
+						finishReason: { reason: stopReason }
+					};
+				}
+			}
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/agent/tools/shared.js
+/**
+* Creates the five shared tools: read_file, write_file, shell, grep, glob.
+*/
+function createSharedTools(shellTimeoutMs = 1e4) {
+	return [
+		createReadFileTool(),
+		createWriteFileTool(),
+		createShellTool(shellTimeoutMs),
+		createGrepTool(shellTimeoutMs),
+		createGlobTool()
+	];
+}
+function createReadFileTool() {
+	return {
+		name: "read_file",
+		description: "Read a file from the filesystem, with optional offset and limit for line ranges. Returns content with 1-based line numbers.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Path to the file to read"
+				},
+				offset: {
+					type: "number",
+					minimum: 1,
+					description: "Line number to start reading from (1-based, optional)"
+				},
+				limit: {
+					type: "number",
+					minimum: 1,
+					description: "Maximum number of lines to read (optional)"
+				}
+			},
+			required: ["path"]
+		},
+		outputTruncation: 5e4,
+		async executor(args, _env) {
+			const raw = await readFile$1(args.path, "utf-8");
+			const lines = raw.split("\n");
+			const offset = args.offset !== void 0 ? args.offset - 1 : 0;
+			const slice = args.limit !== void 0 ? lines.slice(offset, offset + args.limit) : lines.slice(offset);
+			const numbered = slice.map((line, i) => {
+				const lineNum = offset + i + 1;
+				return `${String(lineNum).padStart(3)}\t${line}`;
+			});
+			return numbered.join("\n");
+		}
+	};
+}
+function createWriteFileTool() {
+	return {
+		name: "write_file",
+		description: "Write content to a file, creating parent directories if needed.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Path to the file to write"
+				},
+				content: {
+					type: "string",
+					description: "Content to write to the file"
+				}
+			},
+			required: ["path", "content"]
+		},
+		async executor(args, _env) {
+			const dir = dirname$1(args.path);
+			await mkdir$1(dir, { recursive: true });
+			const bytes = Buffer.byteLength(args.content, "utf-8");
+			await writeFile$1(args.path, args.content, "utf-8");
+			return `Wrote ${bytes} bytes to ${args.path}`;
+		}
+	};
+}
+function createShellTool(shellTimeoutMs) {
+	return {
+		name: "shell",
+		description: "Execute a shell command and return its output.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				command: {
+					type: "string",
+					description: "Shell command to execute"
+				},
+				timeout_ms: {
+					type: "number",
+					description: "Timeout in milliseconds (optional)"
+				}
+			},
+			required: ["command"]
+		},
+		outputTruncation: 1e4,
+		async executor(args, env) {
+			const timeout = args.timeout_ms !== void 0 ? args.timeout_ms : shellTimeoutMs;
+			const result = await env.exec(args.command, timeout);
+			if (result.exitCode !== 0) throw new Error([result.stdout, result.stderr].filter(Boolean).join("\n") || `Command failed with exit code ${result.exitCode}`);
+			const combined = [result.stdout, result.stderr].filter(Boolean).join("\n");
+			return combined || `(exit code ${result.exitCode})`;
+		}
+	};
+}
+function createGrepTool(shellTimeoutMs) {
+	return {
+		name: "grep",
+		description: "Search for a regex pattern in files. Returns matching lines with filenames and line numbers.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				pattern: {
+					type: "string",
+					description: "Regex pattern to search for"
+				},
+				paths: {
+					type: "array",
+					items: { type: "string" },
+					description: "File paths or directories to search in"
+				}
+			},
+			required: ["pattern", "paths"]
+		},
+		outputTruncation: 1e4,
+		async executor(args, env) {
+			if (/[`$\\]/.test(args.pattern) && /[`$]/.test(args.pattern)) return nodeGrepFallback(args.pattern, args.paths);
+			const escapedPattern = args.pattern.replace(/"/g, "\\\"");
+			const escapedPaths = args.paths.map((p) => `"${p.replace(/"/g, "\\\"")}"`).join(" ");
+			const cmd = `rg --no-heading -n -- "${escapedPattern}" ${escapedPaths} 2>&1`;
+			try {
+				const result = await env.exec(cmd, shellTimeoutMs);
+				if (result.exitCode === 0 || result.stdout.trim() !== "") return result.stdout || result.stderr;
+				if (result.exitCode === 1) return result.stdout;
+				throw new Error("rg not available");
+			} catch (_err) {
+				return nodeGrepFallback(args.pattern, args.paths);
+			}
+		}
+	};
+}
+async function nodeGrepFallback(pattern, paths) {
+	const regex$1 = new RegExp(pattern);
+	const results = [];
+	async function scanFile(filePath) {
+		try {
+			const content = await readFile$1(filePath, "utf-8");
+			const lines = content.split("\n");
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i] ?? "";
+				if (regex$1.test(line)) results.push(`${filePath}:${i + 1}:${line}`);
+			}
+		} catch {}
+	}
+	async function scanPath(p) {
+		try {
+			const entries = await readdir$1(p, { withFileTypes: true });
+			for (const entry of entries) {
+				const full = join$1(p, entry.name);
+				if (entry.isDirectory()) await scanPath(full);
+				else await scanFile(full);
+			}
+		} catch {
+			await scanFile(p);
+		}
+	}
+	for (const p of paths) await scanPath(resolve$1(p));
+	return results.join("\n");
+}
+function createGlobTool() {
+	return {
+		name: "glob",
+		description: "Find files matching a glob pattern. Returns newline-separated matching paths.",
+		inputSchema: {
+			type: "object",
+			properties: { pattern: {
+				type: "string",
+				description: "Glob pattern to match files against"
+			} },
+			required: ["pattern"]
+		},
+		outputTruncation: 5e3,
+		async executor(args, env) {
+			return manualGlob(args.pattern, env);
+		}
+	};
+}
+async function manualGlob(pattern, env) {
+	try {
+		const result = await env.exec(`find . -path "./${pattern}" 2>/dev/null || true`, 5e3);
+		return result.stdout.trim();
+	} catch {
+		return "";
+	}
+}
+
+//#endregion
+//#region packages/factory/dist/agent/tools/anthropic-tools.js
+/**
+* Creates the edit_file tool used by Anthropic (Claude) models.
+* Performs exact string search-and-replace on file contents.
+*/
+function createEditFileTool() {
+	return {
+		name: "edit_file",
+		description: "Edit a file by replacing an exact string. The old_string must appear exactly once in the file. Provide enough context to uniquely identify the target location.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Path to the file to edit"
+				},
+				old_string: {
+					type: "string",
+					description: "Exact string to search for (must be unique in the file)"
+				},
+				new_string: {
+					type: "string",
+					description: "String to replace old_string with"
+				}
+			},
+			required: [
+				"path",
+				"old_string",
+				"new_string"
+			]
+		},
+		async executor(args, _env) {
+			const content = await readFile$1(args.path, "utf-8");
+			let count = 0;
+			let pos = 0;
+			while ((pos = content.indexOf(args.old_string, pos)) !== -1) {
+				count++;
+				pos += args.old_string.length;
+			}
+			if (count === 0) throw new Error("old_string not found in file");
+			if (count > 1) throw new Error(`old_string is ambiguous (found ${count} times)`);
+			const updated = content.replace(args.old_string, args.new_string);
+			await writeFile$1(args.path, updated, "utf-8");
+			return `Edited ${args.path}`;
+		}
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/agent/tools/openai-tools.js
+/**
+* Creates the apply_patch tool used by OpenAI models.
+* Accepts v4a-format patch strings.
+*/
+function createApplyPatchTool() {
+	return {
+		name: "apply_patch",
+		description: "Apply a v4a-format patch to modify files. Format: *** Begin Patch\\n*** Update File: <path>\\n@@ <context>\\n-<removed line>\\n+<added line>\\n*** End Patch",
+		inputSchema: {
+			type: "object",
+			properties: { patch: {
+				type: "string",
+				description: "v4a format patch string. Uses *** Begin Patch / *** End Patch delimiters, *** Update File: <path> or *** Add File: <path> headers, @@ hunk markers, and -/+ diff lines."
+			} },
+			required: ["patch"]
+		},
+		async executor(args, env) {
+			return applyV4aPatch(args.patch, env.workdir);
+		}
+	};
+}
+/**
+* Applies a v4a-format patch string to the filesystem.
+* Exported as a pure helper for independent testing.
+*/
+async function applyV4aPatch(patch, workdir) {
+	if (!patch.includes("*** Begin Patch")) throw new Error("Malformed patch: missing *** Begin Patch delimiter");
+	if (!patch.includes("*** End Patch")) throw new Error("Malformed patch: missing *** End Patch delimiter");
+	const lines = patch.split("\n");
+	const changedFiles = [];
+	let i = 0;
+	while (i < lines.length && !(lines[i] ?? "").includes("*** Begin Patch")) i++;
+	i++;
+	while (i < lines.length) {
+		const line = lines[i] ?? "";
+		if (line.includes("*** End Patch")) break;
+		if (line.startsWith("*** Update File: ")) {
+			const filePath = line.slice(17).trim();
+			const absPath = join$1(workdir, filePath);
+			i++;
+			i = await applyUpdateBlock(lines, i, absPath);
+			changedFiles.push(filePath);
+		} else if (line.startsWith("*** Add File: ")) {
+			const filePath = line.slice(14).trim();
+			const absPath = join$1(workdir, filePath);
+			i++;
+			i = await applyAddBlock(lines, i, absPath);
+			changedFiles.push(filePath);
+		} else i++;
+	}
+	if (changedFiles.length === 0) throw new Error("Malformed patch: no file operations found");
+	return `Applied patch to: ${changedFiles.join(", ")}`;
+}
+/**
+* Apply an update block (hunks with +/- lines) to an existing file.
+* Returns the next line index after the block.
+*/
+async function applyUpdateBlock(lines, startIdx, absPath) {
+	let content;
+	try {
+		content = await readFile$1(absPath, "utf-8");
+	} catch {
+		throw new Error(`File not found: ${absPath}`);
+	}
+	const contentLines = content.split("\n");
+	let i = startIdx;
+	while (i < lines.length) {
+		const line = lines[i] ?? "";
+		if (line.startsWith("*** Update File: ") || line.startsWith("*** Add File: ") || line.includes("*** End Patch")) break;
+		if (line.startsWith("@@")) {
+			i++;
+			const removals = [];
+			const additions = [];
+			const context = [];
+			while (i < lines.length) {
+				const hunkLine = lines[i] ?? "";
+				if (hunkLine.startsWith("@@") || hunkLine.startsWith("*** Update File: ") || hunkLine.startsWith("*** Add File: ") || hunkLine.includes("*** End Patch")) break;
+				if (hunkLine.startsWith("-")) removals.push(hunkLine.slice(1));
+				else if (hunkLine.startsWith("+")) additions.push(hunkLine.slice(1));
+				else context.push(hunkLine.startsWith(" ") ? hunkLine.slice(1) : hunkLine);
+				i++;
+			}
+			if (removals.length > 0) applyHunk(contentLines, removals, additions, context);
+			else if (additions.length > 0) applyAdditionHunk(contentLines, additions, context);
+		} else i++;
+	}
+	await writeFile$1(absPath, contentLines.join("\n"), "utf-8");
+	return i;
+}
+/**
+* Apply a hunk with removals to contentLines (in-place mutation).
+*/
+function applyHunk(contentLines, removals, additions, _context) {
+	const firstRemoval = removals[0] ?? "";
+	const startIdx = contentLines.findIndex((l) => l === firstRemoval);
+	if (startIdx === -1) {
+		const trimIdx = contentLines.findIndex((l) => l.trim() === firstRemoval.trim());
+		if (trimIdx === -1) return;
+		contentLines.splice(trimIdx, removals.length, ...additions);
+		return;
+	}
+	contentLines.splice(startIdx, removals.length, ...additions);
+}
+/**
+* Apply a pure addition hunk (no removals) — insert after context.
+*/
+function applyAdditionHunk(contentLines, additions, context) {
+	if (context.length === 0) {
+		contentLines.push(...additions);
+		return;
+	}
+	const lastCtx = context[context.length - 1] ?? "";
+	let idx = -1;
+	for (let j$1 = contentLines.length - 1; j$1 >= 0; j$1--) if (contentLines[j$1] === lastCtx) {
+		idx = j$1;
+		break;
+	}
+	if (idx === -1) {
+		contentLines.push(...additions);
+		return;
+	}
+	contentLines.splice(idx + 1, 0, ...additions);
+}
+/**
+* Apply an add block (new file creation) from patch lines.
+* Returns the next line index after the block.
+*/
+async function applyAddBlock(lines, startIdx, absPath) {
+	let i = startIdx;
+	const fileLines = [];
+	while (i < lines.length) {
+		const line = lines[i] ?? "";
+		if (line.startsWith("*** Update File: ") || line.startsWith("*** Add File: ") || line.includes("*** End Patch")) break;
+		if (line.startsWith("+")) fileLines.push(line.slice(1));
+		i++;
+	}
+	await mkdir$1(dirname$1(absPath), { recursive: true });
+	await writeFile$1(absPath, fileLines.join("\n"), "utf-8");
+	return i;
+}
+
+//#endregion
+//#region packages/factory/dist/agent/tools/gemini-tools.js
+/**
+* Creates the read_many_files tool for Gemini models.
+* Reads multiple files and returns concatenated content with headers.
+*/
+function createReadManyFilesTool() {
+	return {
+		name: "read_many_files",
+		description: "Read multiple files and return their concatenated content with file headers.",
+		inputSchema: {
+			type: "object",
+			properties: { paths: {
+				type: "array",
+				items: { type: "string" },
+				description: "Array of file paths to read"
+			} },
+			required: ["paths"]
+		},
+		outputTruncation: 1e5,
+		async executor(args, _env) {
+			const parts = [];
+			for (const filePath of args.paths) try {
+				const content = await readFile$1(filePath, "utf-8");
+				const lines = content.split("\n");
+				const numbered = lines.map((line, i) => `${String(i + 1).padStart(3)}\t${line}`).join("\n");
+				parts.push(`=== ${filePath} ===\n${numbered}`);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				parts.push(`=== ${filePath} ===\n(error reading file: ${message})`);
+			}
+			return parts.join("\n\n");
+		}
+	};
+}
+/**
+* Creates the list_dir tool for Gemini models.
+* Returns a directory listing with entry types (dirs first, then alpha).
+*/
+function createListDirTool() {
+	return {
+		name: "list_dir",
+		description: "List directory contents with entry types ([DIR] or [FILE]), sorted dirs first then alphabetically.",
+		inputSchema: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Directory path to list"
+			} },
+			required: ["path"]
+		},
+		async executor(args, _env) {
+			const entries = await readdir$1(args.path, { withFileTypes: true });
+			const dirs = entries.filter((e) => e.isDirectory()).map((e) => `[DIR] ${e.name}`).sort();
+			const files = entries.filter((e) => !e.isDirectory()).map((e) => `[FILE] ${e.name}`).sort();
+			return [...dirs, ...files].join("\n");
+		}
+	};
+}
+/**
+* Creates the Gemini variant of edit_file.
+* Uses file_path (instead of path) as the parameter name to match gemini-cli conventions.
+*/
+function createGeminiEditFileTool() {
+	return {
+		name: "edit_file",
+		description: "Edit a file by replacing an exact string. The old_string must appear exactly once in the file.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description: "Path to the file to edit"
+				},
+				old_string: {
+					type: "string",
+					description: "Exact string to search for (must be unique in the file)"
+				},
+				new_string: {
+					type: "string",
+					description: "String to replace old_string with"
+				}
+			},
+			required: [
+				"file_path",
+				"old_string",
+				"new_string"
+			]
+		},
+		async executor(args, _env) {
+			const content = await readFile$1(args.file_path, "utf-8");
+			let count = 0;
+			let pos = 0;
+			while ((pos = content.indexOf(args.old_string, pos)) !== -1) {
+				count++;
+				pos += args.old_string.length;
+			}
+			if (count === 0) throw new Error("old_string not found in file");
+			if (count > 1) throw new Error(`old_string is ambiguous (found ${count} times)`);
+			const updated = content.replace(args.old_string, args.new_string);
+			await mkdir$1(dirname$1(args.file_path), { recursive: true });
+			await writeFile$1(args.file_path, updated, "utf-8");
+			return `Edited ${args.file_path}`;
+		}
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/agent/tools/profiles.js
+/**
+* Anthropic (Claude) provider profile.
+* Uses edit_file for exact string search-and-replace.
+*/
+var AnthropicProfile = class {
+	model;
+	id = "anthropic";
+	supports_streaming = true;
+	context_window_size = 2e5;
+	supports_parallel_tool_calls = true;
+	constructor(model) {
+		this.model = model;
+	}
+	build_system_prompt() {
+		return [
+			"You are a coding agent. You have access to tools for reading and modifying files, running shell commands, and searching code.",
+			"",
+			"Available tools:",
+			"- read_file: Read file contents with optional line range (offset/limit)",
+			"- write_file: Write content to a file (creates parent dirs as needed)",
+			"- edit_file: Replace an exact string in a file (old_string must be unique)",
+			"- shell: Execute shell commands",
+			"- grep: Search for patterns in files",
+			"- glob: Find files matching a pattern",
+			"",
+			"Guidelines:",
+			"- Always read files before editing them to understand their current content",
+			"- Use edit_file for targeted changes, write_file for full rewrites",
+			"- Prefer targeted edits over full file rewrites when possible"
+		].join("\n");
+	}
+	tools() {
+		return [...createSharedTools(12e4), createEditFileTool()];
+	}
+	provider_options() {
+		return { max_tokens: 4096 };
+	}
+};
+/**
+* OpenAI provider profile.
+* Uses apply_patch for v4a-format patch application.
+* Does NOT include edit_file.
+*/
+var OpenAIProfile = class {
+	model;
+	id = "openai";
+	supports_streaming = true;
+	context_window_size = 128e3;
+	supports_parallel_tool_calls = true;
+	constructor(model) {
+		this.model = model;
+	}
+	build_system_prompt() {
+		return [
+			"You are a coding agent. You have access to tools for reading and modifying files, running shell commands, and searching code.",
+			"",
+			"Available tools:",
+			"- read_file: Read file contents with optional line range",
+			"- write_file: Write content to a file",
+			"- apply_patch: Apply a v4a-format patch to modify files",
+			"- shell: Execute shell commands",
+			"- grep: Search for patterns in files",
+			"- glob: Find files matching a pattern"
+		].join("\n");
+	}
+	tools() {
+		return [...createSharedTools(1e4), createApplyPatchTool()];
+	}
+	provider_options() {
+		return {};
+	}
+};
+/**
+* Gemini provider profile.
+* Uses read_many_files, list_dir, and a Gemini-specific edit_file variant.
+*/
+var GeminiProfile = class {
+	model;
+	id = "gemini";
+	supports_streaming = true;
+	context_window_size = 1e6;
+	supports_parallel_tool_calls = true;
+	constructor(model) {
+		this.model = model;
+	}
+	build_system_prompt() {
+		return [
+			"You are a coding agent. You have access to tools for reading and modifying files, running shell commands, and searching code.",
+			"",
+			"Available tools:",
+			"- read_file: Read a single file with optional line range",
+			"- read_many_files: Read multiple files at once",
+			"- write_file: Write content to a file",
+			"- edit_file: Replace an exact string in a file",
+			"- list_dir: List directory contents",
+			"- shell: Execute shell commands",
+			"- grep: Search for patterns in files",
+			"- glob: Find files matching a pattern"
+		].join("\n");
+	}
+	tools() {
+		return [
+			...createSharedTools(1e4),
+			createReadManyFilesTool(),
+			createListDirTool(),
+			createGeminiEditFileTool()
+		];
+	}
+	provider_options() {
+		return {};
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/backend/direct-bootstrap.js
+/**
+* Bootstrap a DirectCodergenBackend for the given provider and model.
+*
+* Reads the required API key from the environment, instantiates the correct
+* provider adapter and profile, constructs an LLMClient, and returns a
+* DirectCodergenBackend configured with the given options.
+*
+* @throws Error if the required API key environment variable is missing
+* @throws Error if the provider string is not recognised
+*/
+function bootstrapDirectBackend(opts) {
+	const { provider, model, maxTurns, projectDir, onEvent } = opts;
+	const executionEnv = {
+		workdir: projectDir,
+		exec: (command, timeoutMs) => {
+			return new Promise((resolve$6) => {
+				try {
+					const stdout = execSync(command, {
+						cwd: projectDir,
+						timeout: timeoutMs,
+						encoding: "utf-8"
+					});
+					resolve$6({
+						stdout: stdout || "",
+						stderr: "",
+						exitCode: 0
+					});
+				} catch (err) {
+					const execError = err;
+					resolve$6({
+						stdout: execError.stdout ? String(execError.stdout) : "",
+						stderr: execError.stderr ? String(execError.stderr) : "",
+						exitCode: typeof execError.status === "number" ? execError.status : 1
+					});
+				}
+			});
+		}
+	};
+	const client = new LLMClient();
+	if (provider === "anthropic") {
+		const apiKey = process.env["ANTHROPIC_API_KEY"];
+		if (!apiKey) throw new Error("ANTHROPIC_API_KEY environment variable is required for direct backend with anthropic provider");
+		const adapter = new AnthropicAdapter({ apiKey });
+		client.registerProvider("anthropic", adapter);
+		client.registerModelPattern("claude-*", "anthropic");
+		const providerProfile = new AnthropicProfile(model);
+		return createDirectCodergenBackend({
+			llmClient: client,
+			providerProfile,
+			executionEnv,
+			config: { max_turns: maxTurns },
+			...onEvent !== void 0 ? { onEvent } : {}
+		});
+	}
+	if (provider === "openai") {
+		const apiKey = process.env["OPENAI_API_KEY"];
+		if (!apiKey) throw new Error("OPENAI_API_KEY environment variable is required for direct backend with openai provider");
+		const adapter = new OpenAIAdapter({ apiKey });
+		client.registerProvider("openai", adapter);
+		client.registerModelPattern("gpt-*", "openai");
+		const providerProfile = new OpenAIProfile(model);
+		return createDirectCodergenBackend({
+			llmClient: client,
+			providerProfile,
+			executionEnv,
+			config: { max_turns: maxTurns },
+			...onEvent !== void 0 ? { onEvent } : {}
+		});
+	}
+	if (provider === "gemini") {
+		const apiKey = process.env["GEMINI_API_KEY"];
+		if (!apiKey) throw new Error("GEMINI_API_KEY environment variable is required for direct backend with gemini provider");
+		const adapter = new GeminiAdapter({ apiKey });
+		client.registerProvider("gemini", adapter);
+		client.registerModelPattern("gemini-*", "gemini");
+		const providerProfile = new GeminiProfile(model);
+		return createDirectCodergenBackend({
+			llmClient: client,
+			providerProfile,
+			executionEnv,
+			config: { max_turns: maxTurns },
+			...onEvent !== void 0 ? { onEvent } : {}
+		});
+	}
+	throw new Error(`Unknown direct backend provider: ${provider}`);
+}
+
+//#endregion
+//#region packages/factory/dist/handlers/start.js
+/**
+* Handler for start nodes.
+* No side effects — edge selection drives the next step.
+*
+* Story 42-9.
+*/
+/** Handler for start nodes; no side effects; edge selection drives next step. */
+const startHandler = async (_node, _context, _graph) => {
+	return { status: "SUCCESS" };
+};
+
+//#endregion
+//#region packages/factory/dist/handlers/exit.js
+/**
+* Handler for exit/terminal nodes.
+* Signals successful graph completion with no side effects.
+*
+* Story 42-9.
+*/
+/** Handler for exit/terminal nodes; signals successful graph completion. */
+const exitHandler = async (_node, _context, _graph) => {
+	return { status: "SUCCESS" };
+};
+
+//#endregion
+//#region packages/factory/dist/handlers/conditional.js
+/**
+* Handler for conditional/branching nodes.
+* Routing is delegated entirely to edge selection (story 42-12).
+* This handler does nothing — it simply returns SUCCESS so the executor
+* can proceed to edge evaluation.
+*
+* Story 42-9.
+*/
+/**
+* Handler for conditional/branching nodes; routing is delegated entirely to
+* edge selection (story 42-12); this handler does nothing.
+*/
+const conditionalHandler = async (_node, _context, _graph) => {
+	return { status: "SUCCESS" };
+};
+
+//#endregion
+//#region packages/factory/dist/stylesheet/resolver.js
+/**
+* Specificity-based resolver for the model stylesheet.
+*
+* Given a parsed stylesheet and a graph node, `resolveNodeStyles` determines
+* which LLM routing properties apply to that node by:
+*   1. Filtering rules to only those whose selector matches the node.
+*   2. Sorting matching rules by specificity ascending (stable sort so that
+*      equal-specificity rules preserve source order).
+*   3. Iterating the sorted list and letting each rule overwrite properties
+*      — the last rule at the highest specificity wins; for ties the rule
+*      appearing later in the original stylesheet wins.
+*
+* **Caller contract**: `resolveNodeStyles` does NOT enforce the "explicit node
+* attribute wins" rule.  The caller (executor / node preparation layer) is
+* responsible for the final merge:
+* ```typescript
+* const resolved = resolveNodeStyles(node, stylesheet)
+* const finalModel = node.llmModel || resolved.llmModel || graph.defaultLlmModel || ''
+* ```
+*
+* Story 42-7.
+*/
+/**
+* Return `true` if the given `selector` matches the provided `node`.
+*
+* Matching rules:
+* - `universal`: always matches every node.
+* - `shape`: matches when `node.shape === selector.value`.
+* - `class`: matches when the node's `class` field, split on commas and
+*   trimmed, contains `selector.value` (case-sensitive).
+* - `id`: matches when `node.id === selector.value`.
+*/
+function matchesNode(node, selector) {
+	switch (selector.type) {
+		case "universal": return true;
+		case "shape": return node.shape === selector.value;
+		case "class": {
+			const tokens = node.class.split(",").map((t) => t.trim());
+			return tokens.includes(selector.value);
+		}
+		case "id": return node.id === selector.value;
+		default: return false;
+	}
+}
+/**
+* Resolve LLM routing properties for a single graph node using the parsed stylesheet.
+*
+* @param node       - The graph node to resolve properties for.
+* @param stylesheet - A parsed stylesheet (array of `StylesheetRule` in source order).
+* @returns A `ResolvedNodeStyles` object containing only the properties that
+*   were resolved from matching rules.  Properties absent from matching rules
+*   are omitted (not set to `undefined` explicitly).
+*
+* **Important**: this function does NOT check the node's own attributes.
+* Callers must give explicit node attributes (`node.llmModel`, etc.) priority
+* over the values returned here.
+*/
+function resolveNodeStyles(node, stylesheet) {
+	const matchingRules = stylesheet.filter((rule) => matchesNode(node, rule.selector));
+	matchingRules.sort((a, b) => a.selector.specificity - b.selector.specificity);
+	const resolved = {};
+	for (const rule of matchingRules) for (const decl of rule.declarations) if (decl.property === "llm_model") resolved.llmModel = decl.value;
+	else if (decl.property === "llm_provider") resolved.llmProvider = decl.value;
+	else if (decl.property === "reasoning_effort") resolved.reasoningEffort = decl.value;
+	return resolved;
+}
+
+//#endregion
+//#region packages/factory/dist/handlers/codergen-handler.js
+const DEFAULT_MODEL = "claude-sonnet-4-5";
+const DEFAULT_PROVIDER = "anthropic";
+const DEFAULT_REASONING_EFFORT = "medium";
+/**
+* Replace all `{{key}}` placeholders in `template` with the corresponding
+* values from `context`.  Missing keys resolve to empty string `""` without
+* throwing.
+*
+* @param template - The prompt template string (may contain `{{variable}}` tokens).
+* @param context  - The graph context to read values from.
+* @returns The fully-interpolated prompt string.
+*/
+function interpolatePrompt(template, context) {
+	return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+		return context.getString(key, "");
+	});
+}
+/**
+* Resolve the LLM routing properties for a graph node.
+*
+* Priority (highest wins):
+*   1. Node-level attributes (`node.llmModel`, `node.llmProvider`, `node.reasoningEffort`)
+*   2. Stylesheet-resolved values via `resolveNodeStyles`
+*   3. Per-option defaults (`options.defaultModel`, etc.)
+*   4. System defaults (`claude-sonnet-4-5`, `anthropic`, `medium`)
+*/
+function resolveModel(node, stylesheet, options) {
+	const stylesheetResolved = stylesheet ? resolveNodeStyles(node, stylesheet) : {};
+	const llm_model = node.llmModel || stylesheetResolved.llmModel || options?.defaultModel || DEFAULT_MODEL;
+	const llm_provider = node.llmProvider || stylesheetResolved.llmProvider || options?.defaultProvider || DEFAULT_PROVIDER;
+	const reasoning_effort = node.reasoningEffort || stylesheetResolved.reasoningEffort || options?.defaultReasoningEffort || DEFAULT_REASONING_EFFORT;
+	return {
+		llm_model,
+		llm_provider,
+		reasoning_effort
+	};
+}
+/**
+* Returns `true` for errors that are transient and should trigger a
+* `NEEDS_RETRY` outcome:
+*   - HTTP status 429 (rate limit)
+*   - Errors whose message contains `"timeout"`, `"ETIMEDOUT"`,
+*     `"ECONNRESET"`, or `"ECONNREFUSED"`
+*
+* All other errors are non-transient and map to `FAILURE`.
+*/
+function isTransientError(error) {
+	if (error == null) return false;
+	const status = error.status ?? error.statusCode;
+	if (status === 429) return true;
+	const message = error.message;
+	if (typeof message === "string") {
+		if (message.includes("timeout") || message.includes("ETIMEDOUT") || message.includes("ECONNRESET") || message.includes("ECONNREFUSED")) return true;
+	}
+	return false;
+}
+/**
+* Create a codergen node handler configured with the given options.
+*
+* @param options - Optional configuration (stylesheet, default model/provider/effort).
+* @returns A `NodeHandler` that:
+*   1. Interpolates the node's prompt (or label) against GraphContext.
+*   2. Resolves LLM routing properties.
+*   3. Calls the LLM client from `\@substrate-ai/core`.
+*   4. Returns a `SUCCESS` outcome with the response in `contextUpdates`,
+*      `NEEDS_RETRY` for transient errors, or `FAILURE` for others.
+*/
+function createCodergenHandler(options) {
+	return async (node, context, _graph) => {
+		const template = node.prompt || node.label || "";
+		const interpolatedPrompt = interpolatePrompt(template, context);
+		if (options?.backend) return options.backend.run(node, interpolatedPrompt, context);
+		if (node.backend === "direct" && options?.directBackend) return options.directBackend.run(node, interpolatedPrompt, context);
+		const { llm_model, llm_provider, reasoning_effort } = resolveModel(node, options?.stylesheet, options);
+		try {
+			const result = await callLLM({
+				model: llm_model,
+				provider: llm_provider,
+				reasoningEffort: reasoning_effort,
+				prompt: interpolatedPrompt
+			});
+			const responseText = result.text;
+			return {
+				status: "SUCCESS",
+				notes: responseText,
+				contextUpdates: { [`${node.id}_output`]: responseText }
+			};
+		} catch (error) {
+			if (isTransientError(error)) return {
+				status: "NEEDS_RETRY",
+				error
+			};
+			return {
+				status: "FAILURE",
+				error
+			};
+		}
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/handlers/tool.js
+/**
+* Duck-typing guard: returns true if `parsed` conforms to the ScenarioRunResult
+* shape (has summary.total and summary.passed as numbers).
+*
 * Detection is intentionally command-agnostic — it operates on the JSON shape
 * alone, not on the value of `node.toolCommand`.
 */
@@ -29176,19 +31392,19 @@ var HandlerRegistry = class {
 * `shape=box` nodes, and as the registry-level default for any node that has no
 * recognised type or shape mapping.
 */
-function createDefaultRegistry() {
+function createDefaultRegistry(options) {
 	const registry = new HandlerRegistry();
 	registry.register("start", startHandler);
 	registry.register("exit", exitHandler);
 	registry.register("conditional", conditionalHandler);
-	registry.register("codergen", createCodergenHandler());
+	registry.register("codergen", createCodergenHandler(options));
 	registry.register("tool", createToolHandler());
 	registry.register("wait.human", createWaitHumanHandler());
 	registry.registerShape("Mdiamond", "start");
 	registry.registerShape("Msquare", "exit");
 	registry.registerShape("diamond", "conditional");
 	registry.registerShape("box", "codergen");
-	registry.setDefault(createCodergenHandler());
+	registry.setDefault(createCodergenHandler(options));
 	return registry;
 }
 
@@ -34491,7 +36707,20 @@ const FactoryConfigSchema = z.object({
 		"dual-signal",
 		"scenario-primary",
 		"scenario-only"
-	]).default("dual-signal")
+	]).default("dual-signal"),
+	direct_backend: z.object({
+		provider: z.enum([
+			"anthropic",
+			"openai",
+			"gemini"
+		]).default("anthropic"),
+		model: z.string().default("claude-3-5-sonnet-20241022"),
+		max_turns: z.number().int().min(1).default(20)
+	}).default({
+		provider: "anthropic",
+		model: "claude-3-5-sonnet-20241022",
+		max_turns: 20
+	})
 }).strict();
 /**
 * Extends SubstrateConfigSchema with an optional `factory:` section.
@@ -34673,7 +36902,7 @@ const TOTAL_RULE_COUNT = 13;
 function registerFactoryCommand(program, options) {
 	const factoryCmd = program.command("factory").description("Factory pipeline and scenario management commands");
 	registerScenariosCommand(factoryCmd);
-	factoryCmd.command("run").description("Execute a DOT graph pipeline").option("--graph <path>", "Path to DOT graph file").option("--config <path>", "Path to config.yaml (default: auto-detect)").option("--events", "Emit NDJSON events to stdout").action(async (opts) => {
+	factoryCmd.command("run").description("Execute a DOT graph pipeline").option("--graph <path>", "Path to DOT graph file").option("--config <path>", "Path to config.yaml (default: auto-detect)").option("--events", "Emit NDJSON events to stdout").option("--backend <mode>", "Backend: cli | direct (overrides config factory.backend)").action(async (opts) => {
 		try {
 			const projectDir = process.cwd();
 			const graphPath = await resolveGraphPath(opts, projectDir);
@@ -34709,6 +36938,18 @@ function registerFactoryCommand(program, options) {
 					type: "factory:config-reloaded",
 					...e
 				}));
+				eventBus.on("agent:tool-call", (e) => emit({
+					type: "agent:tool-call",
+					...e
+				}));
+				eventBus.on("agent:loop-detected", (e) => emit({
+					type: "agent:loop-detected",
+					...e
+				}));
+				eventBus.on("agent:steering-injected", (e) => emit({
+					type: "agent:steering-injected",
+					...e
+				}));
 			}
 			process.stdout.write(`Running graph pipeline from ${graphPath}\n`);
 			const runId = randomUUID();
@@ -34717,6 +36958,63 @@ function registerFactoryCommand(program, options) {
 			await stateManager.initRun(dotSource);
 			/** wallClockCapMs: FactoryConfig.wall_clock_cap_seconds × 1000 (story 45-10) */
 			const factoryConfig = await loadFactoryConfig(projectDir, opts.config);
+			const effectiveBackend = opts.backend ?? factoryConfig.factory?.backend ?? "cli";
+			let directBackend;
+			if (effectiveBackend === "direct") {
+				let currentNodeId = "";
+				eventBus.on("graph:node-started", (e) => {
+					currentNodeId = e.nodeId;
+				});
+				const toolCallNameMap = new Map();
+				const onDirectEvent = (event) => {
+					if (event.kind === EventKind.TOOL_CALL_START) {
+						const toolName = event.data["tool_name"] ?? "";
+						const callId = event.data["call_id"] ?? "";
+						toolCallNameMap.set(callId, toolName);
+						eventBus.emit("agent:tool-call", {
+							runId,
+							nodeId: currentNodeId,
+							toolName,
+							direction: "call"
+						});
+					} else if (event.kind === EventKind.TOOL_CALL_END) {
+						const callId = event.data["call_id"] ?? "";
+						const toolName = toolCallNameMap.get(callId) ?? "";
+						toolCallNameMap.delete(callId);
+						eventBus.emit("agent:tool-call", {
+							runId,
+							nodeId: currentNodeId,
+							toolName,
+							direction: "result"
+						});
+					} else if (event.kind === EventKind.LOOP_DETECTION) eventBus.emit("agent:loop-detected", {
+						runId,
+						nodeId: currentNodeId,
+						windowSize: event.data["windowSize"] ?? 0,
+						pattern: event.data["pattern"] ?? []
+					});
+					else if (event.kind === EventKind.STEERING_INJECTED) eventBus.emit("agent:steering-injected", {
+						runId,
+						nodeId: currentNodeId,
+						message: event.data["content"] ?? ""
+					});
+				};
+				try {
+					const directBackendCfg = factoryConfig.factory?.direct_backend;
+					directBackend = bootstrapDirectBackend({
+						provider: directBackendCfg?.provider ?? "anthropic",
+						model: directBackendCfg?.model ?? "claude-3-5-sonnet-20241022",
+						maxTurns: directBackendCfg?.max_turns ?? 20,
+						projectDir,
+						onEvent: onDirectEvent
+					});
+				} catch (err) {
+					const msg = err instanceof Error ? err.message : String(err);
+					process.stderr.write(`Error: ${msg}\n`);
+					process.exit(1);
+					return;
+				}
+			}
 			const adapter = options?.createAdapter ? options.createAdapter(projectDir) : createDatabaseAdapter$1({
 				backend: "auto",
 				basePath: projectDir
@@ -34726,7 +37024,7 @@ function registerFactoryCommand(program, options) {
 			const executorConfig = {
 				runId,
 				logsRoot,
-				handlerRegistry: createDefaultRegistry(),
+				handlerRegistry: createDefaultRegistry(directBackend ? { directBackend } : void 0),
 				eventBus,
 				dotSource,
 				adapter,
@@ -36454,4 +38752,4 @@ function registerRunCommand(program, _version = "0.0.0", projectRoot = process.c
 
 //#endregion
 export { AdapterTelemetryPersistence, AppError, DoltRepoMapMetaRepository, DoltSymbolRepository, ERR_REPO_MAP_STORAGE_WRITE, GitClient, GrammarLoader, RepoMapInjector, RepoMapModule, RepoMapQueryEngine, RepoMapStorage, SymbolParser, createContextCompiler, createDispatcher, createEventEmitter, createImplementationOrchestrator, createPackLoader, createPhaseOrchestrator, createStopAfterGate, createTelemetryAdvisor, formatPhaseCompletionSummary, getFactoryRunSummaries, getScenarioResultsForRun, getTwinRunsForRun, listGraphRuns, normalizeGraphSummaryToStatus, registerFactoryCommand, registerRunCommand, registerScenariosCommand, resolveStoryKeys, runAnalysisPhase, runPlanningPhase, runRunAction, runSolutioningPhase, validateStopAfterFromConflict };
-//# sourceMappingURL=run-DZwHUMeE.js.map
+//# sourceMappingURL=run-Bku8fmY3.js.map