@tea-agent/loop-agent 0.1.0

package/dist/workflows/loop/benchmark.js

@@ -0,0 +1,510 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+const CONTROL_GROUPS = [
+    "single-repair",
+    "3-pass-convergence",
+    "3-pass-convergence+quota",
+];
+const METRICS_SCHEMA = [
+    "pass",
+    "fullVerifyPass",
+    "wallTimeMs",
+    "tokenEstimate",
+    "executorCalls",
+    "humanPause",
+    "regressionPause",
+    "changedPaths",
+    "repairPasses",
+];
+function result(group, metrics, evidenceRefs, notes) {
+    return { group, metrics, evidenceRefs, notes };
+}
+function sample(id, title, taskClass, results) {
+    return {
+        id,
+        title,
+        taskClass,
+        evidenceType: "deterministic-fixture",
+        results,
+    };
+}
+export const LOOP_BENCHMARK_FIXTURE_SAMPLES = [
+    sample("LB-01", "hard verify fails twice then pass 3 succeeds", "dag-runtime", [
+        result("single-repair", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 118000,
+            tokenEstimate: 6400,
+            executorCalls: 5,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 2,
+            repairPasses: 1,
+        }, ["./test/dag-runner.test.ts"], "Single repair exhausts before the third successful hard verification."),
+        result("3-pass-convergence", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 236000,
+            tokenEstimate: 13700,
+            executorCalls: 11,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 2,
+            repairPasses: 3,
+        }, ["./test/dag-runner.test.ts"], "Convergence re-enters supervisor, repair, and hard verify until pass 3."),
+        result("3-pass-convergence+quota", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 172000,
+            tokenEstimate: 9800,
+            executorCalls: 11,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 2,
+            repairPasses: 3,
+        }, [
+            "./test/dag-runner.test.ts",
+            "./test/verify-step.test.ts",
+        ], "Intermediate verification uses quota while final hard gate remains full."),
+    ]),
+    sample("LB-02", "shell success count regression pauses run", "dag-runtime", [
+        result("single-repair", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 94000,
+            tokenEstimate: 5100,
+            executorCalls: 5,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 3,
+            repairPasses: 1,
+        }, ["./test/dag-runner.test.ts"], "Single repair ends failed without enough evidence to classify regression."),
+        result("3-pass-convergence", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 149000,
+            tokenEstimate: 8200,
+            executorCalls: 8,
+            humanPause: true,
+            regressionPause: true,
+            changedPaths: 3,
+            repairPasses: 2,
+        }, ["./test/dag-runner.test.ts"], "Convergence pauses instead of retrying blindly after regression signal."),
+        result("3-pass-convergence+quota", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 121000,
+            tokenEstimate: 6900,
+            executorCalls: 8,
+            humanPause: true,
+            regressionPause: true,
+            changedPaths: 3,
+            repairPasses: 2,
+        }, ["./test/dag-runner.test.ts"], "Quota reduces intermediate cost but still pauses on regression."),
+    ]),
+    sample("LB-03", "write guard hard failure must not retry", "dag-runtime", [
+        result("single-repair", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 42000,
+            tokenEstimate: 2200,
+            executorCalls: 4,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/dag-runner.test.ts"], "Write-guard failure remains terminal."),
+        result("3-pass-convergence", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 43000,
+            tokenEstimate: 2300,
+            executorCalls: 4,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/dag-runner.test.ts"], "Non-retry class is not re-entered."),
+        result("3-pass-convergence+quota", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 43000,
+            tokenEstimate: 2300,
+            executorCalls: 4,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/dag-runner.test.ts"], "Quota strategy does not change write-guard retry policy."),
+    ]),
+    sample("LB-04", "quota final gate must stay full", "loop-runtime", [
+        result("single-repair", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 78000,
+            tokenEstimate: 2600,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/verify-step.test.ts"], "Baseline full verification passes."),
+        result("3-pass-convergence", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 79000,
+            tokenEstimate: 2700,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/verify-step.test.ts"], "No retry needed."),
+        result("3-pass-convergence+quota", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 52000,
+            tokenEstimate: 1900,
+            executorCalls: 3,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/verify-step.test.ts"], "Intermediate quota is followed by full final gate."),
+    ]),
+    sample("LB-05", "loop auto cursor fix remains opt-in", "loop-runtime", [
+        result("single-repair", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 31000,
+            tokenEstimate: 1800,
+            executorCalls: 2,
+            humanPause: true,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/loop-workflow.test.ts"], "Default auto loop will not write."),
+        result("3-pass-convergence", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 96000,
+            tokenEstimate: 5200,
+            executorCalls: 5,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/loop-workflow.test.ts"], "Approval or enabled policy triggers bounded cursor-fix."),
+        result("3-pass-convergence+quota", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 76000,
+            tokenEstimate: 4400,
+            executorCalls: 5,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/loop-workflow.test.ts"], "Quota only affects verify rounds after bounded write."),
+    ]),
+    sample("LB-06", "structured fix brief feeds repair", "loop-runtime", [
+        result("single-repair", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 70000,
+            tokenEstimate: 4200,
+            executorCalls: 3,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/auto-run-loop.test.ts"], "Raw failure summary alone does not encode invariant or scope."),
+        result("3-pass-convergence", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 112000,
+            tokenEstimate: 6600,
+            executorCalls: 6,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 2,
+        }, ["./test/auto-run-loop.test.ts"], "Structured category, root cause, scope, and invariant make pass 2 succeed."),
+        result("3-pass-convergence+quota", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 91000,
+            tokenEstimate: 5700,
+            executorCalls: 6,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 2,
+        }, ["./test/auto-run-loop.test.ts"], "Structured fix brief plus quota keeps final verification strict."),
+    ]),
+    sample("LB-07", "learned guidance injection is bounded", "skill-policy", [
+        result("single-repair", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 54000,
+            tokenEstimate: 3300,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/dag-skills.test.ts"], "Baseline prompt has no learned guidance."),
+        result("3-pass-convergence", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 53000,
+            tokenEstimate: 3500,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/dag-skills.test.ts"], "Learned guidance injection remains advisory and top-3 bounded."),
+        result("3-pass-convergence+quota", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 48000,
+            tokenEstimate: 3200,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 1,
+            repairPasses: 1,
+        }, ["./test/dag-skills.test.ts"], "Quota has no effect on learned guidance safety."),
+    ]),
+    sample("LB-08", "supervised template exposes structured repair contract", "dag-runtime", [
+        result("single-repair", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 61000,
+            tokenEstimate: 3000,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/dag-supervised-template.test.ts"], "Template contract exists."),
+        result("3-pass-convergence", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 62000,
+            tokenEstimate: 3100,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/dag-supervised-template.test.ts"], "Structured fields are required across supervised convergence."),
+        result("3-pass-convergence+quota", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 58000,
+            tokenEstimate: 2900,
+            executorCalls: 2,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/dag-supervised-template.test.ts"], "Quota does not weaken the repair contract."),
+    ]),
+    sample("LB-09", "task config stays backward compatible", "docs-governance", [
+        result("single-repair", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 47000,
+            tokenEstimate: 2100,
+            executorCalls: 1,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/task-runtime.test.ts"], "Old task.json parses without convergence fields."),
+        result("3-pass-convergence", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 48000,
+            tokenEstimate: 2200,
+            executorCalls: 1,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/task-runtime.test.ts"], "Convergence config remains optional."),
+        result("3-pass-convergence+quota", {
+            pass: true,
+            fullVerifyPass: true,
+            wallTimeMs: 46000,
+            tokenEstimate: 2100,
+            executorCalls: 1,
+            humanPause: false,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/task-runtime.test.ts"], "Quota config remains optional."),
+    ]),
+    sample("LB-10", "handoff coverage stays separate from completion", "docs-governance", [
+        result("single-repair", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 39000,
+            tokenEstimate: 1700,
+            executorCalls: 1,
+            humanPause: true,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/requirement-coverage.test.ts"], "Missing acceptance coverage blocks handoff."),
+        result("3-pass-convergence", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 40000,
+            tokenEstimate: 1800,
+            executorCalls: 1,
+            humanPause: true,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/requirement-coverage.test.ts"], "Extra passes do not bypass missing acceptance coverage."),
+        result("3-pass-convergence+quota", {
+            pass: false,
+            fullVerifyPass: false,
+            wallTimeMs: 40000,
+            tokenEstimate: 1800,
+            executorCalls: 1,
+            humanPause: true,
+            regressionPause: false,
+            changedPaths: 0,
+            repairPasses: 0,
+        }, ["./test/requirement-coverage.test.ts"], "Quota does not bypass requirement coverage."),
+    ]),
+];
+export function aggregateLoopBenchmark(samples) {
+    return CONTROL_GROUPS.map((group) => {
+        const results = samples.flatMap((entry) => entry.results.filter((item) => item.group === group));
+        const changedPathsTotal = results.reduce((sum, item) => sum + item.metrics.changedPaths, 0);
+        return {
+            group,
+            sampleCount: results.length,
+            passCount: results.filter((item) => item.metrics.pass).length,
+            fullVerifyPassCount: results.filter((item) => item.metrics.fullVerifyPass).length,
+            humanPauseCount: results.filter((item) => item.metrics.humanPause)
+                .length,
+            regressionPauseCount: results.filter((item) => item.metrics.regressionPause).length,
+            totalWallTimeMs: results.reduce((sum, item) => sum + item.metrics.wallTimeMs, 0),
+            totalTokenEstimate: results.reduce((sum, item) => sum + item.metrics.tokenEstimate, 0),
+            totalExecutorCalls: results.reduce((sum, item) => sum + item.metrics.executorCalls, 0),
+            avgChangedPaths: results.length
+                ? Number((changedPathsTotal / results.length).toFixed(2))
+                : 0,
+        };
+    });
+}
+export function buildLoopBenchmarkResult(options = {}) {
+    const samples = options.samples ?? LOOP_BENCHMARK_FIXTURE_SAMPLES;
+    const aggregates = aggregateLoopBenchmark(samples);
+    const single = aggregates.find((entry) => entry.group === "single-repair");
+    const quota = aggregates.find((entry) => entry.group === "3-pass-convergence+quota");
+    const deterministicOnly = samples.every((entry) => entry.evidenceType === "deterministic-fixture");
+    const rationale = [
+        "Deterministic fixtures cover the three control groups across 10 task samples.",
+        "At least one fixture shows failed repair becoming successful only under three-pass convergence.",
+        "Live Pi/Cursor dogfood evidence is not present in this benchmark artifact.",
+        "convergence.enabled remains opt-in; this benchmark does not justify a global default change.",
+    ];
+    const recommendation = deterministicOnly || !single || !quota
+        ? "maintain-opt-in"
+        : quota.passCount >= single.passCount
+            ? "expand-live-sample"
+            : "maintain-opt-in";
+    return {
+        command: "loop-benchmark",
+        generatedAt: options.generatedAt ?? new Date().toISOString(),
+        liveCallsPerformed: false,
+        sampleCount: samples.length,
+        controlGroups: CONTROL_GROUPS,
+        metricsSchema: METRICS_SCHEMA,
+        samples,
+        aggregates,
+        liveDogfood: {
+            status: "blocked",
+            reason: "No live Pi/Cursor executor run refs were supplied to this deterministic M0 baseline.",
+            requiredEvidence: [
+                "completed DAG run ref with convergence.enabled=true",
+                "single-repair comparison run ref for the same task",
+                "3-pass+quota comparison run ref for the same task",
+            ],
+        },
+        recommendation,
+        rationale,
+    };
+}
+function formatBool(value) {
+    return value ? "yes" : "no";
+}
+function formatMs(value) {
+    return `${Math.round(value / 1000)}s`;
+}
+export function formatLoopBenchmarkMarkdown(result) {
+    const lines = [
+        "# loop-agent Loop Benchmark Baseline",
+        "",
+        `Date: ${result.generatedAt.slice(0, 10)}`,
+        "",
+        "## Scope",
+        "",
+        "This report is the M0 deterministic baseline for `docs/exec-plans/active/2026-06-30-loop-agent-loop-evolution-roadmap.md`.",
+        "It compares `single-repair`, `3-pass-convergence`, and `3-pass-convergence+quota` on fixture-backed loop-agent workflow samples.",
+        "It performs no live Pi or Cursor calls and must not be treated as statistical evidence for enabling convergence by default.",
+        "",
+        "## Command",
+        "",
+        "```bash",
+        "cd .",
+        "npm run dev -- loop-benchmark --markdown --output docs/reports/2026-06-30-loop-agent-loop-benchmark.md",
+        "```",
+        "",
+        "## Recommendation",
+        "",
+        `recommendation | ${result.recommendation}`,
+        `liveCallsPerformed | ${String(result.liveCallsPerformed)}`,
+        `liveDogfood | ${result.liveDogfood.status}`,
+        `sampleCount | ${result.sampleCount}`,
+        "",
+        "Rationale:",
+        ...result.rationale.map((item) => `- ${item}`),
+        "",
+        "## Metrics Schema",
+        "",
+        ...result.metricsSchema.map((item) => `- ${item}`),
+        "",
+        "## Aggregate Results",
+        "",
+        "| Control Group | Samples | Pass | Full Verify Pass | Human Pause | Regression Pause | Wall Time | Token Estimate | Executor Calls | Avg Changed Paths |",
+        "|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
+        ...result.aggregates.map((entry) => `| ${entry.group} | ${entry.sampleCount} | ${entry.passCount} | ${entry.fullVerifyPassCount} | ${entry.humanPauseCount} | ${entry.regressionPauseCount} | ${formatMs(entry.totalWallTimeMs)} | ${entry.totalTokenEstimate} | ${entry.totalExecutorCalls} | ${entry.avgChangedPaths} |`),
+        "",
+        "## Sample Matrix",
+        "",
+        "| Sample | Class | Evidence | Control Group | Pass | Full Verify | Repair Passes | Evidence Refs | Notes |",
+        "|---|---|---|---|---|---|---:|---|---|",
+    ];
+    for (const entry of result.samples) {
+        for (const item of entry.results) {
+            lines.push(`| ${entry.id} ${entry.title} | ${entry.taskClass} | ${entry.evidenceType} | ${item.group} | ${formatBool(item.metrics.pass)} | ${formatBool(item.metrics.fullVerifyPass)} | ${item.metrics.repairPasses} | ${item.evidenceRefs.join("<br>")} | ${item.notes} |`);
+        }
+    }
+    lines.push("", "## Live Dogfood Status", "", `Status: ${result.liveDogfood.status}`, "", result.liveDogfood.reason, "", "Required evidence before default expansion:", ...result.liveDogfood.requiredEvidence.map((item) => `- ${item}`), "", "## Acceptance Coverage", "", "- Benchmark report lists samples, control groups, metrics, and evidence refs.", "- Deterministic fixtures are explicitly separated from live dogfood.", "- Recommendation is go/no-go: keep convergence opt-in and expand live sample collection.", "- `LB-01` records failed single repair becoming successful under three-pass convergence.", "- This report does not change `convergence.enabled` default.", "");
+    return lines.join("\n");
+}
+export async function writeLoopBenchmarkMarkdown(repoRoot, outputPath, result) {
+    const resolved = path.isAbsolute(outputPath)
+        ? outputPath
+        : path.resolve(repoRoot, outputPath);
+    await writeFile(resolved, formatLoopBenchmarkMarkdown(result), "utf-8");
+    return resolved;
+}

package/dist/workflows/loop/closeout.js

@@ -0,0 +1,134 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { getLoopPaths } from "./paths.js";
+import { readLoopRounds } from "./rounds.js";
+import { readLoopSignals, pendingLoopSignals } from "./signals.js";
+import { loadLoopState } from "./state.js";
+import { loadTaskConfig } from "../../task/runtime.js";
+import { repoRelativePath } from "../../shared/path-refs.js";
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function bulletList(values, fallback) {
+    const items = values.length > 0 ? values : [fallback];
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function resultStatus(status) {
+    if (status === "complete")
+        return "complete";
+    if (status === "paused")
+        return "paused";
+    if (status === "blocked")
+        return "blocked";
+    return "partial";
+}
+function resolveWorkflowPath(input) {
+    if (input.complexity === "small")
+        return "micro-or-small";
+    if (input.hasDagRound)
+        return "dag";
+    if (input.dagFallbackReason.trim())
+        return "explicit-fallback";
+    return "missing-dag-evidence";
+}
+export async function generateLoopCloseout(repoRoot, taskId) {
+    const paths = getLoopPaths(repoRoot, taskId);
+    const [state, rounds, signals, objective, context, taskConfig] = await Promise.all([
+        loadLoopState(repoRoot, taskId),
+        readLoopRounds(repoRoot, taskId),
+        readLoopSignals(repoRoot, taskId),
+        readFile(paths.objectivePath, "utf-8").catch(() => ""),
+        readFile(paths.contextPath, "utf-8").catch(() => ""),
+        loadTaskConfig(repoRoot, taskId),
+    ]);
+    const completedCriteria = unique([
+        ...state.completedCriteria,
+        ...rounds.flatMap((round) => round.completedCriteria),
+    ]);
+    const verificationEvidence = unique(rounds.flatMap((round) => [
+        round.verification,
+        ...round.refs.filter((ref) => /verification|review|run|dag|result/i.test(ref)),
+    ]));
+    const pendingSignals = pendingLoopSignals(signals);
+    const hasDagRound = rounds.some((round) => round.action === "dag");
+    const dagFallbackReason = (taskConfig.dagFallbackReason ?? "").trim();
+    const workflowPath = resolveWorkflowPath({
+        complexity: taskConfig.complexity,
+        hasDagRound,
+        dagFallbackReason,
+    });
+    const remainingRisks = unique([
+        ...(state.status === "complete" ? [] : state.openFrontier),
+        ...(state.freshness.sourceStale ? ["Task source is stale against loop state."] : []),
+        ...pendingSignals.map((signal) => `Pending ${signal.type} signal: ${signal.message}`),
+        ...(workflowPath === "missing-dag-evidence"
+            ? ["Complex loop has no DAG round evidence and no task dagFallbackReason."]
+            : []),
+        ...(state.status === "complete"
+            ? []
+            : [`Loop status is ${state.status}; treat this closeout as partial.`]),
+    ]);
+    const recordedAt = new Date().toISOString();
+    const relativeCloseoutPath = repoRelativePath(repoRoot, paths.closeoutPath);
+    const record = {
+        schemaVersion: 1,
+        taskId,
+        status: state.status,
+        resultStatus: resultStatus(state.status),
+        closeoutPath: relativeCloseoutPath,
+        workflowPath,
+        dagFallbackReason,
+        completedCriteria,
+        verificationEvidence,
+        remainingRisks,
+        roundCount: rounds.length,
+        recordedAt,
+    };
+    const latestRounds = rounds
+        .slice(-5)
+        .map((round) => `- round ${round.round}: ${round.action} -> ${round.result}; next=${round.next}`)
+        .join("\n");
+    const markdown = [
+        "# Loop Closeout Draft",
+        "",
+        `taskId: ${taskId}`,
+        `status: ${record.status}`,
+        `resultStatus: ${record.resultStatus}`,
+        `workflowPath: ${record.workflowPath}`,
+        ...(record.dagFallbackReason ? [`dagFallbackReason: ${record.dagFallbackReason}`] : []),
+        `rounds: ${record.roundCount}`,
+        `recordedAt: ${record.recordedAt}`,
+        "",
+        "## Workflow Path",
+        `- ${record.workflowPath}`,
+        ...(record.dagFallbackReason ? [`- fallback reason: ${record.dagFallbackReason}`] : []),
+        "",
+        "## Completed Criteria",
+        bulletList(completedCriteria, "No completed criteria recorded."),
+        "",
+        "## Verification Evidence",
+        bulletList(verificationEvidence, "No concrete verification evidence recorded."),
+        "",
+        "## Remaining Risks",
+        bulletList(remainingRisks, "No remaining risks recorded."),
+        "",
+        "## Recent Rounds",
+        latestRounds || "- No rounds recorded.",
+        "",
+        "## Objective Snapshot",
+        "```md",
+        objective.trim() || "(empty)",
+        "```",
+        "",
+        "## Context Snapshot",
+        "```md",
+        context.trim() || "(empty)",
+        "```",
+        "",
+        "## Notes",
+        "- This draft is derived from loop state and executor refs.",
+        "- It does not modify completed DAG or one-shot run facts.",
+        "",
+    ].join("\n");
+    await writeFile(paths.closeoutPath, markdown, "utf-8");
+    return record;
+}

package/dist/workflows/loop/context.js

@@ -0,0 +1,48 @@
+import { writeFile } from "node:fs/promises";
+import { getLoopPaths } from "./paths.js";
+import { readLoopRounds } from "./rounds.js";
+import { refreshLoopState } from "./state.js";
+import { appendLoopEvent } from "./events.js";
+export async function rewriteLoopContext(repoRoot, taskId) {
+    const rounds = await readLoopRounds(repoRoot, taskId);
+    const latest = rounds.at(-1);
+    if (!latest)
+        return "";
+    const content = [
+        "# Loop Context",
+        "",
+        "## Current State",
+        `- Completed: ${latest.completedCriteria.length > 0 ? latest.completedCriteria.join("; ") : "none newly completed"}.`,
+        `- Open frontier: ${latest.next || "choose the next bounded action"}.`,
+        `- Current hypothesis: ${latest.decision === "continue" ? latest.next : `loop decision is ${latest.decision}`}.`,
+        "",
+        "## Verified Facts",
+        `- Latest action: ${latest.action}.`,
+        `- Latest result: ${latest.result}.`,
+        `- Verification: ${latest.verification || "not recorded"}.`,
+        `- Evidence refs: ${latest.refs.length > 0 ? latest.refs.join(", ") : "none"}.`,
+        "",
+        "## Last Round Lessons",
+        `- What worked: ${latest.result}.`,
+        `- What failed: ${latest.failureCategory || "not classified"}.`,
+        `- Avoid next round: ${latest.lesson}.`,
+        "",
+        "## Next Suggested Action",
+        `- Action: ${latest.next}.`,
+        `- Why: ${latest.lesson}.`,
+        "- Expected evidence: a new rounds.jsonl entry and deterministic verification when claiming completion.",
+        "",
+        "## Risk Notes",
+        `- Last decision: ${latest.decision}.`,
+        "",
+    ].join("\n");
+    await writeFile(getLoopPaths(repoRoot, taskId).contextPath, content, "utf-8");
+    await refreshLoopState(repoRoot, taskId);
+    await appendLoopEvent(repoRoot, taskId, {
+        type: "context_rewrite",
+        round: latest.round,
+        message: `context rewritten from round ${latest.round}`,
+        refs: latest.refs,
+    });
+    return content;
+}