loopforge 1.7.0 → 1.12.0

package/dist/tests/loop-compiler.test.js

@@ -1,8 +1,8 @@
 /** Tests for loop compiler core: gates, advisories, L0/L1/L2 compilation. */
 import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
-import { decideLevel, compileLoop, computeGoalTextHash, deriveGoalId, alignTask, compileL2, buildRollingSummary, formatRollingSummaryForPrompt, } from "../loop-compiler.js";
-import { makeLoopCompileRequest, makeLoopRoundResult, makeLoopObjective, makeRollingSummary, } from "../protocol.js";
+import { decideLevel, compileLoop, computeGoalTextHash, deriveGoalId, alignTask, compileL2, buildRollingSummary, formatRollingSummaryForPrompt, buildCheckpointSummary, formatCheckpointForPrompt, filterConstraintsForSubTask, formatDelegationPrompt, buildDelegationSummary, } from "../loop-compiler.js";
+import { makeLoopCompileRequest, makeLoopRoundResult, makeLoopObjective, makeRollingSummary, makeCheckpointSummary, makeSelfEvaluation, } from "../protocol.js";
 import { resetPolicy } from "../policy.js";
 describe("Loop Compiler — Goal Identity", () => {
     it("computeGoalTextHash produces a 12-char hex string", () => {
@@ -409,16 +409,17 @@ describe("Loop Compiler — Cross-Round Scenarios", () => {
 // Failure Lineage Weighting (v1.7)
 // ═══════════════════════════════════════════════════════════════════════════
 function makeVaultResult(loopId, round, qualityScore, task, outputSummary = "", techniqueUsed = "zero-shot", constraintViolations = []) {
+    const success = qualityScore >= 3;
     return {
         task,
         output_summary: outputSummary,
         constraint_violations: constraintViolations,
         technique_used: techniqueUsed,
-        quality_score: qualityScore,
+        success,
         loop_lineage: {
             loop_id: loopId,
             round,
-            quality_score: qualityScore,
+            success,
             task,
             technique_used: techniqueUsed,
         },
@@ -437,12 +438,12 @@ describe("Failure Lineage Weighting — buildRollingSummary", () => {
         const rs = buildRollingSummary("loop-1", 4, vault);
         assert.ok(rs !== null);
         assert.equal(rs.failed_patterns?.length ?? 0, 0);
-        // key_lessons should not have [Consider alternatives] marker
-        for (const kl of rs.key_lessons) {
-            assert.ok(!kl.includes("[Consider alternatives]"));
+        // key_outcomes should not have [Consider alternatives] marker
+        for (const ko of rs.key_outcomes) {
+            assert.ok(!ko.includes("[Consider alternatives]"));
         }
     });
-    it("detects 2 consecutive low-quality rounds with same technique and similar task", () => {
+    it("detects 2 consecutive failed rounds with same technique and similar task", () => {
         const vault = {
             results: [
                 makeVaultResult("loop-1", 1, 2, "fix cache bug", "Tried cache fix A", "zero-shot"),
@@ -459,7 +460,7 @@ describe("Failure Lineage Weighting — buildRollingSummary", () => {
         assert.ok(fp.includes("cache"));
         assert.ok(fp.includes("2 consecutive rounds"));
     });
-    it("detects 3 consecutive low-quality rounds", () => {
+    it("detects 3 consecutive failed rounds", () => {
         const vault = {
             results: [
                 makeVaultResult("loop-1", 1, 2, "fix memory leak", "Attempt 1", "few-shot"),
@@ -473,7 +474,7 @@ describe("Failure Lineage Weighting — buildRollingSummary", () => {
         assert.ok((rs.failed_patterns?.length ?? 0) >= 1);
         assert.ok(rs.failed_patterns[0].includes("3 consecutive rounds"));
     });
-    it("no pattern when low-quality rounds use different techniques", () => {
+    it("no pattern when failed rounds use different techniques", () => {
         const vault = {
             results: [
                 makeVaultResult("loop-1", 1, 2, "fix cache bug", "Attempt", "zero-shot"),
@@ -485,7 +486,7 @@ describe("Failure Lineage Weighting — buildRollingSummary", () => {
         assert.ok(rs !== null);
         assert.equal(rs.failed_patterns?.length ?? 0, 0);
     });
-    it("no pattern when low-quality tasks are completely different (Jaccard < 0.4)", () => {
+    it("no pattern when failed tasks are completely different (Jaccard < 0.4)", () => {
         const vault = {
             results: [
                 makeVaultResult("loop-1", 1, 2, "fix cache bug in Redis layer", "Attempt", "zero-shot"),
@@ -497,7 +498,7 @@ describe("Failure Lineage Weighting — buildRollingSummary", () => {
         assert.ok(rs !== null);
         assert.equal(rs.failed_patterns?.length ?? 0, 0);
     });
-    it("key_lessons from failure-pattern rounds are demoted to end with [Consider alternatives]", () => {
+    it("key_outcomes from failure-pattern rounds are demoted to end with [Consider alternatives]", () => {
         const vault = {
             results: [
                 makeVaultResult("loop-1", 1, 2, "fix cache bug", "Tried cache approach", "zero-shot"),
@@ -508,14 +509,15 @@ describe("Failure Lineage Weighting — buildRollingSummary", () => {
         };
         const rs = buildRollingSummary("loop-1", 4, vault);
         assert.ok(rs !== null);
-        // key_lessons should have the successful round first, then demoted ones
-        // (but since score >= 4 for key_lessons, rounds 1-2 with score=2 won't appear at all)
-        // The real test is: no false positives in key_lessons
-        for (const kl of rs.key_lessons) {
-            if (kl.includes("cache")) {
-                assert.ok(kl.includes("[Consider alternatives]"));
+        // key_outcomes only include score>=4 rounds (failure-pattern rounds score<3 don't appear)
+        // Round 3 (score=5) should be present and not marked
+        for (const ko of rs.key_outcomes) {
+            if (ko.includes("cache")) {
+                assert.ok(ko.includes("[Consider alternatives]"));
             }
         }
+        // Round 3 (score=5) should be present with auth fix outcome
+        assert.ok(rs.key_outcomes.some((ko) => ko.includes("Auth")));
     });
     it("recurring_issues from failure-only rounds marked as [Possible dead end]", () => {
         const vault = {
@@ -557,15 +559,12 @@ describe("Failure Lineage Weighting — buildRollingSummary", () => {
 describe("Failure Lineage Weighting — formatRollingSummaryForPrompt", () => {
     it("renders failure patterns section when present", () => {
         const rs = makeRollingSummary({
-            quality_trajectory: [2, 2, 5],
-            trajectory_direction: "improving",
-            what_worked: ["R3 (score=5): Fixed auth"],
+            key_outcomes: ["[R3] ✓ (step-back): Fixed auth bug"],
             recurring_issues: [],
-            key_lessons: ["[R3] Fixed auth bug"],
             rounds_sampled: 3,
             generated_at_round: 4,
             failed_patterns: [
-                "technique 'zero-shot' on task 'fix cache bug' failed 2 consecutive rounds (R1-R2, avg score 2.0) — consider strategy change",
+                "technique 'zero-shot' on task 'fix cache bug' failed 2 consecutive rounds (R1-R2) — consider strategy change",
             ],
         });
         const text = formatRollingSummaryForPrompt(rs);
@@ -576,11 +575,8 @@ describe("Failure Lineage Weighting — formatRollingSummaryForPrompt", () => {
     });
     it("no failure patterns section when empty", () => {
         const rs = makeRollingSummary({
-            quality_trajectory: [5, 4],
-            trajectory_direction: "stable",
-            what_worked: [],
+            key_outcomes: [],
             recurring_issues: [],
-            key_lessons: [],
             rounds_sampled: 2,
             generated_at_round: 3,
             failed_patterns: [],
@@ -594,4 +590,462 @@ describe("Failure Lineage Weighting — formatRollingSummaryForPrompt", () => {
         assert.equal(formatRollingSummaryForPrompt(empty), "");
     });
 });
+// ═══════════════════════════════════════════════════════════════════════════
+// Delegation Helpers (v1.9 — AgentTool mode)
+// ═══════════════════════════════════════════════════════════════════════════
+describe("Delegation Helpers — filterConstraintsForSubTask", () => {
+    const constraints = [
+        "all APIs must have rate limiting",
+        "use TypeScript strict mode",
+        "all files must have license header",
+        "every function needs unit tests",
+        "禁止使用 any 类型",
+    ];
+    it("returns empty array for empty constraints", () => {
+        assert.deepEqual(filterConstraintsForSubTask([], "search for deprecated API"), []);
+    });
+    it("returns empty array for empty subTask", () => {
+        assert.deepEqual(filterConstraintsForSubTask(constraints, ""), []);
+        assert.deepEqual(filterConstraintsForSubTask(constraints, "   "), []);
+    });
+    it("returns only relevant constraints by Jaccard similarity", () => {
+        // "search for deprecated API usage in src/" should NOT match
+        // rate limiting, strict mode, license headers, or unit tests
+        const result = filterConstraintsForSubTask(constraints, "search for deprecated API usage in src/");
+        assert.equal(result.length, 0);
+    });
+    it("returns relevant constraint when task overlaps", () => {
+        // "add rate limiting to all API endpoints" should match
+        // "all APIs must have rate limiting"
+        const result = filterConstraintsForSubTask(constraints, "add rate limiting to all API endpoints");
+        assert.ok(result.length >= 1);
+        assert.ok(result.some((c) => c.includes("rate limiting")));
+    });
+    it("returns at least one constraint when task has TypeScript+testing overlap", () => {
+        // "add TypeScript unit tests for all API functions" overlaps with
+        // "every function needs unit tests" (Jaccard ~0.2);
+        // "use TypeScript strict mode" overlap is too low (Jaccard ~0.1)
+        const result = filterConstraintsForSubTask(constraints, "add TypeScript unit tests for all API functions");
+        assert.ok(result.length >= 1);
+        assert.ok(result.some((c) => c.includes("unit tests")));
+    });
+    it("custom threshold filters more aggressively", () => {
+        // With threshold 0.5, should return very few constraints
+        const lenient = filterConstraintsForSubTask(constraints, "add rate limiting to all API endpoints", 0.15);
+        const strict = filterConstraintsForSubTask(constraints, "add rate limiting to all API endpoints", 0.5);
+        assert.ok(strict.length <= lenient.length);
+    });
+    it("supports CJK subTask with CJK constraints", () => {
+        const cjkConstraints = [
+            "所有API必须有速率限制",
+            "使用TypeScript严格模式",
+        ];
+        // "搜索废弃的API" doesn't overlap with rate limiting or strict mode
+        const result = filterConstraintsForSubTask(cjkConstraints, "搜索废弃的API使用情况");
+        assert.equal(result.length, 0);
+    });
+    it("matches CJK constraint with overlapping CJK subTask", () => {
+        const cjkConstraints = [
+            "所有API必须有速率限制",
+            "所有文件必须有许可证头",
+        ];
+        const result = filterConstraintsForSubTask(cjkConstraints, "为API添加速率限制");
+        assert.ok(result.length >= 1);
+        assert.ok(result.some((c) => c.includes("速率限制")));
+    });
+});
+describe("Delegation Helpers — formatDelegationPrompt", () => {
+    const subTask = "search for deprecated API usage in src/";
+    const constraints = ["all APIs must have rate limiting"];
+    it("generates self-contained explore prompt", () => {
+        const prompt = formatDelegationPrompt(subTask, "explore", []);
+        assert.ok(prompt.includes("### Delegated Task"));
+        assert.ok(prompt.includes(subTask));
+        assert.ok(prompt.includes("### Output Format"));
+        // Explore should NOT get constraints
+        assert.ok(!prompt.includes("### Relevant Constraints"));
+        // Must be self-contained
+        assert.ok(!prompt.match(/based on (above|previous|your findings)/i));
+        assert.ok(!prompt.includes("continue from"));
+    });
+    it("generates general-purpose prompt with constraints", () => {
+        const prompt = formatDelegationPrompt("fix the null pointer in src/auth/validate.ts:42", "general-purpose", constraints);
+        assert.ok(prompt.includes("### Delegated Task"));
+        assert.ok(prompt.includes("### Relevant Constraints"));
+        assert.ok(prompt.includes("rate limiting"));
+        assert.ok(prompt.includes("don't leave it half-done"));
+        // Must be self-contained
+        assert.ok(!prompt.match(/based on (above|previous|your findings)/i));
+    });
+    it("generates plan prompt with instructions", () => {
+        const prompt = formatDelegationPrompt("design authentication middleware", "plan", constraints, { context: "Current auth is JWT-based in src/auth/" });
+        assert.ok(prompt.includes("### Delegated Task"));
+        assert.ok(prompt.includes("### Context"));
+        assert.ok(prompt.includes("JWT-based"));
+        assert.ok(prompt.includes("### Relevant Constraints"));
+        assert.ok(prompt.includes("Critical files for implementation"));
+        assert.ok(prompt.includes("3-5 files"));
+    });
+    it("skips constraints section when empty", () => {
+        const prompt = formatDelegationPrompt(subTask, "general-purpose", []);
+        assert.ok(!prompt.includes("### Relevant Constraints"));
+    });
+    it("custom sub-agent type gets generic template", () => {
+        const prompt = formatDelegationPrompt(subTask, "custom-auditor", constraints);
+        assert.ok(prompt.includes("### Delegated Task"));
+        assert.ok(prompt.includes("### Relevant Constraints"));
+        assert.ok(prompt.includes("Complete the task above"));
+    });
+    it("output is self-contained — no parent-context references", () => {
+        const types = ["explore", "general-purpose", "plan", "custom"];
+        for (const t of types) {
+            const prompt = formatDelegationPrompt("do something", t, constraints);
+            // No references to parent conversation
+            assert.ok(!prompt.match(/based on (above|previous|your findings)/i), `${t}: should not reference parent context`);
+            assert.ok(!prompt.includes("continue from"), `${t}: should not say "continue from"`);
+            assert.ok(!prompt.includes("as discussed"), `${t}: should not say "as discussed"`);
+            assert.ok(!prompt.includes("see above"), `${t}: should not say "see above"`);
+        }
+    });
+});
+describe("Delegation — buildDelegationSummary", () => {
+    it("returns empty string for null vault context", () => {
+        assert.equal(buildDelegationSummary(null), "");
+    });
+    it("returns empty string when no delegation journal entries", () => {
+        const vault = { results: [{ task_type: "loop_lineage", loop_id: "test" }] };
+        assert.equal(buildDelegationSummary(vault), "");
+    });
+    it("returns empty string when results array is empty", () => {
+        const vault = { results: [] };
+        assert.equal(buildDelegationSummary(vault), "");
+    });
+    it("builds delegation table from journal entries", () => {
+        const vault = {
+            results: [
+                {
+                    task_type: "delegation_journal",
+                    loop_lineage: {
+                        round: 2,
+                        delegations: [
+                            { index: 1, agentId: "abc-123", subAgentType: "explore", subTask: "search deprecated APIs", resultSummary: "found 12 instances", success: true, discoveredConstraints: [] },
+                            { index: 2, agentId: "def-456", subAgentType: "general-purpose", subTask: "fix auth bug", resultSummary: "fixed null pointer", success: true, discoveredConstraints: [] },
+                        ],
+                    },
+                },
+            ],
+        };
+        const text = buildDelegationSummary(vault);
+        assert.ok(text.includes("### Delegation History"));
+        assert.ok(text.includes("R2"));
+        assert.ok(text.includes("search deprecated APIs"));
+        assert.ok(text.includes("fix auth bug"));
+        assert.ok(text.includes("✓"));
+        // Agent column should display agentId
+        assert.ok(text.includes("abc-123"));
+        assert.ok(text.includes("def-456"));
+        // Table header should include Agent column
+        assert.ok(text.includes("| Round | Agent | Type | Task | Result | ✓/✗ |"));
+    });
+    it("shows ✗ for failed delegations", () => {
+        const vault = {
+            results: [
+                {
+                    task_type: "delegation_journal",
+                    loop_lineage: {
+                        round: 3,
+                        delegations: [
+                            { index: 1, agentId: "worker-xyz", subAgentType: "general-purpose", subTask: "fix complex bug", resultSummary: "failed — wrong approach", success: false, discoveredConstraints: [] },
+                        ],
+                    },
+                },
+            ],
+        };
+        const text = buildDelegationSummary(vault);
+        assert.ok(text.includes("✗"));
+        assert.ok(text.includes("fix complex bug"));
+        assert.ok(text.includes("wrong approach"));
+    });
+    it("handles multiple rounds of delegation", () => {
+        const vault = {
+            results: [
+                {
+                    task_type: "delegation_journal",
+                    loop_lineage: { round: 1, delegations: [{ index: 1, agentId: "agent-a", subAgentType: "explore", subTask: "research X", resultSummary: "done", success: true, discoveredConstraints: [] }] },
+                },
+                {
+                    task_type: "delegation_journal",
+                    loop_lineage: { round: 2, delegations: [{ index: 1, agentId: "agent-b", subAgentType: "general-purpose", subTask: "fix Y", resultSummary: "done", success: true, discoveredConstraints: [] }] },
+                },
+            ],
+        };
+        const text = buildDelegationSummary(vault);
+        assert.ok(text.includes("R1"));
+        assert.ok(text.includes("R2"));
+    });
+    it("falls back to worker-N when agentId is missing (backward compat)", () => {
+        const vault = {
+            results: [
+                {
+                    task_type: "delegation_journal",
+                    loop_lineage: {
+                        round: 1,
+                        delegations: [
+                            { index: 3, subAgentType: "explore", subTask: "scan codebase", resultSummary: "done", success: true },
+                        ],
+                    },
+                },
+            ],
+        };
+        const text = buildDelegationSummary(vault);
+        assert.ok(text.includes("worker-3"), "should fall back to worker-3");
+    });
+    it("escapes pipe characters in markdown table cells", () => {
+        const vault = {
+            results: [
+                {
+                    task_type: "delegation_journal",
+                    loop_lineage: {
+                        round: 1,
+                        delegations: [
+                            { index: 1, agentId: "agent-1", subAgentType: "explore", subTask: "audit A|B testing in src/", resultSummary: "found issues in x|y module", success: true, discoveredConstraints: [] },
+                        ],
+                    },
+                },
+            ],
+        };
+        const text = buildDelegationSummary(vault);
+        // Should contain escaped pipes, not raw pipes that would break the table
+        assert.ok(text.includes("A\\|B"), "pipe in task should be escaped");
+        assert.ok(text.includes("x\\|y"), "pipe in result should be escaped");
+        // Verify the table row still has the correct number of pipe chars:
+        // 7 structural (leading + 5 separators + trailing) + 2 escaped inside cells = 9 total
+        const tableRow = text.split("\n").find((l) => l.startsWith("| R1"));
+        assert.ok(tableRow, "should have a table row for R1");
+        const pipeCount = (tableRow.match(/\|/g) ?? []).length;
+        assert.equal(pipeCount, 9, "table row should have 9 pipe chars (7 structural + 2 escaped)");
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// Checkpoint Compression (v1.10)
+// ═══════════════════════════════════════════════════════════════════════════
+describe("Checkpoint — buildCheckpointSummary", () => {
+    it("builds from self-eval with checkpoint fields", () => {
+        const selfEval = makeSelfEvaluation({
+            success: true,
+            output_summary: "Completed ERC20 data model with full test coverage",
+            compression_checkpoint: true,
+            checkpoint_label: "数据模型层完成",
+        });
+        const cs = buildCheckpointSummary(selfEval, 8, ["constraint-A", "constraint-B", "constraint-C"], ["old-constraint"]);
+        assert.ok(cs !== null);
+        assert.equal(cs.label, "数据模型层完成");
+        assert.equal(cs.declared_at_round, 8);
+        assert.ok(cs.outcome.includes("ERC20 data model"));
+        assert.deepStrictEqual(cs.carried_constraints, ["constraint-A", "constraint-B", "constraint-C"]);
+        assert.deepStrictEqual(cs.resolved_constraints, ["old-constraint"]);
+    });
+    it("falls back to auto-generated label when checkpoint_label is empty", () => {
+        const selfEval = makeSelfEvaluation({
+            success: true,
+            output_summary: "Done with auth module",
+            compression_checkpoint: true,
+            checkpoint_label: "",
+        });
+        const cs = buildCheckpointSummary(selfEval, 5, ["c1"], []);
+        assert.ok(cs.label.includes("Subtask completed at round 5"));
+    });
+    it("caps carried and resolved constraints at policy limit", () => {
+        const selfEval = makeSelfEvaluation({
+            success: true,
+            output_summary: "Done",
+            compression_checkpoint: true,
+            checkpoint_label: "test",
+        });
+        const manyConstraints = Array.from({ length: 15 }, (_, i) => `c${i + 1}`);
+        const cs = buildCheckpointSummary(selfEval, 3, manyConstraints, manyConstraints);
+        // Default policy: max_carried_constraints = 10
+        assert.equal(cs.carried_constraints.length, 10);
+        assert.equal(cs.resolved_constraints.length, 10);
+    });
+    it("truncates outcome at policy limit", () => {
+        const selfEval = makeSelfEvaluation({
+            success: true,
+            output_summary: "x".repeat(300),
+            compression_checkpoint: true,
+            checkpoint_label: "test",
+        });
+        const cs = buildCheckpointSummary(selfEval, 1, [], []);
+        // Default policy: outcome_max_chars = 200
+        assert.ok(cs.outcome.length <= 200);
+    });
+});
+describe("Checkpoint — formatCheckpointForPrompt", () => {
+    it("renders checkpoint block with all fields", () => {
+        const cs = makeCheckpointSummary({
+            label: "Auth module complete",
+            declared_at_round: 5,
+            outcome: "Implemented JWT auth with refresh tokens",
+            carried_constraints: ["所有API需要认证", "token过期时间≤24h"],
+            resolved_constraints: ["旧密码哈希方式需更新"],
+        });
+        const text = formatCheckpointForPrompt(cs);
+        assert.ok(text.includes("### Checkpoint: Auth module complete (Round 5)"));
+        assert.ok(text.includes("Implemented JWT auth"));
+        assert.ok(text.includes("所有API需要认证"));
+        assert.ok(text.includes("旧密码哈希方式需更新"));
+        assert.ok(text.includes("Carried Constraints"));
+        assert.ok(text.includes("Resolved Constraints"));
+    });
+    it("returns empty string for null", () => {
+        assert.equal(formatCheckpointForPrompt(null), "");
+    });
+    it("returns empty string for empty checkpoint", () => {
+        const cs = makeCheckpointSummary({});
+        assert.equal(formatCheckpointForPrompt(cs), "");
+    });
+    it("omits resolved section when no resolved constraints", () => {
+        const cs = makeCheckpointSummary({
+            label: "test",
+            declared_at_round: 1,
+            outcome: "done",
+            carried_constraints: ["c1"],
+            resolved_constraints: [],
+        });
+        const text = formatCheckpointForPrompt(cs);
+        assert.ok(!text.includes("Resolved Constraints"));
+    });
+});
+describe("Checkpoint — buildRollingSummary with sinceRound", () => {
+    function makeVaultResult(loopId, round, qualityScore, task, outputSummary = "", techniqueUsed = "zero-shot", constraintViolations = []) {
+        const success = qualityScore >= 3;
+        return {
+            task, output_summary: outputSummary,
+            constraint_violations: constraintViolations,
+            technique_used: techniqueUsed, success,
+            loop_lineage: { loop_id: loopId, round, success, task, technique_used: techniqueUsed },
+        };
+    }
+    it("only includes rounds at or after sinceRound", () => {
+        const vault = {
+            results: [
+                makeVaultResult("loop-1", 1, 4, "task A", "did A"),
+                makeVaultResult("loop-1", 2, 5, "task B", "did B"),
+                makeVaultResult("loop-1", 3, 3, "task C", "did C"),
+                makeVaultResult("loop-1", 4, 5, "task D", "did D"),
+                makeVaultResult("loop-1", 5, 4, "task E", "did E"),
+            ],
+        };
+        const rs = buildRollingSummary("loop-1", 6, vault, 3);
+        assert.ok(rs !== null);
+        // Round 1 and 2 should be excluded (before sinceRound=3)
+        assert.equal(rs.rounds_sampled, 3);
+        // Verify key_outcomes contains rounds 3-5
+        assert.equal(rs.key_outcomes.length, 3);
+        assert.ok(rs.key_outcomes.some((k) => k.includes("R3")));
+        assert.ok(rs.key_outcomes.some((k) => k.includes("R5")));
+    });
+    it("sinceRound with no matching rounds returns null", () => {
+        const vault = {
+            results: [
+                makeVaultResult("loop-1", 1, 4, "task A", "did A"),
+                makeVaultResult("loop-1", 2, 5, "task B", "did B"),
+            ],
+        };
+        const rs = buildRollingSummary("loop-1", 3, vault, 5);
+        assert.equal(rs, null);
+    });
+    it("without sinceRound includes all rounds (backward compat)", () => {
+        const vault = {
+            results: [
+                makeVaultResult("loop-1", 1, 4, "task A", "did A"),
+                makeVaultResult("loop-1", 2, 5, "task B", "did B"),
+            ],
+        };
+        const rs = buildRollingSummary("loop-1", 3, vault);
+        assert.ok(rs !== null);
+        assert.equal(rs.rounds_sampled, 2);
+    });
+});
+describe("Checkpoint — compileL2 integration", () => {
+    it("renders checkpoint in prompt when last_round_result has checkpoint", () => {
+        const lr = makeLoopRoundResult({
+            round: 4,
+            success: true,
+            output_summary: "Completed data model layer",
+            constraint_violations: [],
+            compression_checkpoint: true,
+            checkpoint_label: "Data model done",
+        });
+        const req = makeLoopCompileRequest({
+            round: 5,
+            loop_id: "test-cp",
+            task: "Build API layer on top of data model",
+            last_round_result: lr,
+        });
+        // Empty vault — no prior checkpoint to load
+        const vault = { results: [], global_entries: [] };
+        const response = compileL2(req, vault);
+        assert.ok(response.prompt.includes("### Checkpoint: Data model done (Round 4)"));
+        assert.ok(response.prompt.includes("Completed data model layer"));
+        assert.ok(response.checkpoint_summary !== null);
+        assert.equal(response.checkpoint_summary.declared_at_round, 4);
+    });
+    it("no checkpoint in prompt when last_round_result has no checkpoint", () => {
+        const lr = makeLoopRoundResult({
+            round: 2,
+            success: true,
+            output_summary: "Fixed a bug",
+            constraint_violations: [],
+        });
+        const req = makeLoopCompileRequest({
+            round: 3,
+            loop_id: "test-nocp",
+            task: "Continue fixing bugs",
+            last_round_result: lr,
+        });
+        const vault = { results: [], global_entries: [] };
+        const response = compileL2(req, vault);
+        assert.ok(!response.prompt.includes("### Checkpoint:"));
+        assert.equal(response.checkpoint_summary, null);
+    });
+    it("loads existing checkpoint from vault on later rounds", () => {
+        // Simulate a previous round that stored a checkpoint in vault
+        const vault = {
+            results: [
+                {
+                    loop_lineage: { loop_id: "test-cp2", round: 3, success: true },
+                    checkpoint_summary: {
+                        label: "API layer done",
+                        declared_at_round: 3,
+                        outcome: "Built REST API",
+                        carried_constraints: ["auth required"],
+                        resolved_constraints: [],
+                    },
+                    task: "Build API",
+                    output_summary: "Built REST API",
+                    technique_used: "least-to-most",
+                },
+            ],
+        };
+        const lr = makeLoopRoundResult({
+            round: 4,
+            success: true,
+            output_summary: "Added tests",
+            constraint_violations: [],
+        });
+        const req = makeLoopCompileRequest({
+            round: 5,
+            loop_id: "test-cp2",
+            task: "Add integration tests",
+            last_round_result: lr,
+        });
+        const response = compileL2(req, vault);
+        // Should load checkpoint from round 3
+        assert.ok(response.prompt.includes("### Checkpoint: API layer done (Round 3)"));
+        assert.ok(response.prompt.includes("Built REST API"));
+        assert.ok(response.checkpoint_summary !== null);
+        assert.equal(response.checkpoint_summary.declared_at_round, 3);
+    });
+});
 //# sourceMappingURL=loop-compiler.test.js.map