substrate-ai 0.18.0 → 0.19.0

package/dist/{run-gXtnH8lO.js → run-C3MnOuBe.js}

@@ -12259,7 +12259,7 @@ function createImplementationOrchestrator(deps) {
 * @returns Sorted, deduplicated array of story keys in "N-M" format
 */
 async function resolveStoryKeys(db, projectRoot, opts) {
-	if (opts?.explicit !== void 0 && opts.explicit.length > 0) return opts.explicit;
+	if (opts?.explicit !== void 0 && opts.explicit.length > 0) return topologicalSortByDependencies(opts.explicit, projectRoot);
 	let keys = [];
 	const readyKeys = await db.queryReadyStories();
 	if (readyKeys.length > 0) {
@@ -12406,6 +12406,12 @@ function findEpicsFile(projectRoot) {
 		const fullPath = join$1(projectRoot, candidate);
 		if (existsSync(fullPath)) return fullPath;
 	}
+	const planningDir = join$1(projectRoot, "_bmad-output", "planning-artifacts");
+	if (existsSync(planningDir)) try {
+		const entries = readdirSync(planningDir, { encoding: "utf-8" });
+		const match$1 = entries.filter((e) => /^epics[-.].*\.md$/i.test(e) && !/^epic-\d+/.test(e)).sort();
+		if (match$1.length > 0) return join$1(planningDir, match$1[0]);
+	} catch {}
 	return void 0;
 }
 /**
@@ -12512,6 +12518,112 @@ function sortStoryKeys(keys) {
 		return a.localeCompare(b);
 	});
 }
+/**
+* Parse inter-story dependencies from the consolidated epics document.
+*
+* Scans for patterns like:
+*   ### Story 50-2: Title
+*   **Dependencies:** 50-1
+*
+* Returns a Map where key=storyKey, value=Set of dependency keys.
+* Only returns dependencies that are within the provided storyKeys set
+* (external dependencies to other epics are ignored for ordering purposes).
+*/
+function parseEpicsDependencies(projectRoot, storyKeys) {
+	const deps = new Map();
+	const epicsPath = findEpicsFile(projectRoot);
+	if (epicsPath === void 0) return deps;
+	let content;
+	try {
+		content = readFileSync(epicsPath, "utf-8");
+	} catch {
+		return deps;
+	}
+	const storyPattern = /^###\s+Story\s+(\d+)-(\d+)[:\s]/gm;
+	const depPattern = /^\*\*Dependencies:\*\*\s*(.+)$/gm;
+	const storyPositions = [];
+	let match$1;
+	while ((match$1 = storyPattern.exec(content)) !== null) storyPositions.push({
+		key: `${match$1[1]}-${match$1[2]}`,
+		pos: match$1.index
+	});
+	for (let i = 0; i < storyPositions.length; i++) {
+		const story = storyPositions[i];
+		const nextStoryPos = i + 1 < storyPositions.length ? storyPositions[i + 1].pos : content.length;
+		const section = content.slice(story.pos, nextStoryPos);
+		depPattern.lastIndex = 0;
+		const depMatch = depPattern.exec(section);
+		if (depMatch === null || /^none$/i.test(depMatch[1].trim())) continue;
+		const depText = depMatch[1];
+		const storyDeps = new Set();
+		const rangeMatch = /(\d+)-(\d+)\s+through\s+\1-(\d+)/i.exec(depText);
+		if (rangeMatch !== null) {
+			const epic = rangeMatch[1];
+			const start = Number(rangeMatch[2]);
+			const end = Number(rangeMatch[3]);
+			for (let n$1 = start; n$1 <= end; n$1++) {
+				const depKey = `${epic}-${n$1}`;
+				if (storyKeys.has(depKey)) storyDeps.add(depKey);
+			}
+		} else {
+			const keyPattern = /(\d+-\d+[a-z]?)/g;
+			let km;
+			while ((km = keyPattern.exec(depText)) !== null) {
+				const depKey = km[1];
+				if (storyKeys.has(depKey)) storyDeps.add(depKey);
+			}
+		}
+		if (storyDeps.size > 0) deps.set(story.key, storyDeps);
+	}
+	return deps;
+}
+/**
+* Topologically sort explicit story keys by inter-story dependencies.
+*
+* Parses the consolidated epics document for dependency metadata, builds
+* a DAG, and returns keys in dependency-first order using Kahn's algorithm.
+* Stories with no dependencies come first; stories that depend on others
+* are placed after their prerequisites.
+*
+* Falls back to numeric sort if no epics document exists or no
+* dependencies are found among the provided keys.
+*/
+function topologicalSortByDependencies(keys, projectRoot) {
+	if (keys.length <= 1) return keys;
+	const keySet = new Set(keys);
+	const deps = parseEpicsDependencies(projectRoot, keySet);
+	if (deps.size === 0) return sortStoryKeys(keys);
+	const inDegree = new Map();
+	const successors = new Map();
+	for (const key of keys) {
+		inDegree.set(key, 0);
+		successors.set(key, new Set());
+	}
+	for (const [dependent, depSet] of deps) {
+		if (!keySet.has(dependent)) continue;
+		for (const dep of depSet) {
+			if (!keySet.has(dep)) continue;
+			successors.get(dep).add(dependent);
+			inDegree.set(dependent, (inDegree.get(dependent) ?? 0) + 1);
+		}
+	}
+	const result = [];
+	const processed = new Set();
+	while (processed.size < keys.length) {
+		const wave = [];
+		for (const key of keys) if (!processed.has(key) && (inDegree.get(key) ?? 0) === 0) wave.push(key);
+		if (wave.length === 0) {
+			for (const key of sortStoryKeys(keys)) if (!processed.has(key)) result.push(key);
+			break;
+		}
+		for (const key of sortStoryKeys(wave)) {
+			result.push(key);
+			processed.add(key);
+			for (const succ of successors.get(key) ?? []) inDegree.set(succ, (inDegree.get(succ) ?? 0) - 1);
+		}
+	}
+	return result;
+}
 
 //#endregion
 //#region src/modules/phase-orchestrator/phase-detection.ts
@@ -21100,7 +21212,9 @@ function buildGraphNode(id, attrs, subgraphClass, defaultMaxRetries) {
 		autoStatus: attrBool(attrs, "auto_status", true),
 		allowPartial: attrBool(attrs, "allow_partial", false),
 		toolCommand: attrStr(attrs, "tool_command", ""),
-		backend: attrStr(attrs, "backend", "")
+		backend: attrStr(attrs, "backend", ""),
+		maxParallel: attrInt(attrs, "maxParallel", 0),
+		joinPolicy: attrStr(attrs, "joinPolicy", "")
 	};
 }
 function buildGraphEdge(fromNode, toNode, attrs) {
@@ -21776,7 +21890,7 @@ const conditionSyntaxRule = {
 		const diagnostics = [];
 		for (let i = 0; i < graph.edges.length; i++) {
 			const edge = graph.edges[i];
-			if (edge.condition) try {
+			if (edge.condition && !edge.condition.trim().startsWith("llm:")) try {
 				parseCondition(edge.condition);
 			} catch (err) {
 				if (err instanceof ConditionParseError) diagnostics.push({
@@ -21969,6 +22083,102 @@ function createValidator() {
 	};
 }
 
+//#endregion
+//#region packages/factory/dist/graph/llm-evaluator.js
+/**
+* LLM-based edge condition evaluator for the factory graph engine.
+*
+* Provides pure, side-effect-free functions for detecting `llm:` prefixed
+* conditions, building evaluation prompts, parsing boolean responses, and
+* executing an LLM-backed condition evaluation with safe error handling.
+*
+* Zero external package imports — all LLM wiring is done by the caller
+* (edge-selector.ts) via the injectable `llmCall` parameter.
+*
+* Story 50-4.
+*/
+/**
+* Returns `true` iff the condition string starts with the `"llm:"` prefix
+* (after trimming leading/trailing whitespace).
+*/
+function isLlmCondition(condition) {
+	return condition.trim().startsWith("llm:");
+}
+/**
+* Strips the `"llm:"` prefix and trims surrounding whitespace from the
+* remainder of the condition string.
+*
+* @param condition - A condition string beginning with `"llm:"`.
+* @returns The extracted question text, trimmed.
+*/
+function extractLlmQuestion(condition) {
+	return condition.trim().slice(4).trim();
+}
+/**
+* Builds an LLM evaluation prompt that includes the question and a JSON
+* block of the current context snapshot, with an explicit instruction to
+* answer with only "yes" or "no".
+*
+* @param question         - The routing question extracted from the condition.
+* @param contextSnapshot  - Shallow copy of the current execution context.
+* @returns The fully constructed prompt string.
+*/
+function buildEvaluationPrompt(question, contextSnapshot) {
+	return [
+		`You are evaluating a routing condition in a software pipeline.`,
+		``,
+		`Context:`,
+		JSON.stringify(contextSnapshot, null, 2),
+		``,
+		`Question: ${question}`,
+		``,
+		`Answer with exactly "yes" or "no".`
+	].join("\n");
+}
+/**
+* Parses an LLM yes/no response into a boolean value.
+*
+* Returns `true` if the cleaned (trimmed, lowercased) response starts with or
+* contains one of: `"yes"`, `"true"`, `"affirmative"`, `"correct"`, `"1"`.
+* Returns `false` otherwise, including for an empty string.
+*
+* @param response - Raw text response from the LLM.
+* @returns `true` for affirmative responses, `false` for all others.
+*/
+function parseLlmBoolResponse(response) {
+	const cleaned = response.trim().toLowerCase();
+	const affirmatives = [
+		"yes",
+		"true",
+		"affirmative",
+		"correct",
+		"1"
+	];
+	return affirmatives.some((token) => cleaned === token || cleaned.startsWith(token + " ") || cleaned.startsWith(token + "\n"));
+}
+/**
+* Evaluates an LLM edge condition asynchronously.
+*
+* Builds the evaluation prompt, calls the injectable `llmCall` function,
+* and parses the response via `parseLlmBoolResponse`. If any step throws,
+* returns `false` silently — never re-throws.
+*
+* @param question         - The routing question to evaluate.
+* @param contextSnapshot  - Shallow copy of the current execution context.
+* @param llmCall          - Injectable async function that calls an LLM and
+*                           returns the raw text response.
+* @returns `true` if the LLM responds affirmatively, `false` otherwise or on error.
+*/
+async function evaluateLlmCondition(question, contextSnapshot, llmCall) {
+	try {
+		const prompt = buildEvaluationPrompt(question, contextSnapshot);
+		const response = await llmCall(prompt);
+		return parseLlmBoolResponse(response);
+	} catch {
+		return false;
+	}
+}
+
 //#endregion
 //#region packages/factory/dist/graph/edge-selector.js
 /**
@@ -22010,6 +22220,7 @@ function bestByWeightThenLexical(edges) {
 * Select the best outgoing edge from `node` according to the 5-step Attractor spec.
 *
 * Step 1: Condition-matched edges — highest weight, lexical tiebreak.
+*         Edges with `llm:` prefix conditions are evaluated via LLM call.
 * Step 2: Preferred label match on unconditional edges — first match wins.
 * Step 3: Suggested next IDs on unconditional edges — first suggestedNextId wins.
 * Step 4: Highest weight among all unconditional edges.
@@ -22019,14 +22230,48 @@ function bestByWeightThenLexical(edges) {
 * @param outcome - The outcome returned by the node's handler.
 * @param context - The current execution context (used for condition evaluation).
 * @param graph   - The full graph (source of edges).
+* @param options - Optional injectable overrides (e.g. llmCall for testing).
 * @returns The selected `GraphEdge`, or `null` if no outgoing edges exist.
 */
-function selectEdge(node, outcome, context, graph) {
+async function selectEdge(node, outcome, context, graph, options) {
 	const outgoing = graph.edges.filter((e) => e.fromNode === node.id);
 	if (outgoing.length === 0) return null;
+	const defaultLlmCall$1 = (prompt) => callLLM({
+		model: node.llmModel || "claude-haiku-4-5",
+		provider: node.llmProvider || "anthropic",
+		reasoningEffort: "low",
+		prompt
+	}).then((r) => r.text);
+	const llmCall = options?.llmCall ?? defaultLlmCall$1;
 	const conditionMatches = [];
 	const snapshot = context.snapshot();
-	for (const edge of outgoing) if (edge.condition && edge.condition.trim() !== "") try {
+	for (const edge of outgoing) if (edge.condition && edge.condition.trim() !== "") if (isLlmCondition(edge.condition)) {
+		const question = extractLlmQuestion(edge.condition);
+		let evalError = null;
+		const trackingLlmCall = async (prompt) => {
+			try {
+				return await llmCall(prompt);
+			} catch (err) {
+				evalError = err instanceof Error ? err.message : String(err);
+				throw err;
+			}
+		};
+		const matched = await evaluateLlmCondition(question, snapshot, trackingLlmCall);
+		options?.eventBus?.emit("graph:llm-edge-evaluated", {
+			runId: options.runId ?? "unknown",
+			nodeId: node.id,
+			question,
+			result: matched
+		});
+		context.set("llm.edge_eval_count", context.getNumber("llm.edge_eval_count", 0) + 1);
+		if (evalError !== null) {
+			const existing = context.get("llm.edge_eval_errors");
+			const errors = Array.isArray(existing) ? existing : [];
+			errors.push(evalError);
+			context.set("llm.edge_eval_errors", errors);
+		}
+		if (matched) conditionMatches.push(edge);
+	} else try {
 		if (evaluateCondition(edge.condition, snapshot)) conditionMatches.push(edge);
 	} catch {}
 	if (conditionMatches.length > 0) return bestByWeightThenLexical(conditionMatches);
@@ -22987,6 +23232,111 @@ function resolveFidelity(node, incomingEdge, graph) {
 	return "";
 }
 
+//#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/graph/transformer.js
+/**
+* Apply stylesheet rules to all nodes in the given graph.
+*
+* Merges `inheritedStylesheet` (parent rules) with the graph's own
+* `modelStylesheet` rules, parent rules first so that local child rules win at
+* equal specificity via source-order tie-breaking (later rule wins).
+*
+* For each node, the resolved properties are applied only if the node does NOT
+* already have a non-empty explicit value (explicit values are preserved).
+*
+* This function **mutates** graph nodes in-place — consistent with how the
+* DOT parser sets node fields after parsing.
+*
+* **Idempotency**: calling `applyStylesheet` twice on the same graph is safe
+* because nodes with an existing non-empty `llmModel` (or `llmProvider` /
+* `reasoningEffort`) are never overwritten.
+*
+* @param graph               - The graph whose nodes should be styled.
+* @param inheritedStylesheet - Optional stylesheet rules inherited from a
+*   parent graph. Prepended before the graph's own rules so that child local
+*   rules win at equal specificity. Pass `undefined` when there is no parent.
+*/
+function applyStylesheet(graph, inheritedStylesheet) {
+	const localRules = graph.modelStylesheet ? parseStylesheet(graph.modelStylesheet) : [];
+	const effectiveStylesheet = [...inheritedStylesheet ?? [], ...localRules];
+	if (effectiveStylesheet.length === 0) return;
+	for (const node of graph.nodes.values()) {
+		const resolved = resolveNodeStyles(node, effectiveStylesheet);
+		if (!node.llmModel && resolved.llmModel) node.llmModel = resolved.llmModel;
+		if (!node.llmProvider && resolved.llmProvider) node.llmProvider = resolved.llmProvider;
+		if (!node.reasoningEffort && resolved.reasoningEffort) node.reasoningEffort = resolved.reasoningEffort;
+	}
+}
+
 //#endregion
 //#region packages/factory/dist/graph/executor.js
 /**
@@ -23081,6 +23431,7 @@ async function dispatchWithRetry(node, context, graph, config, nodeRetries) {
 */
 function createGraphExecutor() {
 	return { async run(graph, config) {
+		applyStylesheet(graph, config.inheritedStylesheet);
 		const checkpointManager = new CheckpointManager();
 		const checkpointFilePath = path.join(config.logsRoot, "checkpoint.json");
 		const controller = createConvergenceController();
@@ -23176,7 +23527,10 @@ function createGraphExecutor() {
 			if (resumeState.completedNodes.has(checkpoint.currentNode)) {
 				const lastNode = graph.nodes.get(checkpoint.currentNode);
 				if (lastNode) {
-					const nextEdge = selectEdge(lastNode, { status: "SUCCESS" }, context, graph);
+					const nextEdge = await selectEdge(lastNode, { status: "SUCCESS" }, context, graph, {
+						...config.eventBus !== void 0 ? { eventBus: config.eventBus } : {},
+						runId: config.runId
+					});
 					if (nextEdge) {
 						const nextNode = graph.nodes.get(nextEdge.toNode);
 						if (!nextNode) throw new Error(`Edge target node "${nextEdge.toNode}" not found in graph`);
@@ -23189,6 +23543,7 @@ function createGraphExecutor() {
 				else currentNode = graph.startNode();
 			}
 		} else currentNode = graph.startNode();
+		context.set("__runId", config.runId ?? "unknown");
 		while (true) {
 			const sessionResult = sessionManager.checkBudget((config.wallClockCapMs ?? 0) / 1e3);
 			if (!sessionResult.allowed) {
@@ -23279,7 +23634,10 @@ function createGraphExecutor() {
 				return { status: "SUCCESS" };
 			}
 			if (resumeCompletedSet?.has(currentNode.id)) {
-				const skipEdge = selectEdge(currentNode, { status: "SUCCESS" }, context, graph);
+				const skipEdge = await selectEdge(currentNode, { status: "SUCCESS" }, context, graph, {
+					...config.eventBus !== void 0 ? { eventBus: config.eventBus } : {},
+					runId: config.runId
+				});
 				if (!skipEdge) {
 					await persistExit("failed", `No outgoing edge from node ${currentNode.id}`);
 					return {
@@ -23464,7 +23822,10 @@ function createGraphExecutor() {
 					};
 				}
 			}
-			const edge = selectEdge(currentNode, outcome, context, graph);
+			const edge = await selectEdge(currentNode, outcome, context, graph, {
+				...config.eventBus !== void 0 ? { eventBus: config.eventBus } : {},
+				runId: config.runId
+			});
 			if (!edge) {
 				await persistExit("failed", `No outgoing edge from node ${currentNode.id}`);
 				return {
@@ -31087,75 +31448,6 @@ 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";
@@ -31423,32 +31715,788 @@ function createWaitHumanHandler(options) {
 }
 
 //#endregion
-//#region packages/factory/dist/handlers/registry.js
-var HandlerRegistry = class {
-	/** Maps node type → handler function */
-	_handlers = new Map();
-	/** Maps DOT shape name → canonical node type */
-	_shapeMap = new Map();
-	/** Fallback handler when no type or shape match is found */
-	_default;
-	/**
-	* Register a handler for the given node type.
-	* Overwrites if already registered.
-	*/
-	register(type, handler) {
-		this._handlers.set(type, handler);
-	}
-	/**
-	* Register a shape → type mapping.
-	* Overwrites if already registered.
-	*/
-	registerShape(shape, type) {
-		this._shapeMap.set(shape, type);
-	}
-	/**
-	* Set the default handler used when no type or shape match is found.
-	*/
-	setDefault(handler) {
+//#region packages/factory/dist/handlers/join-policy.js
+/**
+* Join policy types, pure evaluator, and branch cancellation manager
+* for parallel node fan-out/fan-in coordination.
+*
+* Design constraints:
+*   - Zero external package imports (pure TypeScript/built-ins only)
+*   - `evaluateJoinPolicy` is a pure synchronous function (no I/O, no side effects)
+*   - `BranchCancellationManager` uses the globally-available AbortController (Node 18+)
+*
+* Story 50-3 (AC6).
+*/
+/**
+* Pure synchronous function that decides what the parallel handler should do
+* after a set of branches has completed.
+*
+* Called incrementally after each branch finishes: pass the full `completed`
+* array (including all branches resolved so far) and the `total` branch count.
+*
+* @param config    - Join policy configuration parsed from the parallel node.
+* @param completed - All branch results collected so far (any order).
+* @param total     - Total number of branches in the fan-out set.
+* @returns A `JoinDecision` indicating whether to continue, wait, or fail.
+*/
+function evaluateJoinPolicy(config, completed, total) {
+	const successes = completed.filter((r) => r.outcome === "SUCCESS");
+	const failures = completed.filter((r) => r.outcome === "FAIL");
+	switch (config.policy) {
+		case "wait_all": {
+			if (completed.length < total) return { action: "wait" };
+			return {
+				action: "continue",
+				results: completed
+			};
+		}
+		case "first_success": {
+			if (successes.length >= 1) return {
+				action: "continue",
+				results: completed
+			};
+			if (completed.length >= total) return {
+				action: "fail",
+				reason: `first_success: all ${total} branches failed`
+			};
+			return { action: "wait" };
+		}
+		case "quorum": {
+			const needed = config.quorum_size ?? 1;
+			if (needed <= 0) return {
+				action: "fail",
+				reason: "quorum_size must be >= 1"
+			};
+			if (successes.length >= needed) return {
+				action: "continue",
+				results: completed
+			};
+			const remaining = total - completed.length;
+			if (successes.length + remaining < needed) return {
+				action: "fail",
+				reason: `quorum unreachable: ${failures.length} failed, needed ${needed} of ${total}`
+			};
+			return { action: "wait" };
+		}
+		default: {
+			const _exhaustive = config.policy;
+			return {
+				action: "fail",
+				reason: `unknown join policy: ${String(_exhaustive)}`
+			};
+		}
+	}
+}
+/**
+* Manages one `AbortController` per branch in a parallel fan-out execution.
+*
+* Typical usage:
+*   1. Construct with the total branch count.
+*   2. Pass `getSignal(i)` to the i-th branch executor.
+*   3. After the join condition is met, call `cancelRemaining(completedSet)`.
+*   4. Await `drainAsync(timeoutMs)` to give cancelled branches time to clean up.
+*/
+var BranchCancellationManager = class {
+	controllers;
+	/**
+	* @param branchCount - Total number of branches; allocates one AbortController per branch.
+	*/
+	constructor(branchCount) {
+		this.controllers = Array.from({ length: branchCount }, () => new AbortController());
+	}
+	/**
+	* Return the AbortSignal for the branch at the given zero-based index.
+	* The signal is not yet aborted; it becomes aborted when `cancelRemaining` includes the index.
+	*/
+	getSignal(index) {
+		const ctrl = this.controllers[index];
+		if (ctrl === void 0) throw new RangeError(`Branch index ${index} is out of range (branchCount=${this.controllers.length})`);
+		return ctrl.signal;
+	}
+	/**
+	* Abort all branches whose index is NOT in `completedIndices`.
+	* Branches that have already completed are not re-aborted.
+	*
+	* @param completedIndices - Set of branch indices that finished successfully/naturally.
+	*/
+	cancelRemaining(completedIndices) {
+		this.controllers.forEach((ctrl, i) => {
+			if (!completedIndices.has(i)) ctrl.abort();
+		});
+	}
+	/**
+	* Wait `timeoutMs` milliseconds for in-flight branches to honour their AbortSignals
+	* and finish any cleanup work before the parallel handler resolves.
+	*
+	* @param timeoutMs - Drain window in milliseconds (default 5000).
+	*/
+	async drainAsync(timeoutMs) {
+		await new Promise((resolve$6) => setTimeout(resolve$6, timeoutMs));
+	}
+};
+
+//#endregion
+//#region packages/factory/dist/handlers/parallel.js
+/**
+* Maps a BranchResult outcome string to a StageStatus for event payloads.
+*
+* BranchResult.outcome: 'SUCCESS' | 'FAIL' | 'CANCELLED'
+* StageStatus:          'SUCCESS' | 'FAIL' | 'PARTIAL_SUCCESS' | 'RETRY' | 'SKIPPED'
+*
+* Mapping:
+*   'SUCCESS'   → 'SUCCESS'
+*   'CANCELLED' → 'SKIPPED'
+*   'FAIL'      → 'FAIL'
+*/
+function branchOutcomeToStatus(outcome) {
+	if (outcome === "SUCCESS") return "SUCCESS";
+	if (outcome === "CANCELLED") return "SKIPPED";
+	return "FAIL";
+}
+/**
+* Enrich a join-policy `BranchResult` with fan-in-compatible fields so that
+* `fan-in.ts` can read `parallel.results` without type-shape mismatch.
+*
+* The returned object is a superset of `BranchResult` — it preserves every
+* original field (index, outcome, contextSnapshot, error) AND adds the fields
+* that `fan-in.ts` requires (branch_id, status, context_updates, failure_reason).
+*
+* Mapping:
+*   index          → branch_id        (same numeric value)
+*   outcome        → status           ('SUCCESS' | 'FAIL'/'CANCELLED' → 'SUCCESS' | 'FAILURE')
+*   contextSnapshot → context_updates  (shallow context snapshot)
+*   error          → failure_reason   (human-readable failure description)
+*/
+function toBridgeBranchResult(result) {
+	return {
+		...result,
+		branch_id: result.index,
+		status: result.outcome === "SUCCESS" ? "SUCCESS" : "FAILURE",
+		context_updates: result.contextSnapshot,
+		failure_reason: result.error
+	};
+}
+/**
+* Run an array of async task factories with at most `limit` executing
+* concurrently at any point in time, preserving result order.
+*/
+async function runWithConcurrencyLimit(tasks, limit) {
+	const results = new Array(tasks.length);
+	const executing = new Set();
+	for (let i = 0; i < tasks.length; i++) {
+		const idx = i;
+		const p = tasks[idx]().then((r) => {
+			results[idx] = r;
+		}).finally(() => {
+			executing.delete(p);
+		});
+		executing.add(p);
+		if (executing.size >= limit) await Promise.race(executing);
+	}
+	await Promise.all(executing);
+	return results;
+}
+function parseJoinPolicyConfig(node) {
+	const policyRaw = node.attrs?.["join_policy"] ?? node.joinPolicy ?? "wait_all";
+	const policy = policyRaw === "first_success" || policyRaw === "quorum" ? policyRaw : "wait_all";
+	const quorumSizeRaw = node.attrs?.["quorum_size"];
+	const quorum_size = quorumSizeRaw !== void 0 ? parseInt(quorumSizeRaw, 10) : void 0;
+	const drainRaw = node.attrs?.["cancel_drain_timeout_ms"];
+	const cancel_drain_timeout_ms = drainRaw !== void 0 ? parseInt(drainRaw, 10) : void 0;
+	return {
+		policy,
+		...quorum_size !== void 0 && { quorum_size },
+		...cancel_drain_timeout_ms !== void 0 && { cancel_drain_timeout_ms }
+	};
+}
+/**
+* Build an async task that executes a single branch node and returns a
+* `BranchResult`. Isolation is guaranteed via `context.clone()`.
+*/
+function makeBranchTask(edge, index, signal, context, graph, options) {
+	return async () => {
+		if (signal.aborted) return {
+			index,
+			outcome: "CANCELLED"
+		};
+		const branchNode = graph.nodes.get(edge.toNode);
+		if (!branchNode) return {
+			index,
+			outcome: "FAIL",
+			error: `Branch node "${edge.toNode}" not found in graph`
+		};
+		const branchCtx = context.clone();
+		branchCtx.set("_branch.abort_signal", signal);
+		branchCtx.set("_branch.index", index);
+		const handler = options.handlerRegistry.resolve(branchNode);
+		let branchOutcome;
+		try {
+			branchOutcome = await handler(branchNode, branchCtx, graph);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				index,
+				outcome: "FAIL",
+				error: msg,
+				contextSnapshot: branchCtx.snapshot()
+			};
+		}
+		if (signal.aborted) return {
+			index,
+			outcome: "CANCELLED",
+			contextSnapshot: branchCtx.snapshot()
+		};
+		const isSuccess = branchOutcome.status === "SUCCESS" || branchOutcome.status === "PARTIAL_SUCCESS";
+		const result = {
+			index,
+			outcome: isSuccess ? "SUCCESS" : "FAIL",
+			contextSnapshot: branchCtx.snapshot()
+		};
+		if (!isSuccess) {
+			const reason = branchOutcome.failureReason;
+			if (reason !== void 0) result.error = reason;
+		}
+		return result;
+	};
+}
+/**
+* Create a `parallel` node handler that fans out to all outgoing branch nodes
+* concurrently, applies a configurable join policy, and writes results to context.
+*
+* @param options.handlerRegistry  Registry used to resolve each branch node's
+*   handler at invocation time.
+*/
+function createParallelHandler(options) {
+	return async (node, context, graph) => {
+		const branchEdges = graph.outgoingEdges(node.id);
+		const branchCount = branchEdges.length;
+		if (branchCount === 0) {
+			context.set("parallel.results", []);
+			return { status: "SUCCESS" };
+		}
+		const config = parseJoinPolicyConfig(node);
+		const maxParallel = node.maxParallel ?? 0;
+		const drainMs = config.cancel_drain_timeout_ms ?? 5e3;
+		const cancellationManager = new BranchCancellationManager(branchCount);
+		const runId = context.getString("__runId", "unknown");
+		options.eventBus?.emit("graph:parallel-started", {
+			runId,
+			nodeId: node.id,
+			branchCount,
+			maxParallel: maxParallel > 0 ? maxParallel : branchCount,
+			policy: config.policy
+		});
+		if (config.policy === "wait_all") {
+			const tasks = branchEdges.map((edge, index) => {
+				const baseTask = makeBranchTask(edge, index, cancellationManager.getSignal(index), context, graph, options);
+				return async () => {
+					options.eventBus?.emit("graph:parallel-branch-started", {
+						runId,
+						nodeId: node.id,
+						branchIndex: index
+					});
+					const branchStart = Date.now();
+					const result = await baseTask();
+					const durationMs = Date.now() - branchStart;
+					options.eventBus?.emit("graph:parallel-branch-completed", {
+						runId,
+						nodeId: node.id,
+						branchIndex: index,
+						status: branchOutcomeToStatus(result.outcome),
+						durationMs
+					});
+					return result;
+				};
+			});
+			const results = maxParallel > 0 ? await runWithConcurrencyLimit(tasks, maxParallel) : await Promise.all(tasks.map((t) => t()));
+			context.set("parallel.results", results.map(toBridgeBranchResult));
+			const completedCount = results.filter((r) => r.outcome === "SUCCESS").length;
+			const cancelledCount = results.filter((r) => r.outcome === "CANCELLED").length;
+			options.eventBus?.emit("graph:parallel-completed", {
+				runId,
+				nodeId: node.id,
+				completedCount,
+				cancelledCount,
+				policy: config.policy
+			});
+			return { status: "SUCCESS" };
+		}
+		const completed = [];
+		const completedIndices = new Set();
+		const pendingEvents = [];
+		const waiters = [];
+		function push(event) {
+			const w = waiters.shift();
+			if (w !== void 0) w(event);
+			else pendingEvents.push(event);
+		}
+		function waitForNext() {
+			return new Promise((resolve$6) => {
+				const e = pendingEvents.shift();
+				if (e !== void 0) resolve$6(e);
+				else waiters.push(resolve$6);
+			});
+		}
+		const branchStarts = new Map();
+		const activeTasks = branchEdges.map((edge, index) => {
+			const task = makeBranchTask(edge, index, cancellationManager.getSignal(index), context, graph, options);
+			options.eventBus?.emit("graph:parallel-branch-started", {
+				runId,
+				nodeId: node.id,
+				branchIndex: index
+			});
+			branchStarts.set(index, Date.now());
+			return task().then((result) => {
+				const branchStart = branchStarts.get(index) ?? Date.now();
+				const durationMs = Date.now() - branchStart;
+				options.eventBus?.emit("graph:parallel-branch-completed", {
+					runId,
+					nodeId: node.id,
+					branchIndex: index,
+					status: branchOutcomeToStatus(result.outcome),
+					durationMs
+				});
+				push({ result });
+			});
+		});
+		let joinOutcome = "SUCCESS";
+		let settled = false;
+		let joinErrorMsg;
+		for (let i = 0; i < branchCount; i++) {
+			const { result } = await waitForNext();
+			if (completedIndices.has(result.index)) continue;
+			completed.push(result);
+			completedIndices.add(result.index);
+			const decision = evaluateJoinPolicy(config, completed, branchCount);
+			if (decision.action === "wait") continue;
+			settled = true;
+			joinOutcome = decision.action === "continue" ? "SUCCESS" : "FAIL";
+			if (decision.action === "fail") joinErrorMsg = decision.reason;
+			const uncancelledCount = branchCount - completedIndices.size;
+			cancellationManager.cancelRemaining(completedIndices);
+			if (uncancelledCount > 0) {
+				await cancellationManager.drainAsync(drainMs);
+				while (pendingEvents.length > 0) {
+					const e = pendingEvents.shift();
+					if (e !== void 0 && !completedIndices.has(e.result.index)) {
+						completed.push(e.result);
+						completedIndices.add(e.result.index);
+					}
+				}
+				for (let j$1 = 0; j$1 < branchCount; j$1++) if (!completedIndices.has(j$1)) {
+					completed.push({
+						index: j$1,
+						outcome: "CANCELLED"
+					});
+					completedIndices.add(j$1);
+				}
+			}
+			context.set("parallel.results", completed.map(toBridgeBranchResult));
+			if (decision.action === "continue") {
+				if (config.policy === "first_success") {
+					const winner = completed.find((r) => r.outcome === "SUCCESS");
+					if (winner !== void 0) context.set("parallel.winner_index", winner.index);
+				}
+				if (config.policy === "quorum") {
+					const successCount = completed.filter((r) => r.outcome === "SUCCESS").length;
+					context.set("parallel.quorum_reached", successCount);
+				}
+			} else context.set("parallel.join_error", joinErrorMsg ?? decision.reason);
+			break;
+		}
+		Promise.allSettled(activeTasks);
+		if (!settled) context.set("parallel.results", completed.map(toBridgeBranchResult));
+		const finalCompletedCount = completed.filter((r) => r.outcome === "SUCCESS").length;
+		const finalCancelledCount = completed.filter((r) => r.outcome === "CANCELLED").length;
+		options.eventBus?.emit("graph:parallel-completed", {
+			runId,
+			nodeId: node.id,
+			completedCount: finalCompletedCount,
+			cancelledCount: finalCancelledCount,
+			policy: config.policy
+		});
+		return { status: joinOutcome === "SUCCESS" ? "SUCCESS" : "FAILURE" };
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/handlers/fan-in.js
+/** Lower number = better rank. FAILURE is excluded before ranking. */
+const OUTCOME_RANK = {
+	SUCCESS: 0,
+	PARTIAL_SUCCESS: 1,
+	NEEDS_RETRY: 2,
+	FAILURE: 3,
+	ESCALATE: 4
+};
+/**
+* Select the best non-FAILURE branch from `results`.
+*
+* Sort order (ascending priority):
+*   1. `OUTCOME_RANK[status]` ascending (SUCCESS wins)
+*   2. `score` descending (higher is better; `undefined` treated as `0`)
+*   3. `branch_id` ascending (stable tiebreak)
+*
+* Returns `null` when every branch has status `FAILURE`.
+*/
+function rankBranches(results) {
+	const eligible = results.filter((r) => r.status !== "FAILURE");
+	if (eligible.length === 0) return null;
+	const sorted = [...eligible].sort((a, b) => {
+		const rankDiff = (OUTCOME_RANK[a.status] ?? 99) - (OUTCOME_RANK[b.status] ?? 99);
+		if (rankDiff !== 0) return rankDiff;
+		const scoreA = a.score ?? 0;
+		const scoreB = b.score ?? 0;
+		if (scoreB !== scoreA) return scoreB - scoreA;
+		return a.branch_id - b.branch_id;
+	});
+	return sorted[0] ?? null;
+}
+/**
+* Build the prompt sent to the LLM for selection-based fan-in.
+*
+* The prompt prepends `nodePrompt`, then lists each branch with its
+* `branch_id`, `status`, `score`, and the keys present in `context_updates`
+* (values omitted for token efficiency). The LLM is instructed to reply with
+* just the integer `branch_id` of the best candidate.
+*/
+function buildSelectionPrompt(nodePrompt, results) {
+	const branchSummaries = results.map((r) => {
+		const contextKeys = r.context_updates && Object.keys(r.context_updates).length > 0 ? Object.keys(r.context_updates).join(", ") : "(none)";
+		return `Branch ${r.branch_id}: status=${r.status}, score=${r.score ?? 0}, context_update_keys=[${contextKeys}]`;
+	}).join("\n");
+	return `${nodePrompt}\n\nParallel branch results:\n${branchSummaries}\n\nReply with only the integer branch_id of the best candidate.`;
+}
+/**
+* Parse an LLM response to extract the winning `branch_id`.
+*
+* Scans the response text for the first integer that matches a valid
+* `branch_id` in `results`. Returns the matching `BranchResult`, or `null`
+* (triggering heuristic fallback) if no valid branch_id is found.
+* Logs a warning on fallback.
+*/
+function parseLlmWinnerResponse(response, results) {
+	const validIds = new Set(results.map((r) => r.branch_id));
+	const matches = response.match(/\d+/g);
+	if (matches) for (const m of matches) {
+		const id = parseInt(m, 10);
+		if (validIds.has(id)) return results.find((r) => r.branch_id === id) ?? null;
+	}
+	console.warn(`[fan-in] LLM response did not contain a valid branch_id; falling back to heuristic selection. Response: "${response}"`);
+	return null;
+}
+/**
+* Default `llmCall` implementation that wraps `callLLM` from `@substrate-ai/core`
+* with fixed default routing parameters.
+*/
+async function defaultLlmCall(prompt) {
+	const result = await callLLM({
+		model: "claude-sonnet-4-5",
+		provider: "anthropic",
+		reasoningEffort: "low",
+		prompt
+	});
+	return result.text;
+}
+/**
+* Create a `parallel.fan_in` node handler.
+*
+* Execution steps:
+*  1. Read `parallel.results` from context; return FAILURE if absent or empty.
+*  2. If `node.prompt` is non-empty, call LLM to select winner; fall back to
+*     heuristic on parse failure.
+*  3. Use heuristic `rankBranches` when no prompt or LLM fallback.
+*  4. If all branches failed, return FAILURE with aggregated failure reasons.
+*  5. Merge winner's `context_updates`, set `parallel.fan_in.best_id` and
+*     `parallel.fan_in.best_outcome`, return SUCCESS.
+*
+* @param options - Optional configuration (inject `llmCall` for testing).
+*/
+function createFanInHandler(options) {
+	const llmCallFn = options?.llmCall ?? defaultLlmCall;
+	return async (node, context, _graph) => {
+		const rawResults = context.get("parallel.results");
+		if (!rawResults || !Array.isArray(rawResults) || rawResults.length === 0) return {
+			status: "FAILURE",
+			failureReason: "fan-in: no parallel results found in context (parallel.results is absent or empty)"
+		};
+		const results = rawResults;
+		let winner = null;
+		if (node.prompt && node.prompt.trim().length > 0) {
+			const prompt = buildSelectionPrompt(node.prompt, results);
+			try {
+				const response = await llmCallFn(prompt);
+				winner = parseLlmWinnerResponse(response, results);
+			} catch (err) {
+				console.warn(`[fan-in] LLM call failed; falling back to heuristic selection. Error: ${String(err)}`);
+				winner = null;
+			}
+			if (winner === null) winner = rankBranches(results);
+		} else winner = rankBranches(results);
+		if (winner === null) {
+			const reasons = results.map((r) => r.failure_reason ?? `branch ${r.branch_id}: no reason provided`).join("; ");
+			return {
+				status: "FAILURE",
+				failureReason: `fan-in: all branches failed — ${reasons}`
+			};
+		}
+		if (winner.context_updates && Object.keys(winner.context_updates).length > 0) context.applyUpdates(winner.context_updates);
+		context.set("parallel.fan_in.best_id", winner.branch_id);
+		context.set("parallel.fan_in.best_outcome", winner.status);
+		return { status: "SUCCESS" };
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/handlers/subgraph.js
+/**
+* Converts the sub-executor's `events.ts:StageStatus` back to the handler
+* return type `types.ts:OutcomeStatus`.
+*
+* Mapping:
+*   'SUCCESS'        → 'SUCCESS'
+*   'PARTIAL_SUCCESS'→ 'PARTIAL_SUCCESS'
+*   all others       → 'FAILURE'  (covers 'FAIL', 'RETRY', 'SKIPPED')
+*/
+function denormalizeStatus(status) {
+	if (status === "SUCCESS") return "SUCCESS";
+	if (status === "PARTIAL_SUCCESS") return "PARTIAL_SUCCESS";
+	return "FAILURE";
+}
+/**
+* Factory function that creates a handler for `type="subgraph"` nodes.
+*
+* Each subgraph node references an external `.dot` file, loads and validates
+* it, then executes it as a nested sub-pipeline. Parent context is seeded into
+* the sub-executor and context updates from the subgraph are propagated back.
+*/
+function createSubgraphHandler(options) {
+	return async (node, context, graph) => {
+		const graphFile = node.attrs?.["graph_file"];
+		if (!graphFile) return {
+			status: "FAILURE",
+			failureReason: `Subgraph node "${node.id}" is missing required attribute graph_file`
+		};
+		const currentDepth = context.getNumber("subgraph._depth", 0);
+		const maxDepth = options.maxDepth ?? 5;
+		if (currentDepth >= maxDepth) return {
+			status: "FAILURE",
+			failureReason: `Subgraph depth limit exceeded (max ${maxDepth}): node "${node.id}"`
+		};
+		const filePath = path.isAbsolute(graphFile) ? graphFile : path.join(options.baseDir, graphFile);
+		const loader = options.graphFileLoader ?? ((fp) => readFile$1(fp, "utf-8"));
+		let dotSource;
+		try {
+			dotSource = await loader(filePath);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				status: "FAILURE",
+				failureReason: `Subgraph node "${node.id}": failed to load "${filePath}": ${msg}`
+			};
+		}
+		let subgraph;
+		try {
+			subgraph = parseGraph(dotSource);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				status: "FAILURE",
+				failureReason: `Subgraph node "${node.id}": failed to parse "${filePath}": ${msg}`
+			};
+		}
+		try {
+			createValidator().validateOrRaise(subgraph);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				status: "FAILURE",
+				failureReason: `Subgraph node "${node.id}": validation failed for "${filePath}": ${msg}`
+			};
+		}
+		const runId = context.getString("__runId", options.runId ?? "unknown");
+		options.eventBus?.emit("graph:subgraph-started", {
+			runId,
+			nodeId: node.id,
+			graphFile: filePath,
+			depth: currentDepth
+		});
+		const subgraphStart = Date.now();
+		const parentStylesheet = graph.modelStylesheet ? parseStylesheet(graph.modelStylesheet) : void 0;
+		const subConfig = {
+			runId: randomUUID(),
+			logsRoot: options.logsRoot ?? tmpdir(),
+			handlerRegistry: options.handlerRegistry,
+			initialContext: {
+				...context.snapshot(),
+				"subgraph._depth": currentDepth + 1
+			},
+			...options.eventBus !== void 0 ? { eventBus: options.eventBus } : {},
+			...parentStylesheet !== void 0 ? { inheritedStylesheet: parentStylesheet } : {}
+		};
+		let subOutcome;
+		try {
+			subOutcome = await createGraphExecutor().run(subgraph, subConfig);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			const durationMs$1 = Date.now() - subgraphStart;
+			options.eventBus?.emit("graph:subgraph-completed", {
+				runId,
+				nodeId: node.id,
+				graphFile: filePath,
+				depth: currentDepth,
+				status: "FAIL",
+				durationMs: durationMs$1
+			});
+			return {
+				status: "FAILURE",
+				failureReason: `Subgraph node "${node.id}": executor threw: ${msg}`
+			};
+		}
+		const durationMs = Date.now() - subgraphStart;
+		options.eventBus?.emit("graph:subgraph-completed", {
+			runId,
+			nodeId: node.id,
+			graphFile: filePath,
+			depth: currentDepth,
+			status: subOutcome.status === "SUCCESS" ? "SUCCESS" : subOutcome.status === "PARTIAL_SUCCESS" ? "PARTIAL_SUCCESS" : "FAIL",
+			durationMs
+		});
+		if (subOutcome.contextUpdates) context.applyUpdates(subOutcome.contextUpdates);
+		return {
+			status: denormalizeStatus(subOutcome.status),
+			...subOutcome.contextUpdates !== void 0 && { contextUpdates: subOutcome.contextUpdates },
+			...subOutcome.notes !== void 0 && { notes: subOutcome.notes },
+			...subOutcome.failureReason !== void 0 && { failureReason: subOutcome.failureReason }
+		};
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/handlers/manager-loop.js
+/**
+* Factory function that creates a handler for `type="stack.manager_loop"` nodes.
+*
+* Each invocation loads the body graph once, then executes it in a loop for up
+* to `max_cycles` cycles (default 10). Stop conditions (context key or LLM-based)
+* allow early exit. Stall detection injects recovery steering after consecutive
+* non-SUCCESS body executions.
+*/
+function createManagerLoopHandler(options) {
+	return async (node, context, _graph) => {
+		const graphFile = node.attrs?.["graph_file"];
+		if (!graphFile) return {
+			status: "FAILURE",
+			failureReason: `Manager loop node "${node.id}" is missing required attribute graph_file`
+		};
+		const rawMaxCycles = node.attrs?.["max_cycles"];
+		let maxCycles = 10;
+		if (rawMaxCycles !== void 0 && rawMaxCycles !== "") {
+			const parsed = parseInt(rawMaxCycles, 10);
+			maxCycles = isNaN(parsed) ? 10 : Math.max(1, parsed);
+		}
+		const filePath = path.isAbsolute(graphFile) ? graphFile : path.join(options.baseDir ?? process.cwd(), graphFile);
+		const loader = options.graphFileLoader ?? ((fp) => readFile$1(fp, "utf-8"));
+		let dotSource;
+		try {
+			dotSource = await loader(filePath);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				status: "FAILURE",
+				failureReason: `Manager loop node "${node.id}": failed to load "${filePath}": ${msg}`
+			};
+		}
+		let bodyGraph;
+		try {
+			bodyGraph = parseGraph(dotSource);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				status: "FAILURE",
+				failureReason: `Manager loop node "${node.id}": failed to parse "${filePath}": ${msg}`
+			};
+		}
+		try {
+			createValidator().validateOrRaise(bodyGraph);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				status: "FAILURE",
+				failureReason: `Manager loop node "${node.id}": validation failed for "${filePath}": ${msg}`
+			};
+		}
+		const stopCondition = node.attrs?.["stop_condition"];
+		let consecutiveFailures = 0;
+		for (let cycle = 1; cycle <= maxCycles; cycle++) {
+			context.set("manager_loop.cycle", cycle);
+			const bodyConfig = {
+				runId: randomUUID(),
+				logsRoot: options.logsRoot ?? tmpdir(),
+				handlerRegistry: options.handlerRegistry,
+				initialContext: context.snapshot()
+			};
+			const bodyOutcome = await createGraphExecutor().run(bodyGraph, bodyConfig);
+			if (bodyOutcome.contextUpdates) context.applyUpdates(bodyOutcome.contextUpdates);
+			context.set("manager_loop.cycles_completed", cycle);
+			context.set("manager_loop.last_outcome", bodyOutcome.status);
+			if (bodyOutcome.status === "SUCCESS") {
+				consecutiveFailures = 0;
+				context.set("manager_loop.steering.mode", "normal");
+				context.set("manager_loop.steering.hints", []);
+			} else {
+				consecutiveFailures++;
+				if (consecutiveFailures >= (options.maxStallCycles ?? 2)) {
+					context.set("manager_loop.steering.mode", "recovery");
+					context.set("manager_loop.steering.hints", [`Previous ${consecutiveFailures} attempts returned ${bodyOutcome.status}. Consider a different strategy.`, "Review context state and adjust approach before retrying."]);
+				}
+			}
+			if (stopCondition) {
+				let shouldStop = false;
+				if (isLlmCondition(stopCondition)) {
+					if (options.llmCall !== void 0) {
+						const question = extractLlmQuestion(stopCondition);
+						shouldStop = await evaluateLlmCondition(question, context.snapshot(), options.llmCall);
+					}
+				} else shouldStop = Boolean(context.get(stopCondition));
+				if (shouldStop) {
+					context.set("manager_loop.stop_reason", "stop_condition");
+					return { status: "SUCCESS" };
+				}
+			}
+		}
+		context.set("manager_loop.stop_reason", "max_cycles");
+		return { status: "SUCCESS" };
+	};
+}
+
+//#endregion
+//#region packages/factory/dist/handlers/registry.js
+var HandlerRegistry = class {
+	/** Maps node type → handler function */
+	_handlers = new Map();
+	/** Maps DOT shape name → canonical node type */
+	_shapeMap = new Map();
+	/** Fallback handler when no type or shape match is found */
+	_default;
+	/**
+	* Register a handler for the given node type.
+	* Overwrites if already registered.
+	*/
+	register(type, handler) {
+		this._handlers.set(type, handler);
+	}
+	/**
+	* Register a shape → type mapping.
+	* Overwrites if already registered.
+	*/
+	registerShape(shape, type) {
+		this._shapeMap.set(shape, type);
+	}
+	/**
+	* Set the default handler used when no type or shape match is found.
+	*/
+	setDefault(handler) {
 		this._default = handler;
 	}
 	/**
@@ -31480,19 +32528,40 @@ var HandlerRegistry = class {
 * Story 42-10 adds codergen as the explicit "codergen" type, as the handler for
 * `shape=box` nodes, and as the registry-level default for any node that has no
 * recognised type or shape mapping.
+*
+* Story 50-5 extends options to `DefaultRegistryOptions` and registers the `subgraph` type.
 */
 function createDefaultRegistry(options) {
 	const registry = new HandlerRegistry();
+	registry.register("parallel", createParallelHandler({
+		handlerRegistry: registry,
+		...options?.eventBus !== void 0 ? { eventBus: options.eventBus } : {},
+		...options?.runId !== void 0 ? { runId: options.runId } : {}
+	}));
+	registry.registerShape("component", "parallel");
 	registry.register("start", startHandler);
 	registry.register("exit", exitHandler);
 	registry.register("conditional", conditionalHandler);
 	registry.register("codergen", createCodergenHandler(options));
 	registry.register("tool", createToolHandler());
 	registry.register("wait.human", createWaitHumanHandler());
+	registry.register("parallel.fan_in", createFanInHandler());
+	registry.register("subgraph", createSubgraphHandler({
+		handlerRegistry: registry,
+		baseDir: options?.baseDir ?? process.cwd(),
+		...options?.eventBus !== void 0 ? { eventBus: options.eventBus } : {},
+		...options?.runId !== void 0 ? { runId: options.runId } : {}
+	}));
+	registry.register("stack.manager_loop", createManagerLoopHandler({
+		handlerRegistry: registry,
+		baseDir: options?.baseDir ?? process.cwd(),
+		...options?.llmCall !== void 0 ? { llmCall: options.llmCall } : {}
+	}));
 	registry.registerShape("Mdiamond", "start");
 	registry.registerShape("Msquare", "exit");
 	registry.registerShape("diamond", "conditional");
 	registry.registerShape("box", "codergen");
+	registry.registerShape("tripleoctagon", "parallel.fan_in");
 	registry.setDefault(createCodergenHandler(options));
 	return registry;
 }
@@ -36738,6 +37807,149 @@ function registerContextCommand(factoryCmd, version, storageDir, engineFactory)
 	});
 }
 
+//#endregion
+//#region packages/factory/dist/templates/index.js
+/**
+* Pipeline Template Catalog — pre-built DOT graph pipeline templates for common patterns.
+*
+* Story 50-10.
+*
+* Node type strings used:
+*   - `start`          — start node (registered by default registry)
+*   - `exit`           — exit node (registered by default registry)
+*   - `codergen`       — coding agent node (registered by default registry)
+*   - `parallel`       — parallel fan-out node (story 50-1, shape=component)
+*   - `parallel.fan_in`— fan-in/merge node (story 50-2, shape=tripleoctagon)
+*/
+const trycycleDotContent = `digraph trycycle {
+  // Trycycle Pattern: iterative refinement with eval gates
+  // Flow: define → plan → eval_plan ⇄ implement → eval_impl → exit
+  // eval nodes can loop back to their upstream node on revision_needed.
+
+  start      [type="start"];
+  define     [type="codergen", label="Define Requirements"];
+  plan       [type="codergen", label="Plan Implementation"];
+  eval_plan  [type="codergen", label="Evaluate Plan"];
+  implement  [type="codergen", label="Implement"];
+  eval_impl  [type="codergen", label="Evaluate Implementation"];
+  exit       [type="exit"];
+
+  start     -> define;
+  define    -> plan;
+  plan      -> eval_plan;
+  eval_plan -> implement     [label="approved"];
+  eval_plan -> plan          [label="revision_needed"];
+  implement -> eval_impl;
+  eval_impl -> exit          [label="approved"];
+  eval_impl -> implement     [label="revision_needed"];
+}
+`;
+const dualReviewDotContent = `digraph dual_review {
+  // Dual-Review Pattern: fan-out to two independent reviewers, then fan-in
+  // Flow: implement → (reviewer_a + reviewer_b) in parallel → merge → exit
+
+  start           [type="start"];
+  implement       [type="codergen",       label="Implement"];
+  review_parallel [type="parallel",       label="Fan-Out to Reviewers"];
+  reviewer_a      [type="codergen",       label="Reviewer A"];
+  reviewer_b      [type="codergen",       label="Reviewer B"];
+  review_merge    [type="parallel.fan_in",label="Merge Reviews"];
+  exit            [type="exit"];
+
+  start           -> implement;
+  implement       -> review_parallel;
+  review_parallel -> reviewer_a;
+  review_parallel -> reviewer_b;
+  reviewer_a      -> review_merge;
+  reviewer_b      -> review_merge;
+  review_merge    -> exit;
+}
+`;
+const parallelExplorationDotContent = `digraph parallel_exploration {
+  // Parallel-Exploration Pattern: dispatch multiple approaches concurrently,
+  // select the best-scoring result, then refine the winner.
+  // Flow: (approach_a + approach_b) in parallel → select best → refine → exit
+
+  start           [type="start"];
+  explore_parallel[type="parallel",        label="Fan-Out Exploration"];
+  approach_a      [type="codergen",        label="Approach A"];
+  approach_b      [type="codergen",        label="Approach B"];
+  select_best     [type="parallel.fan_in", label="Select Best Candidate", selection="best"];
+  refine          [type="codergen",        label="Refine Winner"];
+  exit            [type="exit"];
+
+  start            -> explore_parallel;
+  explore_parallel -> approach_a;
+  explore_parallel -> approach_b;
+  approach_a       -> select_best;
+  approach_b       -> select_best;
+  select_best      -> refine;
+  refine           -> exit;
+}
+`;
+const stagedValidationDotContent = `digraph staged_validation {
+  // Staged-Validation Pattern: sequential quality gates
+  // Flow: implement → lint → test → validate → exit
+  // Each stage is a separate codergen node; no parallel branches.
+
+  start    [type="start"];
+  implement[type="codergen", label="Implement"];
+  lint     [type="codergen", label="Lint"];
+  test     [type="codergen", label="Test"];
+  validate [type="codergen", label="Validate"];
+  exit     [type="exit"];
+
+  start     -> implement;
+  implement -> lint;
+  lint      -> test;
+  test      -> validate;
+  validate  -> exit;
+}
+`;
+const trycycleTemplate = {
+	name: "trycycle",
+	description: "Iterative refinement loop with plan and implementation eval gates",
+	dotContent: trycycleDotContent
+};
+const dualReviewTemplate = {
+	name: "dual-review",
+	description: "Fan-out to two independent reviewers, then fan-in to merge results",
+	dotContent: dualReviewDotContent
+};
+const parallelExplorationTemplate = {
+	name: "parallel-exploration",
+	description: "Dispatch parallel implementation approaches and select the best candidate",
+	dotContent: parallelExplorationDotContent
+};
+const stagedValidationTemplate = {
+	name: "staged-validation",
+	description: "Sequential quality gate stages: implement → lint → test → validate",
+	dotContent: stagedValidationDotContent
+};
+/**
+* Map of all built-in pipeline templates, keyed by template name.
+* Insertion order determines display order in `factory templates list`.
+*/
+const PIPELINE_TEMPLATES = new Map([
+	[trycycleTemplate.name, trycycleTemplate],
+	[dualReviewTemplate.name, dualReviewTemplate],
+	[parallelExplorationTemplate.name, parallelExplorationTemplate],
+	[stagedValidationTemplate.name, stagedValidationTemplate]
+]);
+/**
+* Returns all available pipeline template entries in insertion order.
+*/
+function listPipelineTemplates() {
+	return Array.from(PIPELINE_TEMPLATES.values());
+}
+/**
+* Returns the pipeline template entry for the given name (case-sensitive),
+* or `undefined` if not found.
+*/
+function getPipelineTemplate(name) {
+	return PIPELINE_TEMPLATES.get(name);
+}
+
 //#endregion
 //#region packages/factory/dist/twins/schema.js
 /**
@@ -37776,6 +38988,28 @@ function registerFactoryCommand(program, options) {
 			process.exit(1);
 		}
 	});
+	const templatesCmd = factoryCmd.command("templates").description("Manage reusable DOT graph pipeline templates");
+	templatesCmd.command("list").description("List available pipeline templates").action(() => {
+		const templates = listPipelineTemplates();
+		for (const t of templates) process.stdout.write(`  ${t.name.padEnd(24)}  ${t.description}\n`);
+	});
+	templatesCmd.command("init").description("Create a pipeline.dot from a template").requiredOption("--template <name>", "Template name (see: factory templates list)").option("--output <path>", "Output file path (default: pipeline.dot)", "pipeline.dot").action(async (opts) => {
+		const entry = getPipelineTemplate(opts.template);
+		if (!entry) {
+			const available = listPipelineTemplates().map((t) => t.name).join(", ");
+			process.stderr.write(`Error: Unknown template '${opts.template}'. Available: ${available}\n`);
+			process.exit(1);
+			return;
+		}
+		try {
+			await writeFile$1(opts.output, entry.dotContent, "utf-8");
+			process.stdout.write(`Created ${opts.output} from template '${entry.name}'\n`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`Error: ${msg}\n`);
+			process.exit(1);
+		}
+	});
 }
 
 //#endregion
@@ -39264,4 +40498,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-gXtnH8lO.js.map
+//# sourceMappingURL=run-C3MnOuBe.js.map