@ronkovic/aad 0.3.0

package/src/modules/git-workspace/__tests__/branch-manager.test.ts

@@ -0,0 +1,335 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import { BranchManager } from "../branch-manager";
+import { createTaskId, createRunId } from "@aad/shared/types";
+import { GitWorkspaceError } from "@aad/shared/errors";
+import { pino } from "pino";
+import type { GitOps } from "../git-exec";
+
+describe("BranchManager", () => {
+  let branchManager: BranchManager;
+  const repoRoot = "/test/repo";
+
+  let mockGitOps: GitOps;
+
+  beforeEach(() => {
+    mockGitOps = {
+      gitExec: mock(async () => ({ stdout: "", stderr: "", exitCode: 0 })),
+      branchExists: mock(async () => false),
+    };
+
+    branchManager = new BranchManager({
+      repoRoot,
+      logger: pino({ level: "silent" }),
+      gitOps: mockGitOps,
+    });
+  });
+
+  describe("createParentBranch", () => {
+    test("creates parent branch from base branch", async () => {
+      const runId = createRunId("run-001");
+      const baseBranch = "main";
+
+      const branchName = await branchManager.createParentBranch(runId, baseBranch);
+
+      expect(branchName).toBe("aad-run-run-001");
+      expect(mockGitOps.branchExists).toHaveBeenCalledWith("aad-run-run-001", repoRoot, expect.anything());
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["checkout", "-b", "aad-run-run-001", baseBranch],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("throws error if branch already exists", async () => {
+      const runId = createRunId("run-002");
+      const baseBranch = "main";
+
+      mockGitOps.branchExists = mock(async () => true);
+
+      await expect(
+        branchManager.createParentBranch(runId, baseBranch)
+      ).rejects.toThrow("Parent branch already exists");
+    });
+
+    test("throws GitWorkspaceError on git failure", async () => {
+      const runId = createRunId("run-003");
+      const baseBranch = "main";
+
+      mockGitOps.gitExec = mock(() => Promise.reject(new Error("git checkout failed")));
+
+      await expect(
+        branchManager.createParentBranch(runId, baseBranch)
+      ).rejects.toThrow(GitWorkspaceError);
+    });
+  });
+
+  describe("createTaskBranch", () => {
+    test("creates task branch from parent branch", async () => {
+      const taskId = createTaskId("task-001");
+      const parentBranch = "aad-run-run-001";
+
+      const branchName = await branchManager.createTaskBranch(taskId, parentBranch);
+
+      expect(branchName).toBe("aad-task-task-001");
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "aad-task-task-001", parentBranch],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("returns existing branch if already exists", async () => {
+      const taskId = createTaskId("task-002");
+      const parentBranch = "aad-run-run-001";
+
+      mockGitOps.branchExists = mock(async () => true);
+
+      const branchName = await branchManager.createTaskBranch(taskId, parentBranch);
+
+      expect(branchName).toBe("aad-task-task-002");
+      expect(mockGitOps.gitExec).not.toHaveBeenCalled();
+    });
+
+    test("throws GitWorkspaceError on git failure", async () => {
+      const taskId = createTaskId("task-003");
+      const parentBranch = "aad-run-run-001";
+
+      mockGitOps.gitExec = mock(() => Promise.reject(new Error("git branch failed")));
+
+      await expect(
+        branchManager.createTaskBranch(taskId, parentBranch)
+      ).rejects.toThrow(GitWorkspaceError);
+    });
+  });
+
+  describe("deleteBranch", () => {
+    test("deletes branch with default (non-force) mode", async () => {
+      const branchName = "aad-task-task-001";
+
+      await branchManager.deleteBranch(branchName);
+
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "-d", branchName],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("deletes branch with force mode", async () => {
+      const branchName = "aad-task-task-002";
+
+      await branchManager.deleteBranch(branchName, true);
+
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "-D", branchName],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("throws GitWorkspaceError on failure", async () => {
+      const branchName = "aad-task-task-003";
+
+      mockGitOps.gitExec = mock(() => Promise.reject(new Error("branch not found")));
+
+      await expect(branchManager.deleteBranch(branchName)).rejects.toThrow(GitWorkspaceError);
+    });
+  });
+
+  describe("listBranches", () => {
+    test("lists branches matching pattern", async () => {
+      const pattern = "aad-task-*";
+      const output = "  aad-task-task-001\n* aad-task-task-002\n  aad-task-task-003\n";
+
+      mockGitOps.gitExec = mock(async () => ({ stdout: output, stderr: "", exitCode: 0 }));
+
+      const branches = await branchManager.listBranches(pattern);
+
+      expect(branches).toEqual(["aad-task-task-001", "aad-task-task-002", "aad-task-task-003"]);
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "--list", pattern],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("returns empty array when no branches match", async () => {
+      const pattern = "nonexistent-*";
+
+      mockGitOps.gitExec = mock(async () => ({ stdout: "", stderr: "", exitCode: 0 }));
+
+      const branches = await branchManager.listBranches(pattern);
+
+      expect(branches).toEqual([]);
+    });
+
+    test("removes leading asterisk from current branch", async () => {
+      const pattern = "main";
+      const output = "* main\n";
+
+      mockGitOps.gitExec = mock(async () => ({ stdout: output, stderr: "", exitCode: 0 }));
+
+      const branches = await branchManager.listBranches(pattern);
+
+      expect(branches).toEqual(["main"]);
+    });
+
+    test("throws GitWorkspaceError on failure", async () => {
+      const pattern = "aad-*";
+
+      mockGitOps.gitExec = mock(() => Promise.reject(new Error("git branch failed")));
+
+      await expect(branchManager.listBranches(pattern)).rejects.toThrow(GitWorkspaceError);
+    });
+  });
+
+  describe("cleanupOrphanBranches", () => {
+    test("cleans up orphan branches without runId", async () => {
+      const branches = ["aad-task-task-001", "aad-task-task-002", "aad-run-run-001"];
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async () => {
+        callCount++;
+        if (callCount === 1) {
+          return { stdout: branches.join("\n"), stderr: "", exitCode: 0 };
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      const deleted = await branchManager.cleanupOrphanBranches();
+
+      expect(deleted).toEqual(branches);
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "--list", "aad-*"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("cleans up orphan branches for specific runId", async () => {
+      const runId = createRunId("run-001");
+      const branches = ["aad-task-run-001-01", "aad-run-run-001"];
+
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        callCount++;
+        // First pattern: aad/{runId}/* - returns branches
+        if (callCount === 1 && args[2] === "aad/run-001/*") {
+          return { stdout: branches.join("\n"), stderr: "", exitCode: 0 };
+        }
+        // All other calls (delete, second pattern list): return success
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      const deleted = await branchManager.cleanupOrphanBranches(runId);
+
+      expect(deleted).toEqual(branches);
+      // Should check both patterns
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "--list", "aad/run-001/*"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "--list", "aad-*-run-001*"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("skips branches that cannot be deleted", async () => {
+      const branches = ["aad-task-task-001", "aad-task-task-002"];
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        callCount++;
+        // First pattern (aad/*) list: return branches
+        if (callCount === 1 && args[2] === "aad/*") {
+          return { stdout: branches.join("\n"), stderr: "", exitCode: 0 };
+        }
+        // First delete: success
+        if (callCount === 2 && args[0] === "branch" && args[1] === "-d") {
+          return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        // Second delete: fail
+        if (callCount === 3 && args[0] === "branch" && args[1] === "-d") {
+          throw new Error("branch has unmerged commits");
+        }
+        // Second pattern (aad-*) list: empty
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      const deleted = await branchManager.cleanupOrphanBranches();
+
+      expect(deleted).toEqual(["aad-task-task-001"]);
+    });
+
+    test("returns empty array when no branches to clean up", async () => {
+      mockGitOps.gitExec = mock(async () => ({ stdout: "", stderr: "", exitCode: 0 }));
+
+      const deleted = await branchManager.cleanupOrphanBranches();
+
+      expect(deleted).toEqual([]);
+    });
+  });
+
+  describe("forceCleanupRun", () => {
+    test("force deletes all branches for a run", async () => {
+      const runId = createRunId("run-001");
+      const branches = ["aad-task-run-001-01", "aad-task-run-001-02", "aad-run-run-001"];
+
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        callCount++;
+        // First pattern (aad/{runId}/*) list: return branches
+        if (callCount === 1 && args[2] === "aad/run-001/*") {
+          return { stdout: branches.join("\n"), stderr: "", exitCode: 0 };
+        }
+        // All other calls (delete, second pattern list): return success
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      const deleted = await branchManager.forceCleanupRun(runId);
+
+      expect(deleted).toEqual(branches);
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "--list", "aad/run-001/*"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+
+      // Verify force delete (-D) was used
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["branch", "-D", branches[0]],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("continues deleting even if some branches fail", async () => {
+      const runId = createRunId("run-002");
+      const branches = ["aad-task-run-002-01", "aad-task-run-002-02"];
+
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        callCount++;
+        // First pattern (aad/{runId}/*) list: return branches
+        if (callCount === 1 && args[2] === "aad/run-002/*") {
+          return { stdout: branches.join("\n"), stderr: "", exitCode: 0 };
+        }
+        // First delete: success
+        if (callCount === 2 && args[0] === "branch" && args[1] === "-D") {
+          return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        // Second delete: fail
+        if (callCount === 3 && args[0] === "branch" && args[1] === "-D") {
+          throw new Error("failed to delete branch");
+        }
+        // Second pattern list: empty
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      const deleted = await branchManager.forceCleanupRun(runId);
+
+      expect(deleted).toEqual(["aad-task-run-002-01"]);
+    });
+
+    test("returns empty array when no branches match", async () => {
+      const runId = createRunId("run-003");
+
+      mockGitOps.gitExec = mock(async () => ({ stdout: "", stderr: "", exitCode: 0 }));
+
+      const deleted = await branchManager.forceCleanupRun(runId);
+
+      expect(deleted).toEqual([]);
+    });
+  });
+});

package/src/modules/git-workspace/__tests__/git-exec.test.ts

@@ -0,0 +1,91 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { rm, mkdir, mkdtemp } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { gitExec, isGitRepo, getCurrentBranch, branchExists } from "../git-exec";
+
+const TEST_DIR = join(import.meta.dir, ".tmp-git-exec-test");
+
+describe("git-exec", () => {
+  beforeAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await mkdir(TEST_DIR, { recursive: true });
+
+    // Initialize test git repo with explicit branch name
+    await gitExec(["init", "-b", "main"], { cwd: TEST_DIR });
+    await gitExec(["config", "user.name", "Test User"], { cwd: TEST_DIR });
+    await gitExec(["config", "user.email", "test@example.com"], { cwd: TEST_DIR });
+    // Disable GPG signing for test repo
+    await gitExec(["config", "commit.gpgsign", "false"], { cwd: TEST_DIR });
+
+    // Create initial commit
+    await Bun.write(join(TEST_DIR, "README.md"), "# Test Repo\n");
+    await gitExec(["add", "README.md"], { cwd: TEST_DIR });
+    await gitExec(["commit", "-m", "Initial commit"], { cwd: TEST_DIR });
+  }, 15_000);
+
+  afterAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("gitExec", () => {
+    test("executes git command successfully", async () => {
+      const result = await gitExec(["status", "--short"], { cwd: TEST_DIR });
+
+      expect(result.exitCode).toBe(0);
+      expect(typeof result.stdout).toBe("string");
+    });
+
+    test("throws GitWorkspaceError on failure", async () => {
+      await expect(
+        gitExec(["invalid-command"], { cwd: TEST_DIR })
+      ).rejects.toThrow("Git command failed");
+    });
+
+    test("returns stdout and stderr", async () => {
+      const result = await gitExec(["log", "--oneline", "-1"], { cwd: TEST_DIR });
+
+      expect(result.stdout).toContain("Initial commit");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("isGitRepo", () => {
+    test("returns true for git repository", async () => {
+      const result = await isGitRepo(TEST_DIR);
+      expect(result).toBe(true);
+    });
+
+    test("returns false for non-git directory", async () => {
+      // Create a temporary directory that is guaranteed not to be a git repo
+      const nonGitDir = await mkdtemp(join(tmpdir(), "aad-test-"));
+      try {
+        const result = await isGitRepo(nonGitDir);
+        expect(result).toBe(false);
+      } finally {
+        await rm(nonGitDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe("getCurrentBranch", () => {
+    test("returns current branch name", async () => {
+      const branch = await getCurrentBranch(TEST_DIR);
+      // git init -b main で明示指定したので "main" であるべき
+      expect(branch).toBe("main");
+    });
+  });
+
+  describe("branchExists", () => {
+    test("returns true for existing branch", async () => {
+      const currentBranch = await getCurrentBranch(TEST_DIR);
+      const exists = await branchExists(currentBranch, TEST_DIR);
+      expect(exists).toBe(true);
+    });
+
+    test("returns false for non-existing branch", async () => {
+      const exists = await branchExists("non-existent-branch", TEST_DIR);
+      expect(exists).toBe(false);
+    });
+  });
+});

package/src/modules/git-workspace/__tests__/memory-sync.test.ts

@@ -0,0 +1,273 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import { harvestMemory, type MemorySyncFsOps } from "../memory-sync";
+import { pino } from "pino";
+
+describe("harvestMemory", () => {
+  let mockFsOps: MemorySyncFsOps;
+
+  beforeEach(() => {
+    mockFsOps = {
+      readdir: mock(async () => []) as any,
+      readFile: mock(async () => "") as any,
+      writeFile: mock(async () => {}) as any,
+    };
+  });
+
+  test("harvests memory from agent directories", async () => {
+    const sourceDir = "/source/.claude/agent-memory";
+    const targetDir = "/target/.claude/agent-memory";
+
+    let readFileCallCount = 0;
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+      { name: "agent-2", isDirectory: () => true },
+    ] as any);
+
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return "Source line 1\nSource line 2\n";
+      if (readFileCallCount === 2) throw new Error("ENOENT");
+      if (readFileCallCount === 3) return "Source line 3\n";
+      if (readFileCallCount === 4) throw new Error("ENOENT");
+      return "";
+    }) as any;
+
+    await harvestMemory({
+      sourceDir,
+      targetDir,
+      logger: pino({ level: "silent" }),
+      fsOps: mockFsOps,
+    });
+
+    expect(mockFsOps.readdir).toHaveBeenCalledWith(sourceDir, { withFileTypes: true });
+    expect(mockFsOps.writeFile).toHaveBeenCalledTimes(2);
+    expect(mockFsOps.writeFile).toHaveBeenCalledWith(
+      "/target/.claude/agent-memory/agent-1/MEMORY.md",
+      "Source line 1\nSource line 2\n"
+    );
+    expect(mockFsOps.writeFile).toHaveBeenCalledWith(
+      "/target/.claude/agent-memory/agent-2/MEMORY.md",
+      "Source line 3\n"
+    );
+  });
+
+  test("deduplicates lines between source and target", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+    ] as any);
+
+    let readFileCallCount = 0;
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return "line1\nline2\nline3\n";
+      if (readFileCallCount === 2) return "line2\nline4\n";
+      return "";
+    }) as any;
+
+    await harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps });
+
+    expect(mockFsOps.writeFile).toHaveBeenCalledWith(
+      "/target/agent-1/MEMORY.md",
+      "line2\nline4\nline1\nline3\n"
+    );
+  });
+
+  test("limits output to maxLines (keeps most recent)", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+    ] as any);
+
+    let readFileCallCount = 0;
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return "line1\nline2\nline3\n";
+      if (readFileCallCount === 2) return "line4\nline5\n";
+      return "";
+    }) as any;
+
+    await harvestMemory({
+      sourceDir,
+      targetDir,
+      maxLines: 3,
+      logger: pino({ level: "silent" }),
+      fsOps: mockFsOps,
+    });
+
+    expect(mockFsOps.writeFile).toHaveBeenCalledTimes(1);
+    const calls = (mockFsOps.writeFile as any).mock.calls as Array<[string, string]>;
+    if (calls.length > 0) {
+      const writtenContent = calls[0]![1];
+      const lines = writtenContent.split("\n").filter((l) => l.length > 0);
+      expect(lines.length).toBeLessThanOrEqual(3);
+    }
+  });
+
+  test("skips non-directory entries", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+      { name: "file.txt", isDirectory: () => false },
+      { name: "agent-2", isDirectory: () => true },
+    ] as any);
+
+    let readFileCallCount = 0;
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return "line1\n";
+      if (readFileCallCount === 2) throw new Error("ENOENT");
+      if (readFileCallCount === 3) return "line2\n";
+      if (readFileCallCount === 4) throw new Error("ENOENT");
+      return "";
+    }) as any;
+
+    await harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps });
+
+    expect(mockFsOps.writeFile).toHaveBeenCalledTimes(2);
+  });
+
+  test("handles missing source memory file gracefully", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+    ] as any);
+
+    mockFsOps.readFile = mock(async () => {
+      throw new Error("ENOENT");
+    }) as any;
+
+    await harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps });
+
+    expect(mockFsOps.writeFile).not.toHaveBeenCalled();
+  });
+
+  test("handles source directory read error gracefully", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => {
+      throw new Error("Permission denied");
+    }) as any;
+
+    await expect(
+      harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps })
+    ).resolves.toBeUndefined();
+
+    expect(mockFsOps.writeFile).not.toHaveBeenCalled();
+  });
+
+  test("filters out empty lines", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+    ] as any);
+
+    let readFileCallCount = 0;
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return "line1\n\n\nline2\n   \nline3\n";
+      if (readFileCallCount === 2) throw new Error("ENOENT");
+      return "";
+    }) as any;
+
+    await harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps });
+
+    expect(mockFsOps.writeFile).toHaveBeenCalledTimes(1);
+    const calls = (mockFsOps.writeFile as any).mock.calls as Array<[string, string]>;
+    if (calls.length > 0) {
+      const writtenContent = calls[0]![1];
+      const lines = writtenContent.split("\n").filter((l) => l.trim().length > 0);
+      expect(lines).toEqual(["line1", "line2", "line3"]);
+    }
+  });
+
+  test("preserves order with target lines first", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+    ] as any);
+
+    let readFileCallCount = 0;
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return "source1\nsource2\n";
+      if (readFileCallCount === 2) return "target1\ntarget2\n";
+      return "";
+    }) as any;
+
+    await harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps });
+
+    expect(mockFsOps.writeFile).toHaveBeenCalledTimes(1);
+    const calls = (mockFsOps.writeFile as any).mock.calls as Array<[string, string]>;
+    if (calls.length > 0) {
+      const writtenContent = calls[0]![1];
+      expect(writtenContent).toBe("target1\ntarget2\nsource1\nsource2\n");
+    }
+  });
+
+  test("uses default maxLines of 200", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+    ] as any);
+
+    const manyLines = Array.from({ length: 250 }, (_, i) => `line${i}`).join("\n");
+    let readFileCallCount = 0;
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return manyLines;
+      if (readFileCallCount === 2) throw new Error("ENOENT");
+      return "";
+    }) as any;
+
+    await harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps });
+
+    expect(mockFsOps.writeFile).toHaveBeenCalledTimes(1);
+    const calls = (mockFsOps.writeFile as any).mock.calls as Array<[string, string]>;
+    if (calls.length > 0) {
+      const writtenContent = calls[0]![1];
+      const lines = writtenContent.split("\n").filter((l) => l.length > 0);
+      expect(lines.length).toBe(200);
+    }
+  });
+
+  test("handles write error gracefully", async () => {
+    const sourceDir = "/source";
+    const targetDir = "/target";
+
+    mockFsOps.readdir = mock(async () => [
+      { name: "agent-1", isDirectory: () => true },
+    ] as any);
+
+    let readFileCallCount = 0;
+    mockFsOps.readFile = mock(async () => {
+      readFileCallCount++;
+      if (readFileCallCount === 1) return "line1\n";
+      if (readFileCallCount === 2) throw new Error("ENOENT");
+      return "";
+    }) as any;
+
+    mockFsOps.writeFile = mock(async () => {
+      throw new Error("Write failed");
+    }) as any;
+
+    await expect(
+      harvestMemory({ sourceDir, targetDir, logger: pino({ level: "silent" }), fsOps: mockFsOps })
+    ).resolves.toBeUndefined();
+  });
+});