scai 0.1.178 → 1.0.0

package/dist/__tests__/agents/agentTransform.test.js

@@ -0,0 +1,779 @@
+/**
+ * Covers the new batched transform owner and its runtime integration.
+ *
+ * Why this file exists:
+ * - transform now has a new-agent owner under `cli/src/agent/**`
+  * - the batched inner loop needs direct tests without going through old `MainAgent`
+  * - file-size-based batch sizing needs direct coverage for small, medium, and large files
+ * - transform size limits should be testable without touching a real local config
+ * - one loop-level test proves the outer runtime still sees one `codeTransform` action
+ */
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+const generateMock = vi.fn();
+const configState = vi.hoisted(() => ({
+    transformMaxFileLines: 1084,
+}));
+const runtimeLoggerState = vi.hoisted(() => ({
+    logRuntimeRecord: vi.fn(),
+}));
+vi.mock("../../lib/generate.js", () => ({
+    generate: (...args) => generateMock(...args),
+}));
+vi.mock("../../config.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        Config: {
+            ...actual.Config,
+            getTransformMaxFileLines: () => configState.transformMaxFileLines,
+        },
+    };
+});
+vi.mock("../../utils/runtimeLogger.js", () => ({
+    logRuntimeRecord: runtimeLoggerState.logRuntimeRecord,
+    clearRuntimeLogs: vi.fn(),
+    appendHumanRuntimeEntry: vi.fn(),
+}));
+import { createAgentMemory } from "../../agent/state/memory.js";
+import { buildActions } from "../../agent/actions/index.js";
+import { resolvePolicyState } from "../../agent/policy/index.js";
+import { runAgentLoop } from "../../agent/runtime/runAgentLoop.js";
+import { buildTools } from "../../agent/tools/index.js";
+import { buildTransformPlan, runCodeTransform, selectNextTransformBatch } from "../../agent/transform/index.js";
+import { computeContentFingerprint, computeQueryFingerprint } from "../../utils/fileEvidenceCache.js";
+function addFullRead(memory, filePath) {
+    memory.task.explicitTargets = [filePath];
+    memory.task.hardFileTargets = [filePath];
+    memory.evidence.candidateFiles = [filePath];
+    memory.evidence.fileReads[filePath] = {
+        filePath,
+        readMode: "full",
+        summary: "Target file summary.",
+        snippets: ["export function sample() {}"],
+        keySymbols: ["sample"],
+        matchedTerms: ["sample"],
+        relevanceExplanation: "The file is the direct transform target.",
+        role: "primary",
+        excerpts: [{
+                description: "Main exported function.",
+                startLine: 1,
+                endLine: 3,
+                symbols: ["sample"],
+                code: "export function sample() {\n  return 1;\n}",
+            }],
+        relevantContext: [{
+                kind: "purpose",
+                text: "This file is the requested transform target.",
+            }],
+        contentFingerprint: computeContentFingerprint(fs.readFileSync(filePath, "utf-8")),
+        queryFingerprint: computeQueryFingerprint(memory.task.normalizedQuery),
+        recordedAt: new Date(0).toISOString(),
+    };
+}
+function overwriteFileWithLineCount(filePath, lineCount) {
+    fs.writeFileSync(filePath, Array.from({ length: lineCount }, (_, index) => `const line${index + 1} = ${index + 1};`).join("\n"), "utf-8");
+}
+function queueValidTransformLoop(batchEditIds) {
+    const edits = batchEditIds.flat().map((editId, index) => ({
+        id: editId,
+        order: index + 1,
+        excerptIndex: 0,
+        action: editId,
+        summary: `Apply ${editId}.`,
+    }));
+    generateMock.mockResolvedValueOnce({
+        data: JSON.stringify({ edits }),
+    });
+    for (const editIds of batchEditIds) {
+        generateMock.mockResolvedValueOnce({
+            data: `<FILE_CONTENT>\n${editIds.map((editId, index) => `export const ${editId.replace(/-/g, "_")}_${index + 1} = ${index + 1};`).join("\n")}\n</FILE_CONTENT>`,
+        });
+        generateMock.mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: editIds.map((editId) => ({
+                    editId,
+                    status: "completed",
+                    rationale: `${editId} was applied.`,
+                })),
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: `Batch for ${editIds.join(", ")} is valid.`,
+            }),
+        });
+    }
+}
+function batchSummaries(records, summary) {
+    return records
+        .filter((record) => record.summary === summary)
+        .map((record) => `batch ${record.payload?.batchNumber}/${record.payload?.batchCount}`);
+}
+describe("new-agent transform owner", () => {
+    let tempDir;
+    let targetFile;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "scai-agent-transform-"));
+        targetFile = path.join(tempDir, "sample.ts");
+        fs.writeFileSync(targetFile, [
+            "export function sample() {",
+            "  return 1;",
+            "}",
+        ].join("\n"), "utf-8");
+        generateMock.mockReset();
+        configState.transformMaxFileLines = 1084;
+        runtimeLoggerState.logRuntimeRecord.mockReset();
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("keeps the new transform owner free of old MainAgent imports", () => {
+        const transformOwnerFile = path.join(process.cwd(), "cli", "src", "agent", "transform", "index.ts");
+        const source = fs.readFileSync(transformOwnerFile, "utf-8");
+        expect(source).not.toContain("../agents/");
+        expect(source).not.toContain("../../agents/");
+        expect(source).not.toContain("MainAgent");
+    });
+    it("builds a per-file transform plan with grounded excerpts and edits", async () => {
+        generateMock.mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    {
+                        id: "edit-1",
+                        order: 1,
+                        excerptIndex: 0,
+                        action: "extract-helper",
+                        summary: "Move the return logic into a helper.",
+                        acceptanceChecks: ["sample now calls the helper"],
+                    },
+                ],
+                acceptanceChecks: ["sample still exports one function"],
+            }),
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        const plan = await buildTransformPlan(memory, targetFile);
+        expect(plan.filePath).toBe(targetFile);
+        expect(plan.excerpts).toHaveLength(1);
+        expect(plan.excerpts[0].symbols).toEqual(["sample"]);
+        expect(plan.edits).toEqual([
+            expect.objectContaining({
+                id: "edit-1",
+                order: 1,
+                excerptIndex: 0,
+                action: "extract-helper",
+                status: "pending",
+            }),
+        ]);
+    });
+    it("selects only the next N pending edits for each batch", () => {
+        const batch = selectNextTransformBatch({
+            filePath: targetFile,
+            originalContent: "x",
+            latestContent: "x",
+            plan: {
+                filePath: targetFile,
+                excerpts: [],
+                edits: [
+                    { id: "edit-1", order: 1, action: "a", summary: "one", status: "pending" },
+                    { id: "edit-2", order: 2, action: "b", summary: "two", status: "pending" },
+                    { id: "edit-3", order: 3, action: "c", summary: "three", status: "pending" },
+                ],
+            },
+            completedEditIds: [],
+            failedEditIds: [],
+            retryCounts: {},
+            validationResults: [],
+        }, 3);
+        expect(batch).toEqual({
+            editIds: ["edit-1", "edit-2", "edit-3"],
+            retryCount: 0,
+        });
+    });
+    it("uses batches of 5 edits for files up to 300 lines", async () => {
+        overwriteFileWithLineCount(targetFile, 300);
+        queueValidTransformLoop([["edit-1", "edit-2", "edit-3", "edit-4", "edit-5"], ["edit-6"]]);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await runCodeTransform(memory, targetFile);
+        const applyCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.apply");
+        const validateCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.validate");
+        expect(applyCalls).toHaveLength(2);
+        expect(applyCalls[0]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-1", "edit-2", "edit-3", "edit-4", "edit-5"]);
+        expect(applyCalls[1]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-6"]);
+        expect(validateCalls[0]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-1", "edit-2", "edit-3", "edit-4", "edit-5"]);
+        expect(validateCalls[1]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-6"]);
+    });
+    it("uses batches of 3 edits for files from 301 to 700 lines", async () => {
+        overwriteFileWithLineCount(targetFile, 301);
+        queueValidTransformLoop([["edit-1", "edit-2", "edit-3"], ["edit-4"]]);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await runCodeTransform(memory, targetFile);
+        const applyCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.apply");
+        expect(applyCalls).toHaveLength(2);
+        expect(applyCalls[0]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-1", "edit-2", "edit-3"]);
+        expect(applyCalls[1]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-4"]);
+    });
+    it("uses batches of 3 edits at the 700-line upper medium boundary", async () => {
+        overwriteFileWithLineCount(targetFile, 700);
+        queueValidTransformLoop([["edit-1", "edit-2", "edit-3"], ["edit-4"]]);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await runCodeTransform(memory, targetFile);
+        const applyCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.apply");
+        expect(applyCalls).toHaveLength(2);
+        expect(applyCalls[0]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-1", "edit-2", "edit-3"]);
+        expect(applyCalls[1]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-4"]);
+    });
+    it("uses batches of 1 edit for files from 701 lines up to the cap", async () => {
+        overwriteFileWithLineCount(targetFile, 701);
+        queueValidTransformLoop([["edit-1"], ["edit-2"], ["edit-3"]]);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await runCodeTransform(memory, targetFile);
+        const applyCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.apply");
+        expect(applyCalls).toHaveLength(3);
+        expect(applyCalls[0]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-1"]);
+        expect(applyCalls[1]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-2"]);
+        expect(applyCalls[2]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-3"]);
+    });
+    it("keeps 1084-line files allowed with 1 edit per batch", async () => {
+        overwriteFileWithLineCount(targetFile, 1084);
+        queueValidTransformLoop([["edit-1"], ["edit-2"]]);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await runCodeTransform(memory, targetFile);
+        const applyCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.apply");
+        expect(applyCalls).toHaveLength(2);
+        expect(applyCalls[0]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-1"]);
+        expect(applyCalls[1]?.[1]?.inputContext?.batchEditIds).toEqual(["edit-2"]);
+    });
+    it("warns when a large allowed transform file may be slow", async () => {
+        overwriteFileWithLineCount(targetFile, 800);
+        queueValidTransformLoop([["edit-1"]]);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        memory.task.currentStepId = "step-999";
+        const ui = {
+            update: vi.fn(),
+            message: vi.fn(),
+            pause: vi.fn((fn) => fn()),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+            stop: vi.fn(),
+        };
+        const action = buildActions(buildTools(), ui).codeTransform;
+        const result = await action.run(memory, { target: targetFile });
+        expect(result.ok).toBe(true);
+        expect(ui.message).toHaveBeenCalledWith("Transform file: sample.ts");
+        expect(ui.message).toHaveBeenCalledWith(chalk.yellow("Warning: 800-line transform files can be slow. Files from 800 to 1084 lines run with 1 edit per batch."));
+    });
+    it("blocks files above the default cap before transform LLM calls", async () => {
+        overwriteFileWithLineCount(targetFile, 1085);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        memory.task.currentStepId = "step-999";
+        const ui = {
+            update: vi.fn(),
+            message: vi.fn(),
+            pause: vi.fn((fn) => fn()),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+            stop: vi.fn(),
+        };
+        const action = buildActions(buildTools(), ui).codeTransform;
+        const result = await action.run(memory, { target: targetFile });
+        expect(result.ok).toBe(false);
+        expect(result.summary).toContain("File has 1085 lines");
+        expect(result.summary).toContain("transform limit of 1084 lines");
+        expect(result.summary).toContain("config.transformMaxFileLines");
+        expect(generateMock).not.toHaveBeenCalled();
+        expect(ui.message).toHaveBeenCalledWith("Transform failed for sample.ts. Reason: File has 1085 lines, which exceeds the transform limit of 1084 lines. Increase config.transformMaxFileLines locally only if you accept slower runs.");
+    });
+    it("allows a higher local cap override", async () => {
+        overwriteFileWithLineCount(targetFile, 1200);
+        configState.transformMaxFileLines = 1300;
+        queueValidTransformLoop([["edit-1"]]);
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await runCodeTransform(memory, targetFile);
+        const applyCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.apply");
+        expect(applyCalls).toHaveLength(1);
+    });
+    it("enforces a lower local cap override", async () => {
+        overwriteFileWithLineCount(targetFile, 650);
+        configState.transformMaxFileLines = 600;
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await expect(runCodeTransform(memory, targetFile)).rejects.toThrow("File has 650 lines, which exceeds the transform limit of 600 lines.");
+        expect(generateMock).not.toHaveBeenCalled();
+    });
+    it("repairs broken JavaScript syntax once before validation", async () => {
+        targetFile = path.join(tempDir, "sample.js");
+        fs.writeFileSync(targetFile, "function sample() {\n  return 1;\n}\n", "utf-8");
+        generateMock
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    { id: "edit-1", order: 1, excerptIndex: 0, action: "rename-export", summary: "Rename sample to renamedSample." },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: "<FILE_CONTENT>\nfunction renamedSample( {\n  return 1;\n}\n</FILE_CONTENT>",
+        })
+            .mockResolvedValueOnce({
+            data: "<FILE_CONTENT>\nfunction renamedSample() {\n  return 1;\n}\n</FILE_CONTENT>",
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-1", status: "completed", rationale: "The export was renamed." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The syntax-repaired batch is valid.",
+            }),
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        const result = await runCodeTransform(memory, targetFile);
+        const syntaxRepairCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.syntax-repair");
+        const validateCall = generateMock.mock.calls.find(([, options]) => options?.caller === "agent.transform.validate");
+        expect(syntaxRepairCalls).toHaveLength(1);
+        expect(syntaxRepairCalls[0]?.[1]?.inputContext?.syntaxError).toContain("Unexpected");
+        expect(validateCall?.[0]?.content).toContain("function renamedSample()");
+        expect(result.artifact.content).toContain("function renamedSample()");
+        expect(fs.readFileSync(targetFile, "utf-8")).toContain("function renamedSample()");
+    });
+    it("blocks the transform when syntax repair still leaves invalid JavaScript", async () => {
+        targetFile = path.join(tempDir, "sample.js");
+        fs.writeFileSync(targetFile, "function sample() {\n  return 1;\n}\n", "utf-8");
+        generateMock
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    { id: "edit-1", order: 1, excerptIndex: 0, action: "rename-export", summary: "Rename sample to renamedSample." },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: "<FILE_CONTENT>\nfunction renamedSample( {\n  return 1;\n}\n</FILE_CONTENT>",
+        })
+            .mockResolvedValueOnce({
+            data: "<FILE_CONTENT>\nfunction renamedSample( {\n  return 1;\n}\n</FILE_CONTENT>",
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await expect(runCodeTransform(memory, targetFile)).rejects.toThrow(`Transform batch produced invalid JavaScript for ${targetFile}:`);
+        const validateCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.validate");
+        expect(validateCalls).toHaveLength(0);
+    });
+    it("skips JavaScript syntax repair for non-JavaScript transform targets", async () => {
+        generateMock
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    { id: "edit-1", order: 1, excerptIndex: 0, action: "rename-export", summary: "Rename sample to renamedSample." },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: "<FILE_CONTENT>\nexport function renamedSample() {\n  return 1;\n}\n</FILE_CONTENT>",
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-1", status: "completed", rationale: "The export was renamed." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The transform batch is valid.",
+            }),
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        await runCodeTransform(memory, targetFile);
+        const syntaxRepairCalls = generateMock.mock.calls.filter(([, options]) => options?.caller === "agent.transform.syntax-repair");
+        expect(syntaxRepairCalls).toHaveLength(0);
+    });
+    it("runs batched apply, validation, retry, and continuation inside the transform owner", async () => {
+        generateMock
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    { id: "edit-1", order: 1, excerptIndex: 0, action: "extract-helper", summary: "Add helper." },
+                    { id: "edit-2", order: 2, excerptIndex: 0, action: "call-helper", summary: "Call the helper." },
+                    { id: "edit-3", order: 3, excerptIndex: 0, action: "rename-export", summary: "Rename the export." },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "function helper() {",
+                "  return 1;",
+                "}",
+                "export function sample() {",
+                "  return helper();",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-1", status: "completed", rationale: "Helper extracted." },
+                    { editId: "edit-2", status: "completed", rationale: "Call now uses the helper." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The first batch is valid.",
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "function helper() {",
+                "  return 1;",
+                "}",
+                "export function renamedSample() {",
+                "  return sample();",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "invalid",
+                perEditResults: [
+                    { editId: "edit-3", status: "failed", rationale: "The old symbol call was left behind." },
+                ],
+                unplannedChanges: ["renamedSample still calls sample()"],
+                requiresRedo: true,
+                summary: "The rename batch missed one call site.",
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "function helper() {",
+                "  return 1;",
+                "}",
+                "export function renamedSample() {",
+                "  return helper();",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-3", status: "completed", rationale: "The export rename is now complete." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The repaired batch is valid.",
+            }),
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        const result = await runCodeTransform(memory, targetFile);
+        const transformState = memory.artifacts.transform?.files[targetFile];
+        expect(result.artifact.content).toContain("export function renamedSample()");
+        expect(result.artifact.content).toContain("return helper();");
+        expect(fs.readFileSync(targetFile, "utf-8")).toContain("export function renamedSample()");
+        expect(transformState?.completedEditIds).toEqual(["edit-1", "edit-2", "edit-3"]);
+        expect(transformState?.failedEditIds).toEqual([]);
+        expect(transformState?.retryCounts["edit-3"]).toBe(1);
+        expect(transformState?.validationResults).toHaveLength(3);
+    });
+    it("emits inner runtime records and progress stages for the transform loop", async () => {
+        overwriteFileWithLineCount(targetFile, 801);
+        generateMock
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    { id: "edit-1", order: 1, excerptIndex: 0, action: "extract-helper", summary: "Add helper." },
+                    { id: "edit-2", order: 2, excerptIndex: 0, action: "call-helper", summary: "Call the helper." },
+                    { id: "edit-3", order: 3, excerptIndex: 0, action: "rename-export", summary: "Rename the export." },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "function helper() {",
+                "  return 1;",
+                "}",
+                "export function sample() {",
+                "  return helper();",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-1", status: "completed", rationale: "Helper extracted." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The first batch is valid.",
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "function helper() {",
+                "  return 1;",
+                "}",
+                "export function sample() {",
+                "  return helper();",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-2", status: "completed", rationale: "Call now uses the helper." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The second batch is valid.",
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "function helper() {",
+                "  return 1;",
+                "}",
+                "export function renamedSample() {",
+                "  return sample();",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "invalid",
+                perEditResults: [
+                    { editId: "edit-3", status: "failed", rationale: "The old symbol call was left behind." },
+                ],
+                unplannedChanges: ["renamedSample still calls sample()"],
+                requiresRedo: true,
+                summary: "The rename batch missed one call site.",
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "function helper() {",
+                "  return 1;",
+                "}",
+                "export function renamedSample() {",
+                "  return helper();",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-3", status: "completed", rationale: "The export rename is now complete." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The repaired batch is valid.",
+            }),
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        memory.task.currentStepId = "step-999";
+        const progressStages = [];
+        await runCodeTransform(memory, targetFile, {
+            onProgress(progress) {
+                progressStages.push(progress.stage);
+            },
+        });
+        const transformRecords = runtimeLoggerState.logRuntimeRecord.mock.calls
+            .map((call) => call[0])
+            .filter((record) => record?.payload?.action === "codeTransform");
+        const summaries = transformRecords.map((record) => record.summary);
+        expect(summaries).toContain("transform started");
+        expect(summaries).toContain("transform planning started");
+        expect(summaries).toContain("transform plan created");
+        expect(summaries).toContain("transform batch selected");
+        expect(summaries).toContain("transform apply started");
+        expect(summaries).toContain("transform apply finished");
+        expect(summaries).toContain("transform validation started");
+        expect(summaries).toContain("transform validation result");
+        expect(summaries).toContain("transform retry requested");
+        expect(summaries).toContain("transform completed");
+        expect(progressStages[0]).toBe("started");
+        expect(progressStages).toContain("planning");
+        expect(progressStages.filter((stage) => stage === "applying").length).toBeGreaterThanOrEqual(3);
+        expect(progressStages.filter((stage) => stage === "validating").length).toBeGreaterThanOrEqual(3);
+        expect(progressStages).toContain("retrying");
+        expect(progressStages[progressStages.length - 1]).toBe("completed");
+        expect(batchSummaries(transformRecords, "transform batch selected")).toEqual(["batch 1/3", "batch 2/3", "batch 3/3"]);
+    });
+    it("exposes only codeTransform once a transform target has a grounded full read", () => {
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        memory.task.primaryIntent = "Refactor the target file.";
+        const policy = resolvePolicyState(memory);
+        expect(policy.allowedActions).toEqual(["codeTransform"]);
+    });
+    it("runs the outer loop with one visible codeTransform action", async () => {
+        generateMock
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                normalizedQuery: `Refactor ${targetFile}`,
+                explicitTargets: [targetFile],
+                constraints: [],
+                primaryIntent: "Refactor the target file.",
+                alternativeIntents: [],
+                ambiguityFlags: [],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                action: "read-file",
+                args: { target: targetFile },
+                reason: "Read the target file before transforming it.",
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                summary: "The file exports sample.",
+                relevanceExplanation: "This file is the requested transform target.",
+                role: "primary",
+                keySymbols: ["sample"],
+                excerpts: [{
+                        description: "Main sample function.",
+                        startLine: 1,
+                        endLine: 3,
+                        symbols: ["sample"],
+                        code: "export function sample() {\n  return 1;\n}",
+                    }],
+                risks: [],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    { id: "edit-1", order: 1, excerptIndex: 0, action: "rename-export", summary: "Rename sample to renamedSample." },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: [
+                "<FILE_CONTENT>",
+                "export function renamedSample() {",
+                "  return 1;",
+                "}",
+                "</FILE_CONTENT>",
+            ].join("\n"),
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "valid",
+                perEditResults: [
+                    { editId: "edit-1", status: "completed", rationale: "The export was renamed." },
+                ],
+                unplannedChanges: [],
+                requiresRedo: false,
+                summary: "The transform batch is valid.",
+            }),
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        const ui = {
+            update: vi.fn(),
+            message: vi.fn(),
+            pause: vi.fn((fn) => fn()),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+            stop: vi.fn(),
+        };
+        await runAgentLoop(memory, ui);
+        expect(memory.task.status).toBe("done");
+        expect(memory.steps.some((step) => step.action === "codeTransform" && step.status === "done")).toBe(true);
+        expect(memory.artifacts.finalAnswer).toContain(`Updated ${targetFile}`);
+        expect(fs.readFileSync(targetFile, "utf-8")).toContain("renamedSample");
+        expect(ui.message).toHaveBeenCalledWith("Transform file: sample.ts");
+        expect(ui.message).toHaveBeenCalledWith("Transform completed for sample.ts.");
+        expect(ui.update).toHaveBeenCalledWith(expect.stringContaining("sample.ts | batch 1/1 | edit 1 | applying"));
+        expect(ui.update).toHaveBeenCalledWith(expect.stringContaining("sample.ts | batch 1/1 | edit 1 | validating"));
+    });
+    it("emits retry and failure boundary lines during a failed transform", async () => {
+        generateMock
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                edits: [
+                    { id: "edit-1", order: 1, excerptIndex: 0, action: "rename-export", summary: "Rename sample to renamedSample." },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: "<FILE_CONTENT>\nexport function renamedSample() {\n  return sample();\n}\n</FILE_CONTENT>",
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "invalid",
+                perEditResults: [
+                    { editId: "edit-1", status: "failed", rationale: "Old symbol call remains." },
+                ],
+                unplannedChanges: ["renamedSample still calls sample()"],
+                requiresRedo: true,
+                summary: "First validation failed.",
+            }),
+        })
+            .mockResolvedValueOnce({
+            data: "<FILE_CONTENT>\nexport function renamedSample() {\n  return sample();\n}\n</FILE_CONTENT>",
+        })
+            .mockResolvedValueOnce({
+            data: JSON.stringify({
+                status: "invalid",
+                perEditResults: [
+                    { editId: "edit-1", status: "failed", rationale: "Repair still left the old symbol call." },
+                ],
+                unplannedChanges: ["renamedSample still calls sample()"],
+                requiresRedo: true,
+                summary: "Repair validation failed.",
+            }),
+        });
+        const memory = createAgentMemory(`Refactor ${targetFile}`, tempDir, tempDir);
+        addFullRead(memory, targetFile);
+        memory.task.currentStepId = "step-999";
+        const ui = {
+            update: vi.fn(),
+            message: vi.fn(),
+            pause: vi.fn((fn) => fn()),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+            stop: vi.fn(),
+        };
+        const action = buildActions(buildTools(), ui).codeTransform;
+        const result = await action.run(memory, { target: targetFile });
+        expect(result.ok).toBe(false);
+        expect(ui.message).toHaveBeenCalledWith("Transform file: sample.ts");
+        expect(ui.message).toHaveBeenCalledWith("Retry batch 1/1 for sample.ts.");
+        expect(ui.message).toHaveBeenCalledWith("Transform failed for sample.ts at batch 1/1. Reason: Repair validation failed.");
+        expect(ui.update).toHaveBeenCalledWith(expect.stringContaining("sample.ts | batch 1/1 | edit 1 | retrying | retry 1"));
+    });
+});
+//# sourceMappingURL=agentTransform.test.js.map