ralph-lisa-loop 0.3.0

package/dist/test/cli.test.js

@@ -0,0 +1,594 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const CLI = path.join(__dirname, "..", "cli.js");
+const TMP = path.join(__dirname, "..", "..", ".test-tmp");
+function run(...args) {
+    try {
+        const stdout = (0, node_child_process_1.execFileSync)(process.execPath, [CLI, ...args], {
+            cwd: TMP,
+            encoding: "utf-8",
+            env: { ...process.env, RL_POLICY_MODE: "off" },
+        });
+        return { stdout, exitCode: 0 };
+    }
+    catch (e) {
+        return { stdout: (e.stdout || "") + (e.stderr || ""), exitCode: e.status };
+    }
+}
+(0, node_test_1.describe)("CLI: policy check-consensus", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("passes when both agents submit CONSENSUS", () => {
+        run("submit-ralph", "[CONSENSUS] Agreed on plan");
+        run("submit-lisa", "[CONSENSUS] Agreed\n\n- All good");
+        const r = run("policy", "check-consensus");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Consensus reached"));
+    });
+    (0, node_test_1.it)("fails when neither agent has CONSENSUS", () => {
+        run("submit-ralph", "[CODE] Done\n\nTest Results\n- pass");
+        run("submit-lisa", "[PASS] OK\n\n- Clean code");
+        const r = run("policy", "check-consensus");
+        assert.strictEqual(r.exitCode, 1);
+        assert.ok(r.stdout.includes("NOT reached"));
+    });
+    (0, node_test_1.it)("fails when only Ralph has CONSENSUS", () => {
+        run("submit-ralph", "[CONSENSUS] I agree");
+        run("submit-lisa", "[PASS] OK\n\n- Looks good");
+        const r = run("policy", "check-consensus");
+        assert.strictEqual(r.exitCode, 1);
+        assert.ok(r.stdout.includes("Lisa"));
+    });
+});
+(0, node_test_1.describe)("CLI: policy check-next-step", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("passes when both CONSENSUS and policy OK", () => {
+        run("submit-ralph", "[CONSENSUS] Agreed on approach");
+        run("submit-lisa", "[CONSENSUS] Confirmed\n\n- Sound plan");
+        const r = run("policy", "check-next-step");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Ready to proceed"));
+    });
+    (0, node_test_1.it)("fails with comprehensive issues", () => {
+        run("submit-ralph", "[CODE] Done");
+        run("submit-lisa", "[PASS] OK");
+        const r = run("policy", "check-next-step");
+        assert.strictEqual(r.exitCode, 1);
+        // Should report: no consensus + missing test results + missing reason
+        assert.ok(r.stdout.includes("not [CONSENSUS]"));
+    });
+});
+(0, node_test_1.describe)("CLI: doctor", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("runs and outputs dependency check header", () => {
+        const r = run("doctor");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Dependency Check"));
+    });
+    (0, node_test_1.it)("outputs at least one status line", () => {
+        const r = run("doctor");
+        assert.strictEqual(r.exitCode, 0);
+        // Should have at least one OK, MISSING, or -- line
+        assert.ok(r.stdout.includes("OK") ||
+            r.stdout.includes("MISSING") ||
+            r.stdout.includes("--"));
+    });
+    (0, node_test_1.it)("outputs Node.js version", () => {
+        const r = run("doctor");
+        assert.ok(r.stdout.includes("Node.js"));
+    });
+});
+(0, node_test_1.describe)("CLI: logs", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("lists no logs when none exist", () => {
+        const r = run("logs");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("No transcript logs found"));
+    });
+    (0, node_test_1.it)("lists live pane logs when present", () => {
+        const logFile = path.join(TMP, ".dual-agent", "pane0.log");
+        fs.writeFileSync(logFile, "some output from ralph\n");
+        const r = run("logs");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Live (current session)"));
+        assert.ok(r.stdout.includes("pane0.log"));
+    });
+    (0, node_test_1.it)("lists archived logs", () => {
+        const logsDir = path.join(TMP, ".dual-agent", "logs");
+        fs.mkdirSync(logsDir, { recursive: true });
+        fs.writeFileSync(path.join(logsDir, "pane0-2026-01-01T12-00-00.log"), "archived output\n");
+        const r = run("logs");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Archived (previous sessions)"));
+        assert.ok(r.stdout.includes("pane0-2026-01-01T12-00-00.log"));
+    });
+    (0, node_test_1.it)("cat shows live pane log content", () => {
+        const logFile = path.join(TMP, ".dual-agent", "pane0.log");
+        fs.writeFileSync(logFile, "hello from ralph pane\n");
+        const r = run("logs", "cat");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("hello from ralph pane"));
+    });
+    (0, node_test_1.it)("cat shows specific archived log", () => {
+        const logsDir = path.join(TMP, ".dual-agent", "logs");
+        fs.mkdirSync(logsDir, { recursive: true });
+        const archiveFile = "pane1-2026-01-01T12-00-00.log";
+        fs.writeFileSync(path.join(logsDir, archiveFile), "archived lisa output\n");
+        const r = run("logs", "cat", archiveFile);
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("archived lisa output"));
+    });
+    (0, node_test_1.it)("ignores empty pane logs in listing", () => {
+        const logFile = path.join(TMP, ".dual-agent", "pane0.log");
+        fs.writeFileSync(logFile, ""); // empty
+        const r = run("logs");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(!r.stdout.includes("pane0.log"));
+    });
+});
+(0, node_test_1.describe)("CLI: init --minimal", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("creates only .dual-agent/, no project files", () => {
+        run("init", "--minimal");
+        assert.ok(fs.existsSync(path.join(TMP, ".dual-agent", "turn.txt")));
+        assert.ok(!fs.existsSync(path.join(TMP, "CLAUDE.md")));
+        assert.ok(!fs.existsSync(path.join(TMP, "CODEX.md")));
+        assert.ok(!fs.existsSync(path.join(TMP, ".claude")));
+        assert.ok(!fs.existsSync(path.join(TMP, ".codex")));
+    });
+    (0, node_test_1.it)("allows submit after minimal init", () => {
+        run("init", "--minimal");
+        const r = run("submit-ralph", "[PLAN] Test plan");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Submitted"));
+    });
+});
+(0, node_test_1.describe)("CLI: submit --file", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("ralph submits content from file", () => {
+        const contentFile = path.join(TMP, "submission.md");
+        fs.writeFileSync(contentFile, "[PLAN] My plan from file\n\nDetailed plan content here.");
+        const r = run("submit-ralph", "--file", contentFile);
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Submitted"));
+        assert.ok(r.stdout.includes("[PLAN]"));
+        // Verify work.md contains the file content
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(work.includes("Detailed plan content here"));
+    });
+    (0, node_test_1.it)("lisa submits content from file", () => {
+        // Ralph submits first to give Lisa the turn
+        run("submit-ralph", "[PLAN] Setup");
+        const contentFile = path.join(TMP, "review.md");
+        fs.writeFileSync(contentFile, "[PASS] Approved from file\n\nLooks good to me.");
+        const r = run("submit-lisa", "--file", contentFile);
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Submitted"));
+        assert.ok(r.stdout.includes("[PASS]"));
+    });
+    (0, node_test_1.it)("fails when --file has no path", () => {
+        const r = run("submit-ralph", "--file");
+        assert.notStrictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("--file requires a file path"));
+    });
+    (0, node_test_1.it)("fails when file does not exist", () => {
+        const r = run("submit-ralph", "--file", "/nonexistent/path.md");
+        assert.notStrictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("File not found"));
+    });
+    (0, node_test_1.it)("handles file with special characters in content", () => {
+        const contentFile = path.join(TMP, "special.md");
+        fs.writeFileSync(contentFile, '[PLAN] Plan with "quotes" & $pecial chars\n\nContent with `backticks` and $(subshell)');
+        const r = run("submit-ralph", "--file", contentFile);
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Submitted"));
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(work.includes("$(subshell)"));
+    });
+    (0, node_test_1.it)("--file history gets summary only, not full content", () => {
+        const contentFile = path.join(TMP, "submission.md");
+        fs.writeFileSync(contentFile, "[PLAN] File plan\n\nThis detailed body should NOT be in history.");
+        run("submit-ralph", "--file", contentFile);
+        const history = fs.readFileSync(path.join(TMP, ".dual-agent", "history.md"), "utf-8");
+        // History should have summary reference, not full body
+        assert.ok(history.includes("File plan"));
+        assert.ok(history.includes("(Full content in work.md)"));
+        assert.ok(!history.includes("This detailed body should NOT be in history"));
+    });
+    (0, node_test_1.it)("--file full content is still in work.md", () => {
+        const contentFile = path.join(TMP, "submission.md");
+        fs.writeFileSync(contentFile, "[PLAN] File plan\n\nFull body lives in work.md.");
+        run("submit-ralph", "--file", contentFile);
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(work.includes("Full body lives in work.md"));
+    });
+    (0, node_test_1.it)("inline args still write full content to history", () => {
+        const r = run("submit-ralph", "[PLAN] Inline plan\n\nInline body in history.");
+        assert.strictEqual(r.exitCode, 0);
+        const history = fs.readFileSync(path.join(TMP, ".dual-agent", "history.md"), "utf-8");
+        assert.ok(history.includes("Inline body in history"));
+        assert.ok(!history.includes("(Full content in work.md)"));
+    });
+});
+(0, node_test_1.describe)("CLI: submit files_changed", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        // Set up a git repo so git diff works
+        (0, node_child_process_1.execFileSync)("git", ["init"], { cwd: TMP, stdio: "pipe" });
+        (0, node_child_process_1.execFileSync)("git", ["config", "user.email", "test@test.com"], { cwd: TMP, stdio: "pipe" });
+        (0, node_child_process_1.execFileSync)("git", ["config", "user.name", "Test"], { cwd: TMP, stdio: "pipe" });
+        // Create and commit an initial file
+        fs.writeFileSync(path.join(TMP, "app.ts"), "const x = 1;\n");
+        (0, node_child_process_1.execFileSync)("git", ["add", "app.ts"], { cwd: TMP, stdio: "pipe" });
+        (0, node_child_process_1.execFileSync)("git", ["commit", "-m", "initial"], { cwd: TMP, stdio: "pipe" });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("attaches files_changed to work.md for CODE tag", () => {
+        // Modify a tracked file
+        fs.writeFileSync(path.join(TMP, "app.ts"), "const x = 2;\n");
+        const r = run("submit-ralph", "[CODE] Updated app\n\nTest Results\n- pass");
+        assert.strictEqual(r.exitCode, 0);
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(work.includes("**Files Changed**:"));
+        assert.ok(work.includes("- app.ts"));
+    });
+    (0, node_test_1.it)("attaches files_changed to work.md for FIX tag", () => {
+        fs.writeFileSync(path.join(TMP, "app.ts"), "const x = 3;\n");
+        const r = run("submit-ralph", "[FIX] Fixed app\n\nTest Results\n- pass");
+        assert.strictEqual(r.exitCode, 0);
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(work.includes("**Files Changed**:"));
+        assert.ok(work.includes("- app.ts"));
+    });
+    (0, node_test_1.it)("does NOT attach files_changed for PLAN tag", () => {
+        fs.writeFileSync(path.join(TMP, "app.ts"), "const x = 4;\n");
+        const r = run("submit-ralph", "[PLAN] Just a plan");
+        assert.strictEqual(r.exitCode, 0);
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(!work.includes("**Files Changed**:"));
+    });
+    (0, node_test_1.it)("no files_changed section when no files changed", () => {
+        // No modifications — git diff should return empty
+        const r = run("submit-ralph", "[CODE] No changes\n\nTest Results\n- pass");
+        assert.strictEqual(r.exitCode, 0);
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(!work.includes("**Files Changed**:"));
+    });
+});
+(0, node_test_1.describe)("CLI: submit --stdin", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    function runWithStdin(input, ...args) {
+        try {
+            const stdout = (0, node_child_process_1.execFileSync)(process.execPath, [CLI, ...args], {
+                cwd: TMP,
+                encoding: "utf-8",
+                input,
+                env: { ...process.env, RL_POLICY_MODE: "off" },
+            });
+            return { stdout, exitCode: 0 };
+        }
+        catch (e) {
+            return { stdout: (e.stdout || "") + (e.stderr || ""), exitCode: e.status };
+        }
+    }
+    (0, node_test_1.it)("ralph submits content from stdin", () => {
+        const r = runWithStdin("[PLAN] Plan from stdin\n\nStdin content here.", "submit-ralph", "--stdin");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Submitted"));
+        assert.ok(r.stdout.includes("[PLAN]"));
+        const work = fs.readFileSync(path.join(TMP, ".dual-agent", "work.md"), "utf-8");
+        assert.ok(work.includes("Stdin content here"));
+    });
+    (0, node_test_1.it)("lisa submits content from stdin", () => {
+        run("submit-ralph", "[PLAN] Setup");
+        const r = runWithStdin("[PASS] Approved from stdin\n\nAll good.", "submit-lisa", "--stdin");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Submitted"));
+        assert.ok(r.stdout.includes("[PASS]"));
+    });
+    (0, node_test_1.it)("--stdin history gets summary only, not full content", () => {
+        runWithStdin("[PLAN] Stdin plan\n\nDetailed stdin body not in history.", "submit-ralph", "--stdin");
+        const history = fs.readFileSync(path.join(TMP, ".dual-agent", "history.md"), "utf-8");
+        assert.ok(history.includes("Stdin plan"));
+        assert.ok(history.includes("(Full content in work.md)"));
+        assert.ok(!history.includes("Detailed stdin body not in history"));
+    });
+});
+(0, node_test_1.describe)("CLI: recap", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("shows current step and round", () => {
+        const r = run("recap");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("RECAP"));
+        assert.ok(r.stdout.includes("Step: planning"));
+        assert.ok(r.stdout.includes("Round: 1"));
+    });
+    (0, node_test_1.it)("shows recent actions after submissions", () => {
+        run("submit-ralph", "[PLAN] First plan");
+        run("submit-lisa", "[PASS] Plan approved\n\n- Looks good");
+        run("submit-ralph", "[CONSENSUS] Agreed");
+        const r = run("recap");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Recent actions:"));
+        assert.ok(r.stdout.includes("Ralph [PLAN] First plan"));
+        assert.ok(r.stdout.includes("Lisa [PASS] Plan approved"));
+        assert.ok(r.stdout.includes("Ralph [CONSENSUS] Agreed"));
+        assert.ok(r.stdout.includes("Actions in this step: 3"));
+    });
+    (0, node_test_1.it)("shows only last 3 actions when more exist", () => {
+        run("submit-ralph", "[PLAN] Plan A");
+        run("submit-lisa", "[NEEDS_WORK] Fix it\n\n- Issue found");
+        run("submit-ralph", "[FIX] Fixed\n\nTest Results\n- pass");
+        run("submit-lisa", "[PASS] Now good\n\n- All clear");
+        const r = run("recap");
+        assert.strictEqual(r.exitCode, 0);
+        // Should show last 3, not the first PLAN
+        assert.ok(!r.stdout.includes("[PLAN] Plan A"));
+        assert.ok(r.stdout.includes("[NEEDS_WORK] Fix it"));
+        assert.ok(r.stdout.includes("[FIX] Fixed"));
+        assert.ok(r.stdout.includes("[PASS] Now good"));
+    });
+    (0, node_test_1.it)("shows unresolved NEEDS_WORK", () => {
+        run("submit-ralph", "[CODE] Some code\n\nTest Results\n- pass");
+        run("submit-lisa", "[NEEDS_WORK] Missing edge case\n\n- Need tests");
+        const r = run("recap");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Unresolved NEEDS_WORK:"));
+        assert.ok(r.stdout.includes("Missing edge case"));
+    });
+    (0, node_test_1.it)("does not show resolved NEEDS_WORK", () => {
+        run("submit-ralph", "[CODE] Some code\n\nTest Results\n- pass");
+        run("submit-lisa", "[NEEDS_WORK] Missing edge case\n\n- Need tests");
+        run("submit-ralph", "[FIX] Added edge case tests\n\nTest Results\n- pass");
+        const r = run("recap");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(!r.stdout.includes("Unresolved NEEDS_WORK:"));
+    });
+    (0, node_test_1.it)("shows no actions when step is fresh", () => {
+        const r = run("recap");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Actions in this step: 0"));
+        assert.ok(r.stdout.includes("Recent actions: (none)"));
+    });
+});
+(0, node_test_1.describe)("CLI: review-history", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("review.md keeps last 3 entries after 4 submissions", () => {
+        // Round 1
+        run("submit-ralph", "[PLAN] Plan A");
+        run("submit-lisa", "[NEEDS_WORK] Fix plan\n\n- Issue 1");
+        // Round 2
+        run("submit-ralph", "[FIX] Fixed plan\n\nTest Results\n- pass");
+        run("submit-lisa", "[NEEDS_WORK] Still wrong\n\n- Issue 2");
+        // Round 3
+        run("submit-ralph", "[FIX] Fixed again\n\nTest Results\n- pass");
+        run("submit-lisa", "[PASS] Now good\n\n- All clear");
+        // Round 4
+        run("submit-ralph", "[CONSENSUS] Agreed");
+        run("submit-lisa", "[CONSENSUS] Confirmed\n\n- Done");
+        const review = fs.readFileSync(path.join(TMP, ".dual-agent", "review.md"), "utf-8");
+        // Should have exactly 3 entries (rounds 2, 3, 4), not round 1
+        assert.ok(!review.includes("Fix plan"));
+        assert.ok(review.includes("Still wrong"));
+        assert.ok(review.includes("Now good"));
+        assert.ok(review.includes("Confirmed"));
+    });
+    (0, node_test_1.it)("review.md contains separator between entries", () => {
+        run("submit-ralph", "[PLAN] Plan");
+        run("submit-lisa", "[PASS] OK\n\n- Good");
+        run("submit-ralph", "[CONSENSUS] Agreed");
+        run("submit-lisa", "[CONSENSUS] Done\n\n- Confirmed");
+        const review = fs.readFileSync(path.join(TMP, ".dual-agent", "review.md"), "utf-8");
+        assert.ok(review.includes("---"));
+    });
+    (0, node_test_1.it)("read review --round N returns specific round from history", () => {
+        run("submit-ralph", "[PLAN] Plan A");
+        run("submit-lisa", "[NEEDS_WORK] Fix plan\n\n- Issue found");
+        run("submit-ralph", "[FIX] Fixed\n\nTest Results\n- pass");
+        run("submit-lisa", "[PASS] Approved\n\n- Looks good");
+        const r = run("read", "review", "--round", "1");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Fix plan"));
+        assert.ok(r.stdout.includes("Issue found"));
+    });
+    (0, node_test_1.it)("read review --round returns correct round when multiple exist", () => {
+        run("submit-ralph", "[PLAN] Plan");
+        run("submit-lisa", "[NEEDS_WORK] Round 1 review\n\n- R1 issue");
+        run("submit-ralph", "[FIX] Fix\n\nTest Results\n- pass");
+        run("submit-lisa", "[PASS] Round 2 review\n\n- R2 good");
+        const r2 = run("read", "review", "--round", "2");
+        assert.strictEqual(r2.exitCode, 0);
+        assert.ok(r2.stdout.includes("Round 2 review"));
+        assert.ok(r2.stdout.includes("R2 good"));
+    });
+    (0, node_test_1.it)("read review --round with invalid round shows error", () => {
+        const r = run("read", "review", "--round", "abc");
+        assert.notStrictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("--round requires a positive integer"));
+    });
+    (0, node_test_1.it)("read review --round with out-of-range round shows not found", () => {
+        run("submit-ralph", "[PLAN] Plan");
+        run("submit-lisa", "[PASS] OK\n\n- Good");
+        const r = run("read", "review", "--round", "99");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("No review found for round 99"));
+    });
+    (0, node_test_1.it)("read review.md without --round still shows current file", () => {
+        run("submit-ralph", "[PLAN] Plan");
+        run("submit-lisa", "[PASS] Latest review\n\n- Current");
+        const r = run("read", "review.md");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Latest review"));
+    });
+});
+(0, node_test_1.describe)("CLI: step consensus check", () => {
+    (0, node_test_1.beforeEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+        fs.mkdirSync(TMP, { recursive: true });
+        run("init", "--minimal");
+    });
+    (0, node_test_1.afterEach)(() => {
+        fs.rmSync(TMP, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("allows step when both CONSENSUS", () => {
+        run("submit-ralph", "[CONSENSUS] Agreed");
+        run("submit-lisa", "[CONSENSUS] Confirmed\n\n- Done");
+        const r = run("step", "next-feature");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Entered step: next-feature"));
+    });
+    (0, node_test_1.it)("allows step when CONSENSUS + PASS", () => {
+        // Ralph submits CONSENSUS, Lisa responds with PASS
+        // work.md last tag = CONSENSUS, review.md last tag = PASS
+        run("submit-ralph", "[CONSENSUS] I agree");
+        run("submit-lisa", "[PASS] Approved\n\n- Looks good");
+        const r = run("step", "next-feature");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Entered step: next-feature"));
+    });
+    (0, node_test_1.it)("allows step when PASS + CONSENSUS", () => {
+        // Lisa gives PASS, Ralph submits CONSENSUS
+        // After Ralph's CONSENSUS, work.md has CONSENSUS, review.md still has PASS
+        run("submit-ralph", "[PLAN] Plan");
+        run("submit-lisa", "[PASS] Approved\n\n- Good");
+        run("submit-ralph", "[CONSENSUS] Agreed");
+        // work.md = CONSENSUS, review.md = PASS → should allow
+        const r = run("step", "next-feature");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Entered step: next-feature"));
+    });
+    (0, node_test_1.it)("blocks step when no consensus", () => {
+        run("submit-ralph", "[CODE] Some code\n\nTest Results\n- pass");
+        run("submit-lisa", "[PASS] Looks good\n\n- Clean");
+        const r = run("step", "next-feature");
+        assert.notStrictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Consensus not reached"));
+    });
+    (0, node_test_1.it)("--force bypasses consensus check", () => {
+        run("submit-ralph", "[CODE] Some code\n\nTest Results\n- pass");
+        run("submit-lisa", "[NEEDS_WORK] Fix it\n\n- Issue");
+        const r = run("step", "--force", "next-feature");
+        assert.strictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Entered step: next-feature"));
+    });
+    (0, node_test_1.it)("shows both tags in error when blocked", () => {
+        run("submit-ralph", "[CODE] Code\n\nTest Results\n- pass");
+        run("submit-lisa", "[NEEDS_WORK] Problems\n\n- Bugs");
+        const r = run("step", "next-feature");
+        assert.notStrictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("[CODE]"));
+        assert.ok(r.stdout.includes("[NEEDS_WORK]"));
+    });
+    (0, node_test_1.it)("body text with ## [CONSENSUS] does NOT spoof consensus", () => {
+        // Ralph submits CODE with a ## [CONSENSUS] heading in the body text
+        run("submit-ralph", "[CODE] My code\n\nTest Results\n- pass\n\n## [CONSENSUS] fake heading in body");
+        run("submit-lisa", "[PASS] OK\n\n- Clean code");
+        const r = run("step", "next-feature");
+        // Should block: work.md metadata tag is CODE, not CONSENSUS
+        assert.notStrictEqual(r.exitCode, 0);
+        assert.ok(r.stdout.includes("Consensus not reached"));
+        assert.ok(r.stdout.includes("[CODE]"));
+    });
+});

package/dist/test/policy.test.d.ts

@@ -0,0 +1 @@
+export {};