fix(logging): keep the active log when rotation fails

Renaming onto the previous generation replaces it only when that rename
succeeds. Deleting that generation first, then truncating the active
file on failure, drops every record but the last.

Author: TheGreatAxios

src/logging/sink.test.ts

@@ -108,6 +108,34 @@ describe("installFileLogSink", () => {
     }
   });
 
+  test("a failed rotation keeps already-written records in the active file", () => {
+    const { dir, file } = tempLogFile();
+    try {
+      installFileLogSink(file, { maxBytes: 180 });
+      const logger = getLogger(["logging", "rotate-fail"]);
+      for (let i = 0; i < 30; i++) logger.info(`seed-line-${i}-xxxxxxxx`);
+      flushFileLogSinkSync();
+      const rotated = `${file}.1`;
+      expect(fs.statSync(rotated).isFile()).toBe(true);
+      fs.rmSync(rotated);
+      fs.mkdirSync(rotated);
+      const kept = fs.readFileSync(file, "utf8");
+      expect(kept.length).toBeGreaterThan(0);
+      logger.info("kept-tail-1");
+      logger.info("kept-tail-2");
+      logger.info("kept-tail-3");
+      flushFileLogSinkSync();
+      const active = fs.readFileSync(file, "utf8");
+      expect(active.startsWith(kept)).toBe(true);
+      expect(active).toContain("kept-tail-1");
+      expect(active).toContain("kept-tail-2");
+      expect(active).toContain("kept-tail-3");
+      expect(fs.statSync(rotated).isDirectory()).toBe(true);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   test("a crash or exit flush writes the pending tail", () => {
     const { dir, file } = tempLogFile();
     try {

src/logging/sink.ts

@@ -58,20 +58,17 @@ function fileSize(path: string): number {
 }
 
 function rotateActive(current: FileSinkState): void {
-  const rotated = `${current.path}.1`;
+  // Publish the filled file by renaming it onto `.1`. Do not remove `.1`
+  // first, and do not truncate the active file if rename fails: a directory
+  // or busy `.1` throws, and wiping the live log then leaves only the next
+  // line. A failed rename leaves both paths untouched, so this cycle may
+  // grow past the cap.
   try {
-    fs.rmSync(rotated, { force: true });
-    fs.renameSync(current.path, rotated);
-    current.size = 0;
+    fs.renameSync(current.path, `${current.path}.1`);
   } catch {
-    try {
-      // rename can fail (missing file, cross-device); truncating still caps growth.
-      fs.truncateSync(current.path, 0);
-      current.size = 0;
-    } catch {
-      // Keep `size` so a later flush retries instead of appending forever.
-    }
+    return;
   }
+  current.size = 0;
 }
 
 function writeBatch(