@blackbelt-technology/pi-agent-dashboard 0.4.5 → 0.5.0

package/packages/shared/src/__tests__/bootstrap-install-resolve-npm.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Regression: `resolveNpmArgv` from `bootstrap-install.ts` MUST consult
+ * the injected `ToolRegistry` for `npm` before falling back to the
+ * platform `npm` / `npm.cmd` PATH binary.
+ *
+ * The change `embed-managed-node-runtime` adds a managedRuntime
+ * strategy to the npm chain in the registry. If a future refactor
+ * accidentally bypasses the registry inside `resolveNpmArgv`, the
+ * managed Node runtime would stop being preferred for shared bootstrap
+ * spawns \u2014 the user-visible regression class this whole change exists
+ * to prevent.
+ *
+ * See change: embed-managed-node-runtime (task 4.2).
+ */
+import { describe, expect, it } from "vitest";
+import { resolveNpmArgv } from "../bootstrap-install.js";
+import type {
+  Resolution,
+  ToolRegistry,
+} from "../tool-registry/index.js";
+
+function fakeRegistry(opts: {
+  hasNpm?: boolean;
+  resolveResult?: Partial<Resolution>;
+}): ToolRegistry {
+  // Only the methods `resolveNpmArgv` actually calls.
+  return {
+    has: (name: string) => name === "npm" && (opts.hasNpm ?? true),
+    resolve: () =>
+      ({
+        name: "npm",
+        ok: true,
+        path: "/managed/node/bin/npm",
+        source: "managed",
+        tried: [],
+        resolvedAt: Date.now(),
+        ...opts.resolveResult,
+      }) as Resolution,
+  } as unknown as ToolRegistry;
+}
+
+describe("resolveNpmArgv", () => {
+  it("explicit npmArgv wins over registry", () => {
+    const argv = resolveNpmArgv({
+      npmArgv: ["/explicit/node", "/explicit/npm-cli.js"],
+      registry: fakeRegistry({}),
+    });
+    expect(argv).toEqual(["/explicit/node", "/explicit/npm-cli.js"]);
+  });
+
+  it("uses ToolRegistry.resolve('npm') when no explicit argv", () => {
+    const argv = resolveNpmArgv({
+      registry: fakeRegistry({
+        resolveResult: { ok: true, path: "/managed/node/bin/npm" } as Partial<Resolution>,
+      }),
+    });
+    expect(argv).toEqual(["/managed/node/bin/npm"]);
+  });
+
+  it("falls back to npm/npm.cmd on PATH when registry has no entry", () => {
+    const argv = resolveNpmArgv({
+      registry: {
+        has: () => false,
+        resolve: () => {
+          throw new Error("should not be called");
+        },
+      } as unknown as ToolRegistry,
+    });
+    expect(argv).toHaveLength(1);
+    expect(argv[0]).toMatch(/^npm(\.cmd)?$/);
+  });
+});

package/packages/shared/src/__tests__/browser-protocol-types.test.ts

@@ -12,8 +12,13 @@ import type {
   BrowserPromptDismissMessage,
   BrowserPromptCancelMessage,
   BrowserExtUiDecoratorMessage,
+  BrowserAssetRegisterMessage,
 } from "../browser-protocol.js";
-import type { ExtensionToServerMessage, ExtUiDecoratorMessage } from "../protocol.js";
+import type {
+  ExtensionToServerMessage,
+  ExtUiDecoratorMessage,
+  AssetRegisterMessage,
+} from "../protocol.js";
 import type { DecoratorDescriptor } from "../types.js";
 
 // Type-level assertion: if these types are NOT in the union, this will fail to compile.
@@ -26,6 +31,11 @@ type _PromptCancelInUnion = AssertExtends<BrowserPromptCancelMessage, ServerToBr
 // esbuild strips the switch arms in production builds.
 type _ExtUiDecoratorInExtensionUnion = AssertExtends<ExtUiDecoratorMessage, ExtensionToServerMessage>;
 type _ExtUiDecoratorInBrowserUnion   = AssertExtends<BrowserExtUiDecoratorMessage, ServerToBrowserMessage>;
+// chat-markdown-local-images-and-math: asset_register must live in BOTH the
+// extension→server union (so the server's switch arm survives esbuild) AND
+// the server→browser union (so the client's reducer arm survives esbuild).
+type _AssetRegisterInExtensionUnion = AssertExtends<AssetRegisterMessage, ExtensionToServerMessage>;
+type _AssetRegisterInBrowserUnion   = AssertExtends<BrowserAssetRegisterMessage, ServerToBrowserMessage>;
 
 // Runtime verification that the type discriminants are reachable in a switch
 function extractPromptType(msg: ServerToBrowserMessage): string | null {
@@ -119,3 +129,39 @@ describe("ext_ui_decorator is a member of both protocol unions", () => {
     expect(msg.descriptor.kind).toBe("footer-segment");
   });
 });
+
+// chat-markdown-local-images-and-math: asset_register switch-arm reachability.
+function extractAssetHash(msg: ServerToBrowserMessage): string | null {
+  switch (msg.type) {
+    case "asset_register":
+      return msg.hash;
+    default:
+      return null;
+  }
+}
+
+describe("asset_register is a member of both protocol unions", () => {
+  it("server→browser asset_register is a valid discriminant", () => {
+    const msg: BrowserAssetRegisterMessage = {
+      type: "asset_register",
+      sessionId: "s1",
+      hash: "abc1234567890123",
+      mimeType: "image/png",
+      data: "iVBORw0KGgo=",
+    };
+    expect(extractAssetHash(msg)).toBe("abc1234567890123");
+  });
+
+  it("extension→server asset_register carries the same shape", () => {
+    const msg: AssetRegisterMessage = {
+      type: "asset_register",
+      sessionId: "s1",
+      hash: "abc1234567890123",
+      mimeType: "image/svg+xml",
+      data: "PHN2Zy8+",
+    };
+    expect(msg.type).toBe("asset_register");
+    expect(msg.hash).toBe("abc1234567890123");
+    expect(msg.mimeType).toBe("image/svg+xml");
+  });
+});

package/packages/shared/src/__tests__/config.test.ts

@@ -471,3 +471,51 @@ describe("loadConfig reattachPlacement", () => {
     expect(content.reattachPlacement).toBeUndefined();
   });
 });
+
+describe("loadConfig spawnRegisterTimeoutMs", () => {
+  let testDir: string;
+  let configFile: string;
+  let origHome: string;
+
+  beforeEach(() => {
+    testDir = path.join(os.tmpdir(), `test-config-srt-${Date.now()}`);
+    fs.mkdirSync(path.join(testDir, ".pi", "dashboard"), { recursive: true });
+    configFile = path.join(testDir, ".pi", "dashboard", "config.json");
+    origHome = process.env.HOME!;
+    process.env.HOME = testDir;
+  });
+
+  afterEach(() => {
+    process.env.HOME = origHome;
+    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true });
+  });
+
+  it("defaults to 30000 when field is omitted", () => {
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(30000);
+  });
+
+  it("preserves in-range value", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: 45000 }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(45000);
+  });
+
+  it("clamps below-range value to 5000", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: 1000 }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(5000);
+  });
+
+  it("clamps above-range value to 120000", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: 999999 }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(120000);
+  });
+
+  it("falls back to default for non-number string", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: "thirty" }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(30000);
+  });
+
+  it("falls back to default for null", () => {
+    fs.writeFileSync(configFile, JSON.stringify({ spawnRegisterTimeoutMs: null }));
+    expect(loadConfig().spawnRegisterTimeoutMs).toBe(30000);
+  });
+});

package/packages/shared/src/__tests__/dashboard-starter.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { parseDashboardStarter } from "../dashboard-starter.js";
+
+describe("parseDashboardStarter", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns Standalone when env is empty object", () => {
+    expect(parseDashboardStarter({})).toBe("Standalone");
+  });
+
+  it("returns Standalone when DASHBOARD_STARTER is undefined", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: undefined })).toBe("Standalone");
+  });
+
+  it("returns Standalone when DASHBOARD_STARTER is empty string", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "" })).toBe("Standalone");
+  });
+
+  it("returns Bridge for valid value", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "Bridge" })).toBe("Bridge");
+  });
+
+  it("returns Standalone for valid value", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "Standalone" })).toBe("Standalone");
+  });
+
+  it("returns Electron for valid value", () => {
+    expect(parseDashboardStarter({ DASHBOARD_STARTER: "Electron" })).toBe("Electron");
+  });
+
+  it("returns Standalone and warns on invalid value", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const result = parseDashboardStarter({ DASHBOARD_STARTER: "bogus" });
+    expect(result).toBe("Standalone");
+    expect(warnSpy).toHaveBeenCalledOnce();
+    expect(warnSpy.mock.calls[0]![0]).toContain("bogus");
+  });
+});

package/packages/shared/src/__tests__/detached-spawn.test.ts

@@ -61,6 +61,30 @@ describe("spawnDetached", () => {
     rmSync(path.dirname(logPath), { recursive: true, force: true });
   });
 
+  // See change: fix-electron-extracted-jiti-and-stdio-capture.
+  it("redirects BOTH stdout and stderr to logFd when provided", async () => {
+    const logPath = tmpLog();
+    const fd = openSync(logPath, "a");
+    try {
+      const r = await spawnDetached({
+        cmd: process.execPath,
+        args: [
+          "-e",
+          "console.log('STDOUT-LINE'); process.stderr.write('STDERR-LINE'); setTimeout(() => process.exit(0), 100)",
+        ],
+        logFd: fd,
+      });
+      expect(r.ok).toBe(true);
+      await new Promise((res) => r.process!.once("exit", res));
+    } finally {
+      try { closeSync(fd); } catch { /* ignore */ }
+    }
+    const content = readFileSync(logPath, "utf-8");
+    expect(content).toContain("STDOUT-LINE");
+    expect(content).toContain("STDERR-LINE");
+    rmSync(path.dirname(logPath), { recursive: true, force: true });
+  });
+
   it("does not keep parent event loop alive (unref)", async () => {
     // Can only check behaviour indirectly: the returned pid/process exist
     // and the child is running detached. Lifecycle survival is covered by

package/packages/shared/src/__tests__/doctor-core.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Doctor core — section assignment, suggestion taxonomy, and the
+ * Decision-8 lint (every non-ok check has non-empty
+ * message/detail/suggestion). See change: doctor-rich-output.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  SECTION_OF,
+  SUGGESTIONS,
+  stampSectionsAndSuggestions,
+  type DoctorCheck,
+  type DoctorStatus,
+} from "../doctor-core.js";
+
+const ALL_CHECK_NAMES = Object.keys(SECTION_OF);
+
+describe("SECTION_OF", () => {
+  it("maps every canonical check name to one of the five sections", () => {
+    const allowed = new Set(["runtime", "pi-tooling", "server", "setup", "diagnostics"]);
+    for (const name of ALL_CHECK_NAMES) {
+      expect(allowed.has(SECTION_OF[name])).toBe(true);
+    }
+  });
+
+  it("covers all five sections (none empty)", () => {
+    const sections = new Set(Object.values(SECTION_OF));
+    for (const s of ["runtime", "pi-tooling", "server", "setup", "diagnostics"]) {
+      expect(sections.has(s as never)).toBe(true);
+    }
+  });
+});
+
+describe("SUGGESTIONS", () => {
+  it("returns undefined for status=ok across every check name", () => {
+    for (const name of ALL_CHECK_NAMES) {
+      const fn = SUGGESTIONS[name];
+      expect(fn).toBeDefined();
+      expect(fn?.("ok")).toBeUndefined();
+    }
+  });
+
+  it("returns a non-empty string for status=error or warning when defined", () => {
+    for (const name of ALL_CHECK_NAMES) {
+      const fn = SUGGESTIONS[name];
+      // Electron is the only one that returns undefined even for non-ok
+      // (because today it never fails). Skip it.
+      if (name === "Electron") continue;
+      const w = fn?.("warning");
+      const e = fn?.("error");
+      expect(typeof w === "string" && w.length > 0).toBe(true);
+      expect(typeof e === "string" && e.length > 0).toBe(true);
+    }
+  });
+
+  it("constrains suggestion text to the allowed Markdown subset", () => {
+    // Allowed: **bold**, single-backtick code, [text](url). Disallow: tables,
+    // headings, fenced blocks, raw HTML.
+    for (const name of ALL_CHECK_NAMES) {
+      const fn = SUGGESTIONS[name];
+      const candidates: (string | undefined)[] = [
+        fn?.("warning"),
+        fn?.("error"),
+        fn?.("error", undefined, "not-found"),
+        fn?.("error", undefined, "permission-denied"),
+        fn?.("error", undefined, "timeout"),
+        fn?.("error", undefined, "non-zero-exit"),
+      ];
+      for (const s of candidates) {
+        if (!s) continue;
+        // No fenced code blocks.
+        expect(/```/.test(s)).toBe(false);
+        // No headings at line start.
+        expect(/^#{1,6}\s/m.test(s)).toBe(false);
+        // No raw HTML tags (closing, self-closing, or with attributes).
+        // Plain `<placeholder>` text is allowed (used as prose).
+        expect(/<\/[a-zA-Z]|<[a-zA-Z][^>]*\s+[^>]+>|<[a-zA-Z][^>]*\/>/.test(s)).toBe(false);
+        // Triple-asterisk or underline for bold not allowed.
+        expect(/\*\*\*|___/.test(s)).toBe(false);
+      }
+    }
+  });
+});
+
+describe("stampSectionsAndSuggestions (Decision 8 lint)", () => {
+  it("stamps section + suggestion on non-ok rows by name", () => {
+    const checks: DoctorCheck[] = [
+      { name: "pi CLI", section: undefined as unknown as never, status: "error", message: "Not found", detail: "Searched PATH" },
+      { name: "System Node.js", section: undefined as unknown as never, status: "ok", message: "v22 at /usr/bin/node" },
+    ];
+    const out = stampSectionsAndSuggestions(checks);
+    expect(out[0].section).toBe("pi-tooling");
+    expect(out[0].suggestion).toBeDefined();
+    expect(out[1].section).toBe("runtime");
+    expect(out[1].suggestion).toBeUndefined();
+  });
+
+  it("every non-ok row produced through stamping has non-empty message + detail + suggestion", () => {
+    const statuses: DoctorStatus[] = ["warning", "error"];
+    for (const name of ALL_CHECK_NAMES) {
+      // Electron suggestion is always undefined (decision-by-design); skip.
+      if (name === "Electron") continue;
+      for (const status of statuses) {
+        const checks: DoctorCheck[] = [
+          {
+            name,
+            section: undefined as unknown as never,
+            status,
+            message: "synthetic message",
+            detail: "synthetic detail",
+          },
+        ];
+        const [stamped] = stampSectionsAndSuggestions(checks);
+        expect(stamped.message.length).toBeGreaterThan(0);
+        expect((stamped.detail ?? "").length).toBeGreaterThan(0);
+        expect((stamped.suggestion ?? "").length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it("does not overwrite an existing suggestion", () => {
+    const checks: DoctorCheck[] = [
+      {
+        name: "pi CLI",
+        section: "pi-tooling",
+        status: "error",
+        message: "x",
+        detail: "y",
+        suggestion: "custom",
+      },
+    ];
+    const out = stampSectionsAndSuggestions(checks);
+    expect(out[0].suggestion).toBe("custom");
+  });
+});

package/packages/shared/src/__tests__/doctor-fault-tolerance.test.ts

@@ -0,0 +1,218 @@
+/**
+ * Doctor fault-tolerance helpers — safeCheck / safeExec / assumedMandatory.
+ * See change: doctor-rich-output (design.md Decision 7).
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import os from "node:os";
+import path from "node:path";
+import { mkdtempSync, rmSync, existsSync, statSync, writeFileSync, readFileSync, chmodSync } from "node:fs";
+
+import {
+  safeCheck,
+  safeExec,
+  assumedMandatory,
+  stripAnsi,
+} from "../doctor-core.js";
+
+describe("stripAnsi", () => {
+  it("removes CSI sequences", () => {
+    expect(stripAnsi("\u001b[31mred\u001b[0m text")).toBe("red text");
+    expect(stripAnsi("\u001b[1;33;40myellow\u001b[m")).toBe("yellow");
+  });
+  it("removes OSC sequences", () => {
+    expect(stripAnsi("\u001b]0;title\u0007hello")).toBe("hello");
+  });
+  it("preserves printable text untouched", () => {
+    expect(stripAnsi("a | b | c\nfoo")).toBe("a | b | c\nfoo");
+  });
+  it("handles empty input", () => {
+    expect(stripAnsi("")).toBe("");
+  });
+});
+
+describe("safeCheck", () => {
+  it("returns the row on success", async () => {
+    const r = await safeCheck("X", "diagnostics", () => ({
+      name: "X",
+      section: "diagnostics",
+      status: "ok",
+      message: "fine",
+    }));
+    expect(r.status).toBe("ok");
+    expect(r.name).toBe("X");
+  });
+
+  it("swallows synchronous throws and returns a fallback row", async () => {
+    const r = await safeCheck("Boom", "runtime", () => {
+      throw new Error("kaboom");
+    });
+    expect(r.status).toBe("error");
+    expect(r.message).toMatch(/Check failed/i);
+    expect(r.detail).toContain("kaboom");
+    expect(r.suggestion?.length ?? 0).toBeGreaterThan(0);
+  });
+
+  it("swallows promise rejections and returns a fallback row", async () => {
+    const r = await safeCheck("Boom", "runtime", async () => {
+      throw new Error("async-boom");
+    });
+    expect(r.status).toBe("error");
+    expect(r.detail).toContain("async-boom");
+  });
+
+  it("never throws even when fn returns a non-DoctorCheck", async () => {
+    // @ts-expect-error — exercising runtime tolerance
+    const r = await safeCheck("X", "runtime", () => null);
+    // The post-pass treats the missing section as the wrapper-provided
+    // default, so we should still get a row of some shape.
+    expect(r).toBeDefined();
+  });
+});
+
+describe("safeExec — error classification", () => {
+  it("classifies ENOENT as not-found", () => {
+    const r = safeExec("definitely-not-a-binary-xyz-1729 --version", { timeoutMs: 2000 });
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      // Some shells/platforms classify the missing executable differently:
+      // POSIX with /bin/sh raises a non-zero shell exit (kind=non-zero-exit),
+      // direct exec gets ENOENT (kind=not-found). Both are acceptable failure
+      // signals for "binary missing".
+      expect(["not-found", "non-zero-exit", "unknown"]).toContain(r.kind);
+    }
+  });
+
+  it("classifies non-zero exits", () => {
+    const r = safeExec(`node -e "process.exit(7)"`, { timeoutMs: 5000 });
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.kind).toBe("non-zero-exit");
+      expect(r.exitCode).toBe(7);
+    }
+  });
+
+  it("captures stderr tail and runs it through stripAnsi", () => {
+    const r = safeExec(
+      `node -e "process.stderr.write('\\u001b[31mboom\\u001b[0m'); process.exit(1)"`,
+      { timeoutMs: 5000 },
+    );
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.stderrTail).toContain("boom");
+      expect(r.stderrTail).not.toContain("\u001b");
+    }
+  });
+
+  it("classifies timeouts and reflects the deadline in the message", () => {
+    const r = safeExec(`node -e "setTimeout(()=>{}, 5000)"`, { timeoutMs: 200 });
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      // Node's execSync timeout typically surfaces as ETIMEDOUT or
+      // SIGTERM signal — both classify as "timeout" in our wrapper.
+      expect(r.kind).toBe("timeout");
+      expect(r.message).toMatch(/0?\s*s/);
+    }
+  });
+
+  it("honours the 15s timeout override (uses it for cold-start probes)", () => {
+    // We don't actually wait 15s; we just verify the wrapper carries the
+    // configured timeoutMs into the SafeExecErr.
+    const r = safeExec(`node -e "process.exit(1)"`, { timeoutMs: 15000 });
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.timeoutMs).toBe(15000);
+    }
+  });
+
+  it("returns ok with stdout on success", () => {
+    const r = safeExec(`node -e "console.log('hi')"`, { timeoutMs: 5000 });
+    expect(r.ok).toBe(true);
+    if (r.ok) {
+      expect(r.stdout.trim()).toBe("hi");
+    }
+  });
+});
+
+describe("assumedMandatory", () => {
+  let tmp: string;
+  beforeEach(() => {
+    tmp = mkdtempSync(path.join(os.tmpdir(), "doctor-am-"));
+  });
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("returns ok value when fn does not throw", () => {
+    const r = assumedMandatory("read-foo", () => 42, { managedDir: tmp });
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.value).toBe(42);
+  });
+
+  it("logs to <managedDir>/doctor.log on throw and surfaces a diagnostics row", () => {
+    const r = assumedMandatory(
+      "read-foo",
+      () => {
+        throw new Error("filesystem-down");
+      },
+      { managedDir: tmp },
+    );
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.row.section).toBe("diagnostics");
+      expect(r.row.status).toBe("error");
+      expect(r.row.name).toMatch(/Doctor internal: read-foo/);
+      expect(r.row.detail).toContain("filesystem-down");
+      expect(r.row.suggestion?.length ?? 0).toBeGreaterThan(0);
+    }
+    const logPath = path.join(tmp, "doctor.log");
+    expect(existsSync(logPath)).toBe(true);
+    const log = readFileSync(logPath, "utf-8").trim();
+    const parsed = JSON.parse(log.split("\n")[0]);
+    expect(parsed.label).toBe("read-foo");
+    expect(parsed.message).toBe("filesystem-down");
+  });
+
+  it("tolerates an unwriteable log file (never propagates)", () => {
+    // Make managedDir read-only — append should fail silently.
+    if (process.platform === "win32") {
+      // chmod semantics on Windows are unreliable; skip.
+      return;
+    }
+    chmodSync(tmp, 0o500);
+    try {
+      const r = assumedMandatory(
+        "x",
+        () => {
+          throw new Error("z");
+        },
+        { managedDir: tmp },
+      );
+      expect(r.ok).toBe(false);
+      // Did not throw.
+    } finally {
+      chmodSync(tmp, 0o700);
+    }
+  });
+
+  it("rotates doctor.log when it exceeds 1 MB", () => {
+    const logPath = path.join(tmp, "doctor.log");
+    // Pre-fill log with > 1 MB of data.
+    writeFileSync(logPath, Buffer.alloc(1.2 * 1024 * 1024, "x".charCodeAt(0)));
+    const beforeSize = statSync(logPath).size;
+    expect(beforeSize).toBeGreaterThan(1024 * 1024);
+
+    assumedMandatory(
+      "rotate-test",
+      () => {
+        throw new Error("trigger");
+      },
+      { managedDir: tmp },
+    );
+
+    const rotated = path.join(tmp, "doctor.log.1");
+    expect(existsSync(rotated)).toBe(true);
+    // The fresh log should be small (just one JSON line).
+    const fresh = statSync(logPath).size;
+    expect(fresh).toBeLessThan(2048);
+  });
+});