fix(git): skip one failed remove without staging the batch

Array git.remove throws before the index write, so swallowing
that error committed every removed path still staged. Omit the
failing path and write the rest once. If nothing can be
unstaged, fail the commit instead.

Author: TheGreatAxios

src/session/optimized-context-store.test.ts

@@ -1,4 +1,5 @@
 import { defined } from "../../testkit/defined.js";
+import { withMockedModuleDuring } from "../../testkit/mock-module.js";
 import { describe, test, expect } from "bun:test";
 import fs from "node:fs";
 import os from "node:os";
@@ -1726,4 +1727,50 @@ describe("createOptimizedContextStore prompt dedupe (CL-9026)", () => {
     expect(tree).not.toContain(extraPrompt);
     expect(turnTexts((await store.load()).turns)).toEqual(turnTexts(live));
   });
+
+  test("one remove failure still unstages the other paths in one index write", async () => {
+    const dir = tempDir();
+    const store = await createOptimizedContextStore(dir);
+    const huge = "x".repeat(300_000);
+    const live = [turn(`live-${huge}`), turn("live-tail")];
+    await store.writeTurns([...live]);
+    await store.writePrompt([turn(`prompt-${huge}`), turn("prompt-tail")]);
+    await store.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await store.commit({ message: "two prompt segments" });
+    const extraPrompt = segmentFileName(PROMPT_FILE, 1);
+    expect(await gitLsTree(dir)).toEqual(
+      expect.arrayContaining([PROMPT_FILE, extraPrompt]),
+    );
+
+    await store.writePrompt(cloneTurns(live));
+    await store.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+
+    const removeCalls: (string | string[])[] = [];
+    await withMockedModuleDuring(
+      import.meta.resolve("isomorphic-git"),
+      (real: typeof import("isomorphic-git")) => {
+        const remove: typeof real.default.remove = async (args) => {
+          removeCalls.push(args.filepath);
+          const paths = Array.isArray(args.filepath)
+            ? args.filepath
+            : [args.filepath];
+          if (paths.includes(extraPrompt)) {
+            throw new Error("index write failed");
+          }
+          return real.default.remove(args);
+        };
+        return { ...real, default: { ...real.default, remove } };
+      },
+      () => store.commit({ message: "drop prompt segments" }),
+    );
+
+    const tree = await gitLsTree(dir);
+    expect(tree).not.toContain(PROMPT_FILE);
+    expect(tree).toContain(extraPrompt);
+    const written = removeCalls.filter((filepath) => {
+      const paths = Array.isArray(filepath) ? filepath : [filepath];
+      return !paths.includes(extraPrompt);
+    });
+    expect(written).toEqual([[PROMPT_FILE]]);
+  });
 });

src/session/optimized-context-store.ts

@@ -1332,19 +1332,34 @@ export async function createSessionStores(
           const remove = [...new Set(toRemove)].filter((p) => !add.includes(p));
           extraPaths = [...new Set([...add, ...remove])];
 
-          // Array-form add/remove stages and unstages in one index write
-          // per call (isomorphic-git >= 1.42.7). On a mid-batch add failure
-          // the index is left unwritten and the catch below still resets
-          // every extraPath, so the all-or-nothing outcome matches the old
-          // per-file loop.
+          // Array `git.add` / `git.remove` each write the index once.
+          // Array `remove` is isomorphic-git 1.43.0; array `add` is older.
+          // A mid-batch add failure leaves the index unwritten. Only the
+          // outer catch calls `resetIndexPaths`.
           if (add.length > 0) {
             await git.add({ fs, dir, filepath: add });
           }
           if (remove.length > 0) {
             try {
               await git.remove({ fs, dir, filepath: remove });
-            } catch {
-              // Already absent from the index.
+            } catch (cause) {
+              // `GitIndex.delete` does not throw when a path is absent, so
+              // this is an index lock or write. It aborts before the index
+              // write. Skip the failing path and write the rest once.
+              let unstaged = false;
+              if (remove.length > 1) {
+                for (let index = 0; index < remove.length; index++) {
+                  const rest = remove.filter((_, other) => other !== index);
+                  try {
+                    await git.remove({ fs, dir, filepath: rest });
+                    unstaged = true;
+                    break;
+                  } catch {
+                    // This omission still aborted before the index write.
+                  }
+                }
+              }
+              if (!unstaged) throw cause;
             }
           }
           const committed = await base.commit(options, signal);