@tea-agent/loop-agent 0.1.0 → 0.2.0

package/dist/task/delegate.js

@@ -1,6 +1,7 @@
-import { access, mkdir, readFile, symlink, unlink, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, symlink, unlink } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
+import { initializeTaskLogStubs, writeTaskConfig, } from '../infrastructure/harness/task-store.js';
 import { initializeArtifacts } from '../shared/artifacts-core.js';
 import { createWorktree } from './worktree.js';
 import { loadHarnessManifest } from '../governance/harness.js';
@@ -107,11 +108,10 @@ async function syncSourceToWorktree(repoRoot, taskId, worktreePath, executor) {
     const parsedTaskConfig = JSON.parse(rawJson);
     parsedTaskConfig.executor = executor;
     await mkdir(path.dirname(destTaskConfigPath), { recursive: true });
-    await writeFile(destTaskConfigPath, `${JSON.stringify(parsedTaskConfig, null, 2)}\n`, 'utf-8');
+    await writeTaskConfig(worktreePath, taskId, parsedTaskConfig);
     await mkdir(destPaths.logsDir, { recursive: true });
     await initializeArtifacts(destTaskDir);
-    await writeFile(path.join(destPaths.logsDir, 'executor.jsonl'), '', 'utf-8');
-    await writeFile(path.join(destPaths.logsDir, 'decisions.jsonl'), '', 'utf-8');
+    await initializeTaskLogStubs(worktreePath, taskId);
     const state = await loadOrCreateWorkflowState(srcPaths.statePath, taskId, executor);
     await saveWorkflowState(destPaths.statePath, state);
 }

package/dist/task/runtime.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
-import { access, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
-import os from 'node:os';
+import { access, mkdir, readFile, readdir } from 'node:fs/promises';
 import path from 'node:path';
+import { initializeTaskLogStubs, writeTaskConfig, } from '../infrastructure/harness/task-store.js';
 import { initializeArtifacts } from '../shared/artifacts-core.js';
 import { appendDecisionRecord, appendGoalEventRecord, appendWorkflowLog } from '../shared/logger.js';
 import { loadWorkflowState, saveWorkflowState } from './state.js';
@@ -163,10 +163,9 @@ export async function createTask(repoRoot, taskId, title) {
         },
         decisionLog: [],
     };
-    await writeFile(paths.taskConfigPath, `${JSON.stringify(taskConfig, null, 2)}\n`, 'utf-8');
+    await writeTaskConfig(repoRoot, taskId, taskConfig);
     await saveWorkflowState(paths.statePath, state);
-    await writeFile(path.join(paths.logsDir, 'executor.jsonl'), '', 'utf-8');
-    await writeFile(path.join(paths.logsDir, 'decisions.jsonl'), '', 'utf-8');
+    await initializeTaskLogStubs(repoRoot, taskId);
     await appendWorkflowLog(paths.taskDir, `created task ${taskId}`);
     return paths.taskDir;
 }
@@ -289,8 +288,7 @@ export function getSupportedNextCommand(step, taskId, status, options) {
         return `npm run dev -- loop status ${taskId}`;
     }
     if (step === 'analyze' || step === 'plan' || step === 'spec' || step === 'implement' || step === 'verify' || step === 'retrospective') {
-        const dagPath = path.join(os.tmpdir(), `${taskId}-dag.json`);
-        return `npm run dev -- dag run-task ${taskId} --profile auto --strict-models --output ${JSON.stringify(dagPath)}`;
+        return `npm run dev -- dag run-task ${taskId} --profile auto --strict-models --output /tmp/${taskId}-dag.json`;
     }
     return `${step} step not yet implemented in this prototype; human intervention required`;
 }

package/dist/task/state.js

@@ -1,4 +1,5 @@
-import { copyFile, readFile, rename, unlink, writeFile, } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
+import { resolveTaskStateContext, writeWorkflowState as writeTaskWorkflowState, } from '../infrastructure/harness/task-store.js';
 import { workflowStateSchema } from '../shared/types.js';
 function parseWorkflowState(raw) {
     try {
@@ -8,18 +9,6 @@ function parseWorkflowState(raw) {
         return null;
     }
 }
-/** Persist backup atomically (tmp → rename), tolerant of Windows rename semantics. */
-async function writeBackupCopy(bakPath, json) {
-    const bakTmp = `${bakPath}.${process.pid}.tmp`;
-    await writeFile(bakTmp, json, 'utf-8');
-    try {
-        await rename(bakTmp, bakPath);
-    }
-    catch {
-        await copyFile(bakTmp, bakPath);
-        await unlink(bakTmp).catch(() => { });
-    }
-}
 export async function loadWorkflowState(statePath) {
     const bakPath = `${statePath}.bak`;
     let raw = '';
@@ -40,16 +29,13 @@ export async function loadWorkflowState(statePath) {
     }
     const fromBak = raw.trim() ? parseWorkflowState(raw) : null;
     if (fromBak) {
-        const json = `${JSON.stringify(fromBak, null, 2)}\n`;
-        await writeFile(statePath, json, 'utf-8');
-        await writeBackupCopy(bakPath, json);
+        const { repoRoot, taskId } = resolveTaskStateContext(statePath);
+        await writeTaskWorkflowState(repoRoot, taskId, fromBak);
         return fromBak;
     }
     throw new Error(`workflow state unreadable or missing: ${statePath} (no valid ${bakPath})`);
 }
 export async function saveWorkflowState(statePath, state) {
-    const json = `${JSON.stringify(state, null, 2)}\n`;
-    const bakPath = `${statePath}.bak`;
-    await writeFile(statePath, json, 'utf-8');
-    await writeBackupCopy(bakPath, json);
+    const { repoRoot, taskId } = resolveTaskStateContext(statePath);
+    await writeTaskWorkflowState(repoRoot, taskId, state);
 }

package/dist/workflows/dag/convergence/controller.js

@@ -0,0 +1,277 @@
+import { access, appendFile, cp, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { parseProcessVerdict } from "../node-execution.js";
+import { freshNodeRecord } from "../dynamic-runtime/shared.js";
+const CONVERGENCE_CHAIN_NODE_IDS = [
+    "process-supervisor-pi",
+    "process-gate-shell",
+    "repair-cursor",
+    "hard-verify-shell",
+];
+const CONVERGENCE_NON_RETRY_FAILURES = new Set([
+    "timeout",
+    "spawn-error",
+    "write-guard",
+    "missing-api-key",
+    "auth",
+    "human-rejected",
+    "decision-gate-requires-human",
+]);
+export function shouldEnableDagConvergence(spec) {
+    return (process.env.HARNESS_DAG_CONVERGENCE !== "off" &&
+        spec.convergence?.enabled === true);
+}
+export async function runConvergencePassController(input) {
+    const convergence = input.state.convergence;
+    if (!convergence?.enabled)
+        return { retry: false };
+    if (process.env.HARNESS_DAG_CONVERGENCE === "off") {
+        convergence.terminalReason = "feature-flag-off";
+        return { retry: false };
+    }
+    if (!hasConvergenceChain(input.tasksById)) {
+        convergence.terminalReason = "unsupported-dag-shape";
+        return { retry: false };
+    }
+    const hardVerify = input.state.nodes["hard-verify-shell"];
+    if (!hardVerify)
+        return { retry: false };
+    if (hardVerify.status === "FINISHED") {
+        convergence.terminalReason = "hard-verify-pass";
+        await appendConvergenceKnowledgePattern({
+            cwd: input.cwd,
+            state: input.state,
+        });
+        return { retry: false };
+    }
+    if (hardVerify.status !== "ERROR")
+        return { retry: false };
+    const currentPass = convergence.currentPass || 1;
+    const hardFailure = hardVerify.failureCategory ?? "unknown";
+    const passRecord = await buildConvergencePassRecord({
+        pass: currentPass,
+        status: "retrying",
+        reason: "hard-verify-failed",
+        state: input.state,
+        runDir: input.runDir,
+    });
+    if (CONVERGENCE_NON_RETRY_FAILURES.has(hardFailure)) {
+        passRecord.status = "terminal";
+        passRecord.reason = "non-retry-failure";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "non-retry-failure";
+        await input.persistState();
+        return { retry: false };
+    }
+    if (input.spec.convergence?.pauseOnRegression !== false &&
+        detectConvergenceRegression(convergence.passHistory, passRecord)) {
+        passRecord.status = "paused";
+        passRecord.reason = "regression";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "regression";
+        const pausedAt = new Date().toISOString();
+        input.state.status = "paused";
+        input.state.pausedAt = pausedAt;
+        input.state.pausedByNodeId = "hard-verify-shell";
+        input.state.pauseReason = "convergence-regression";
+        input.state.failureCategory = "convergence-regression";
+        await input.persistState();
+        return { retry: false, pausedByNodeId: "hard-verify-shell" };
+    }
+    if (currentPass >= convergence.maxPasses) {
+        passRecord.status = "terminal";
+        passRecord.reason = "max-passes";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "max-passes";
+        await input.persistState();
+        return { retry: false };
+    }
+    convergence.passHistory.push(passRecord);
+    convergence.currentPass = currentPass + 1;
+    await resetConvergenceNodesForNextPass({
+        spec: input.spec,
+        state: input.state,
+        tasksById: input.tasksById,
+    });
+    await input.persistState();
+    return { retry: true };
+}
+function hasConvergenceChain(tasksById) {
+    return CONVERGENCE_CHAIN_NODE_IDS.every((id) => tasksById.has(id));
+}
+async function buildConvergencePassRecord(input) {
+    const hardVerify = input.state.nodes["hard-verify-shell"];
+    const processSupervisor = input.state.nodes["process-supervisor-pi"];
+    const verifyEvidence = hardVerify?.verifyEvidence;
+    return {
+        pass: input.pass,
+        startedAt: hardVerify?.startedAt,
+        finishedAt: new Date().toISOString(),
+        status: input.status,
+        reason: input.reason,
+        hardVerifyStatus: hardVerify?.status,
+        hardVerifyFailureCategory: hardVerify?.failureCategory,
+        processVerdict: parseProcessVerdict(processSupervisor),
+        repairArtifact: processSupervisor?.repairArtifact,
+        verifyPhase: verifyEvidence?.phase,
+        verifyQuota: verifyEvidence?.quota,
+        verifyCommandCount: verifyEvidence?.commandCount,
+        verifyCommandLabels: verifyEvidence?.commandLabels,
+        shellSuccessCount: countSuccessfulShellCommands(hardVerify?.stdout),
+        artifactRefs: await preserveConvergencePassArtifacts({
+            pass: input.pass,
+            state: input.state,
+            runDir: input.runDir,
+        }),
+    };
+}
+async function preserveConvergencePassArtifacts(input) {
+    const passDir = path.join(input.runDir, "convergence", `pass-${input.pass}`);
+    await mkdir(passDir, { recursive: true });
+    const nodeIds = nodesToPreserveForConvergence(input.state);
+    const refs = [];
+    for (const nodeId of nodeIds) {
+        const node = input.state.nodes[nodeId];
+        if (!node || node.status === "PENDING")
+            continue;
+        const preservedNodeRecordPath = path.join(passDir, `${nodeId}.json`);
+        const preservedNodeDir = path.join(passDir, nodeId);
+        await copyIfExists(path.join(input.runDir, `${nodeId}.json`), preservedNodeRecordPath);
+        await copyIfExists(path.join(input.runDir, nodeId), preservedNodeDir);
+        refs.push({
+            nodeId,
+            status: node.status,
+            failureCategory: node.failureCategory,
+            nodeRecordPath: node.nodeRecordPath ?? path.join(input.runDir, `${nodeId}.json`),
+            stdoutArtifactPath: node.stdoutArtifactPath,
+            assistantArtifactPath: node.assistantArtifactPath,
+            preservedNodeRecordPath,
+            preservedNodeDir,
+        });
+    }
+    return refs;
+}
+function nodesToPreserveForConvergence(state) {
+    return CONVERGENCE_CHAIN_NODE_IDS.filter((nodeId) => state.nodes[nodeId]);
+}
+async function copyIfExists(from, to) {
+    try {
+        await access(from);
+        await cp(from, to, { recursive: true, force: true });
+    }
+    catch {
+        // Missing artifacts are represented in passHistory by absent files.
+    }
+}
+function countSuccessfulShellCommands(stdout) {
+    if (!stdout)
+        return undefined;
+    const matches = stdout.match(/\|\s*\d+\s*\|\s*true\s*\|/g);
+    if (matches)
+        return matches.length;
+    if (/\|\s*\d+\s*\|\s*false\s*\|/.test(stdout))
+        return 0;
+    const explicit = stdout.match(/(?:passed|success(?:es)?|ok)\s*[=:]\s*(\d+)/i);
+    return explicit ? Number.parseInt(explicit[1], 10) : undefined;
+}
+function detectConvergenceRegression(history, current) {
+    const previous = [...history]
+        .reverse()
+        .find((pass) => pass.shellSuccessCount !== undefined);
+    if (previous?.shellSuccessCount !== undefined &&
+        current.shellSuccessCount !== undefined &&
+        current.shellSuccessCount < previous.shellSuccessCount) {
+        return true;
+    }
+    return isWorseFailureCategory(previous?.hardVerifyFailureCategory, current.hardVerifyFailureCategory);
+}
+function isWorseFailureCategory(previous, current) {
+    const severity = new Map([
+        ["success", 0],
+        ["nonzero-exit", 1],
+        ["unknown", 2],
+        ["timeout", 3],
+        ["spawn-error", 3],
+        ["write-guard", 4],
+    ]);
+    if (!previous || !current)
+        return false;
+    return (severity.get(current) ?? 2) > (severity.get(previous) ?? 2);
+}
+async function appendConvergenceKnowledgePattern(input) {
+    const convergence = input.state.convergence;
+    if (!convergence || convergence.passHistory.length === 0)
+        return;
+    const supervisor = input.state.nodes["process-supervisor-pi"];
+    const hardVerify = input.state.nodes["hard-verify-shell"];
+    const pattern = {
+        schemaVersion: 1,
+        type: "dag-convergence-repair",
+        runId: input.state.runId,
+        recordedAt: new Date().toISOString(),
+        passCount: convergence.currentPass,
+        terminalReason: convergence.terminalReason ?? "hard-verify-pass",
+        processVerdict: parseProcessVerdict(supervisor),
+        repairArtifact: supervisor?.repairArtifact,
+        supervisorStructuredBlock: extractSupervisorStructuredBlock(supervisor),
+        hardVerify: {
+            status: hardVerify?.status,
+            failureCategory: hardVerify?.failureCategory,
+            nodeRecordPath: hardVerify?.nodeRecordPath,
+        },
+        passHistory: convergence.passHistory.map((pass) => ({
+            pass: pass.pass,
+            reason: pass.reason,
+            hardVerifyFailureCategory: pass.hardVerifyFailureCategory,
+            shellSuccessCount: pass.shellSuccessCount,
+        })),
+    };
+    const knowledgeDir = path.join(input.cwd, ".harness", "knowledge");
+    await mkdir(knowledgeDir, { recursive: true });
+    await appendFile(path.join(knowledgeDir, "patterns.jsonl"), `${JSON.stringify(pattern)}\n`, "utf-8");
+}
+function extractSupervisorStructuredBlock(node) {
+    // Legacy compatibility only. New supervisor prompts must emit REPAIR_ARTIFACT_JSON.
+    const text = `${node?.assistantText ?? ""}\n${node?.stdout ?? ""}`;
+    const block = {};
+    for (const key of ["FAILURE_CLASS", "FIX_SCOPE", "INVARIANT"]) {
+        const match = text.match(new RegExp(`^${key}:\\s*(.+)$`, "im"));
+        if (match?.[1])
+            block[key] = match[1].trim();
+    }
+    return block;
+}
+async function resetConvergenceNodesForNextPass(input) {
+    const resetIds = new Set(CONVERGENCE_CHAIN_NODE_IDS);
+    for (const id of collectTransitiveDescendantTaskIds(input.spec, "hard-verify-shell")) {
+        const node = input.state.nodes[id];
+        if (node?.status === "SKIPPED")
+            resetIds.add(id);
+    }
+    for (const id of resetIds) {
+        const task = input.tasksById.get(id);
+        if (!task)
+            continue;
+        input.state.nodes[id] = freshNodeRecord(task);
+    }
+}
+function collectTransitiveDescendantTaskIds(spec, rootNodeId) {
+    const childrenByParent = new Map();
+    for (const task of spec.tasks) {
+        for (const parent of task.depends_on) {
+            const children = childrenByParent.get(parent) ?? [];
+            children.push(task.id);
+            childrenByParent.set(parent, children);
+        }
+    }
+    const descendants = new Set();
+    const queue = [...(childrenByParent.get(rootNodeId) ?? [])];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (descendants.has(id))
+            continue;
+        descendants.add(id);
+        queue.push(...(childrenByParent.get(id) ?? []));
+    }
+    return descendants;
+}

package/dist/workflows/dag/dynamic-runtime/condition.js

@@ -0,0 +1,48 @@
+import { parseConditionLiteral, resolveOutputSelector } from "./shared.js";
+function evaluateConditionExpression(expression, state) {
+    const equality = expression.match(/^\s*(\$\..+?)\s*==\s*(.+?)\s*$/);
+    if (!equality?.[1]) {
+        throw new Error(`unsupported condition expression: ${expression}`);
+    }
+    const actual = resolveOutputSelector(equality[1], state);
+    const expected = parseConditionLiteral(equality[2] ?? "");
+    return actual === expected;
+}
+export function executeDynamicCondition(input) {
+    const started = Date.now();
+    const matchedIndex = input.condition.cases.findIndex((conditionCase) => evaluateConditionExpression(conditionCase.when, input.state));
+    const selected = matchedIndex >= 0
+        ? input.condition.cases[matchedIndex]?.then
+        : input.condition.default;
+    if (!selected) {
+        throw new Error(`condition ${input.task.id} did not match and has no default`);
+    }
+    if (!input.tasksById.has(selected)) {
+        throw new Error(`condition ${input.task.id} selected missing target ${selected}`);
+    }
+    const branchTargets = new Set([
+        ...input.condition.cases.map((conditionCase) => conditionCase.then),
+        ...(input.condition.default ? [input.condition.default] : []),
+    ]);
+    for (const target of branchTargets) {
+        if (target === selected)
+            continue;
+        const record = input.state.nodes[target];
+        if (record?.status === "PENDING") {
+            record.status = "SKIPPED";
+            record.skippedReason = `condition ${input.task.id} selected ${selected}; branch not selected`;
+        }
+    }
+    return {
+        ok: true,
+        stdout: JSON.stringify({
+            workflowNodeId: input.condition.workflowNodeId,
+            selected,
+            matchedCaseIndex: matchedIndex >= 0 ? matchedIndex : undefined,
+            defaulted: matchedIndex < 0,
+        }),
+        stderr: "",
+        failureCategory: "success",
+        durationMs: Date.now() - started,
+    };
+}

package/dist/workflows/dag/dynamic-runtime/loop-until.js

@@ -0,0 +1,156 @@
+import { writeDagRunJsonArtifact } from "../../../infrastructure/harness/artifact-store.js";
+import { executeDagNode, } from "../node-execution.js";
+import { writeRunSpec } from "../run-store.js";
+import { freshNodeRecord, lookupPath, parseConditionLiteral, parseJsonFromText, } from "./shared.js";
+function evaluateLoopStopExpression(input) {
+    const equality = input.expression.match(/^\s*(\$\..+?)\s*==\s*(.+?)\s*$/);
+    if (!equality?.[1]) {
+        throw new Error(`unsupported loop_until stop expression: ${input.expression}`);
+    }
+    const selector = equality[1];
+    let actual;
+    if (selector.startsWith("$.last.output.")) {
+        actual = lookupPath(input.lastOutput, selector.slice("$.last.output.".length));
+    }
+    else if (selector === "$.iteration") {
+        actual = input.iteration;
+    }
+    else {
+        throw new Error(`unsupported loop_until stop selector: ${selector}`);
+    }
+    const expected = parseConditionLiteral(equality[2] ?? "");
+    return actual === expected;
+}
+function renderLoopTemplate(template, iteration) {
+    const iterationStatus = iteration >= 2 ? "passed" : "failed";
+    return template
+        .replace(/\{\{\s*iteration\s*\}\}/g, String(iteration))
+        .replace(/\{\{\s*iterationStatus\s*\}\}/g, iterationStatus);
+}
+function buildLoopBodyChildTask(input) {
+    const { parent, bodyTask, iteration, nodeId, bodyIdMap } = input;
+    const mappedDepends = bodyTask.dependsOn.map((depId) => bodyIdMap.get(depId) ?? depId);
+    return {
+        id: nodeId,
+        depends_on: mappedDepends.length > 0 ? mappedDepends : parent.depends_on,
+        complexity: bodyTask.complexity,
+        subtask_prompt: renderLoopTemplate(bodyTask.subtaskPromptTemplate, iteration),
+        executor: bodyTask.executor,
+        role: bodyTask.role,
+        writePolicy: bodyTask.writePolicy,
+        allowedPaths: bodyTask.allowedPaths,
+        forbiddenPaths: bodyTask.forbiddenPaths,
+        writeSet: bodyTask.writeSet,
+        outputContract: bodyTask.outputContract,
+        static: bodyTask.executor === "static"
+            ? {
+                resultMarkdown: bodyTask.staticResultTemplate
+                    ? renderLoopTemplate(bodyTask.staticResultTemplate, iteration)
+                    : "dynamic loop child completed",
+            }
+            : undefined,
+    };
+}
+export async function executeDynamicLoopUntil(input) {
+    const started = Date.now();
+    const executedChildren = [];
+    let stopped = false;
+    let stopReason = "";
+    let iterations = 0;
+    for (let iteration = 1; iteration <= input.loop.maxIterations; iteration += 1) {
+        iterations = iteration;
+        const bodyIdMap = new Map(input.loop.bodyTasks.map((bodyTask) => [
+            bodyTask.id,
+            `${input.task.id}-r${iteration}-${bodyTask.id}`,
+        ]));
+        const children = input.loop.bodyTasks.map((bodyTask) => buildLoopBodyChildTask({
+            parent: input.task,
+            loop: input.loop,
+            bodyTask,
+            iteration,
+            nodeId: bodyIdMap.get(bodyTask.id),
+            bodyIdMap,
+        }));
+        for (const child of children) {
+            if (!input.tasksById.has(child.id)) {
+                input.tasksById.set(child.id, child);
+                input.spec.tasks.push(child);
+            }
+            if (!input.state.nodes[child.id]) {
+                input.state.nodes[child.id] = freshNodeRecord(child);
+            }
+        }
+        input.state.ranks.push(children.map((child) => child.id));
+        await writeRunSpec(input.runDir, input.spec);
+        await input.persistState();
+        for (const child of children) {
+            await executeDagNode({
+                nodeId: child.id,
+                tasksById: input.tasksById,
+                state: input.state,
+                spec: input.spec,
+                cwd: input.cwd,
+                runDir: input.runDir,
+                executeNode: input.executeNode,
+                executeDynamicNode: input.executeDynamicNode,
+                observer: input.observer,
+                persistState: input.persistState,
+                onPause: () => {
+                    throw new Error(`dynamic child node ${child.id} requested a human pause; loop_until children do not support pause in v0`);
+                },
+            });
+            executedChildren.push(child.id);
+        }
+        const failedChild = children.find((child) => input.state.nodes[child.id]?.status !== "FINISHED");
+        if (failedChild) {
+            return {
+                ok: false,
+                stdout: JSON.stringify({
+                    workflowNodeId: input.loop.workflowNodeId,
+                    iterations,
+                    stopped: false,
+                    children: executedChildren,
+                }),
+                stderr: `loop_until child failed: ${failedChild.id}`,
+                failureCategory: "dynamic-loop-child-failed",
+                durationMs: Date.now() - started,
+            };
+        }
+        const lastChild = children[children.length - 1];
+        const lastOutput = parseJsonFromText(input.state.nodes[lastChild.id]?.stdout);
+        const matched = input.loop.stopWhenAny.find((expression) => evaluateLoopStopExpression({
+            expression,
+            lastOutput,
+            iteration,
+        }));
+        if (matched) {
+            stopped = true;
+            stopReason = matched;
+            break;
+        }
+    }
+    const manifest = {
+        workflowNodeId: input.loop.workflowNodeId,
+        expandedAt: new Date().toISOString(),
+        maxIterations: input.loop.maxIterations,
+        iterations,
+        stopped,
+        stopReason: stopped ? stopReason : undefined,
+        children: executedChildren.map((nodeId) => ({ nodeId })),
+    };
+    await writeDagRunJsonArtifact(input.runDir, `expansions/${input.task.id}.expansion.json`, manifest);
+    return {
+        ok: true,
+        stdout: JSON.stringify({
+            workflowNodeId: input.loop.workflowNodeId,
+            iterations,
+            stopped,
+            stopReason: stopped ? stopReason : undefined,
+            maxIterationsReached: !stopped,
+            children: executedChildren,
+        }),
+        stderr: "",
+        failureCategory: "success",
+        durationMs: Date.now() - started,
+    };
+}