@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.0

package/packages/shared/src/__tests__/platform-shell.test.ts

@@ -0,0 +1,74 @@
+/**
+ * Tests for packages/shared/src/platform/shell.ts.
+ * All four platform × env-present/absent branches are exercised via injected
+ * `platform` and `env`. No `process.env` or `process.platform` mutation.
+ * See change: consolidate-platform-handlers.
+ */
+import { describe, it, expect } from "vitest";
+import { detectShell, getTerminalEnvHints } from "../platform/shell.js";
+
+describe("detectShell", () => {
+  it("uses COMSPEC on Windows when present", () => {
+    expect(detectShell({
+      platform: "win32",
+      env: { COMSPEC: "C:\\Windows\\System32\\cmd.exe" },
+    })).toBe("C:\\Windows\\System32\\cmd.exe");
+  });
+
+  it("falls back to powershell.exe on Windows when COMSPEC missing", () => {
+    expect(detectShell({ platform: "win32", env: {} })).toBe("powershell.exe");
+  });
+
+  it("uses SHELL on Linux when present", () => {
+    expect(detectShell({
+      platform: "linux",
+      env: { SHELL: "/bin/zsh" },
+    })).toBe("/bin/zsh");
+  });
+
+  it("falls back to /bin/bash on Linux when SHELL missing", () => {
+    expect(detectShell({ platform: "linux", env: {} })).toBe("/bin/bash");
+  });
+
+  it("uses SHELL on macOS when present", () => {
+    expect(detectShell({
+      platform: "darwin",
+      env: { SHELL: "/bin/zsh" },
+    })).toBe("/bin/zsh");
+  });
+
+  it("falls back to /bin/bash on macOS when SHELL missing", () => {
+    expect(detectShell({ platform: "darwin", env: {} })).toBe("/bin/bash");
+  });
+
+  it("ignores SHELL on Windows (uses COMSPEC path)", () => {
+    // Even if some Windows environment sets SHELL (e.g. Git Bash), the PTY
+    // primitive must use COMSPEC / powershell because that's what node-pty
+    // can actually spawn on win32.
+    expect(detectShell({
+      platform: "win32",
+      env: { SHELL: "/usr/bin/bash" },
+    })).toBe("powershell.exe");
+  });
+});
+
+describe("getTerminalEnvHints", () => {
+  it("adds TERM=cygwin on Windows when TERM is not set", () => {
+    expect(getTerminalEnvHints({ platform: "win32", env: {} })).toEqual({ TERM: "cygwin" });
+  });
+
+  it("leaves TERM alone on Windows when already set", () => {
+    expect(getTerminalEnvHints({
+      platform: "win32",
+      env: { TERM: "xterm-256color" },
+    })).toEqual({});
+  });
+
+  it("adds no hints on Linux", () => {
+    expect(getTerminalEnvHints({ platform: "linux", env: {} })).toEqual({});
+  });
+
+  it("adds no hints on macOS", () => {
+    expect(getTerminalEnvHints({ platform: "darwin", env: {} })).toEqual({});
+  });
+});

package/packages/shared/src/__tests__/process-identify.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Tests for platform/process-identify.ts.
+ *
+ * Uses an injected fake `exec` so we can simulate ps/tasklist output on
+ * any host OS. All tests pass `platform` explicitly.
+ */
+import { describe, it, expect, vi } from "vitest";
+import {
+  findPidByMarker,
+  isProcessLikePi,
+  isPiCommandLine,
+} from "../platform/process-identify.js";
+
+describe("isPiCommandLine", () => {
+  it("matches pi", () => {
+    expect(isPiCommandLine("/usr/bin/pi --mode rpc")).toBe(true);
+  });
+  it("matches node", () => {
+    expect(isPiCommandLine("node cli.js")).toBe(true);
+  });
+  it("matches pi even with path prefixes", () => {
+    expect(isPiCommandLine("/opt/foo/pi --args")).toBe(true);
+  });
+  it("does not match unrelated processes", () => {
+    expect(isPiCommandLine("/bin/bash")).toBe(false);
+    expect(isPiCommandLine("/usr/bin/zsh")).toBe(false);
+  });
+  it("does not match substrings without word boundary", () => {
+    // "pip" and "typescript" must not match pi or node.
+    expect(isPiCommandLine("pip install something")).toBe(false);
+    expect(isPiCommandLine("/usr/bin/typescript-compiler")).toBe(false);
+  });
+});
+
+describe("findPidByMarker", () => {
+  it("Windows returns empty array without execution", () => {
+    const exec = vi.fn(() => "should not be called");
+    const result = findPidByMarker("marker", { platform: "win32", exec: exec as any });
+    expect(result).toEqual([]);
+    expect(exec).not.toHaveBeenCalled();
+  });
+
+  it("Linux parses ps output and filters to sentinel lines", () => {
+    const fakeOutput = [
+      "12345 sh -c tail -f /dev/null | pi --mode rpc session-abc",
+      "67890 grep session-abc",
+      "11111 sleep 2147483647 | pi --mode rpc session-abc",
+      "22222 vim notes-about-session-abc.txt",
+    ].join("\n");
+    const exec = vi.fn(() => fakeOutput) as any;
+    const result = findPidByMarker("session-abc", { platform: "linux", exec });
+    expect(result).toEqual([12345, 11111]);
+  });
+
+  it("macOS parses ps output similarly", () => {
+    const fakeOutput = "99999 tail -f /dev/null | pi --mode rpc s1";
+    const exec = vi.fn(() => fakeOutput) as any;
+    const result = findPidByMarker("s1", { platform: "darwin", exec });
+    expect(result).toEqual([99999]);
+  });
+
+  it("returns empty array when no match", () => {
+    const exec = vi.fn(() => "") as any;
+    const result = findPidByMarker("nothing", { platform: "linux", exec });
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array when exec throws (process dead / permission)", () => {
+    const exec = vi.fn(() => { throw new Error("no such command"); }) as any;
+    const result = findPidByMarker("x", { platform: "linux", exec });
+    expect(result).toEqual([]);
+  });
+
+  it("excludes lines without pi headless sentinels", () => {
+    const fakeOutput = "12345 some-random-process matching-marker-only";
+    const exec = vi.fn(() => fakeOutput) as any;
+    const result = findPidByMarker("matching-marker", { platform: "linux", exec });
+    expect(result).toEqual([]);
+  });
+});
+
+describe("isProcessLikePi", () => {
+  it("Windows returns true unconditionally", () => {
+    const exec = vi.fn(() => "should not be called");
+    expect(isProcessLikePi(1234, { platform: "win32", exec: exec as any })).toBe(true);
+    expect(exec).not.toHaveBeenCalled();
+  });
+
+  it("Linux matches via /proc cmdline", () => {
+    const exec = vi.fn(() => "/usr/bin/node /opt/pi-coding-agent/dist/cli.js") as any;
+    expect(isProcessLikePi(1234, { platform: "linux", exec })).toBe(true);
+  });
+
+  it("Linux does not match non-pi", () => {
+    const exec = vi.fn(() => "/bin/bash") as any;
+    expect(isProcessLikePi(1234, { platform: "linux", exec })).toBe(false);
+  });
+
+  it("macOS uses ps -p -o command=", () => {
+    let capturedCmd = "";
+    const exec = ((cmd: string) => {
+      capturedCmd = cmd;
+      return "node cli.js --mode rpc";
+    }) as any;
+    expect(isProcessLikePi(555, { platform: "darwin", exec })).toBe(true);
+    expect(capturedCmd).toMatch(/ps -p 555 -o command=/);
+  });
+
+  it("returns false when process has exited (exec throws)", () => {
+    const exec = vi.fn(() => { throw new Error("no such process"); }) as any;
+    expect(isProcessLikePi(9999, { platform: "linux", exec })).toBe(false);
+  });
+});

package/packages/shared/src/__tests__/recommended-extensions.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from "vitest";
 import {
+	BUNDLED_EXTENSION_IDS,
 	RECOMMENDED_EXTENSIONS,
 	getRecommendedExtension,
 	getRecommendedByStatus,
@@ -35,18 +36,18 @@ describe("RECOMMENDED_EXTENSIONS manifest", () => {
 		}
 	});
 
-	it("pi-anthropic-messages is marked required and uses SSH git URL", () => {
+	it("pi-anthropic-messages is marked required and uses HTTPS git URL", () => {
 		const entry = getRecommendedExtension("pi-anthropic-messages");
 		expect(entry).toBeDefined();
 		expect(entry?.status).toBe("required");
-		expect(entry?.source).toContain("git@github.com:BlackBeltTechnology/pi-anthropic-messages.git");
+		expect(entry?.source).toContain("https://github.com/BlackBeltTechnology/pi-anthropic-messages.git");
 		expect(entry?.autowired).toBe(true);
 	});
 
-	it("pi-flows uses SSH git URL and registers flow-engine tools", () => {
+	it("pi-flows uses HTTPS git URL and registers flow-engine tools", () => {
 		const entry = getRecommendedExtension("pi-flows");
 		expect(entry).toBeDefined();
-		expect(entry?.source).toBe("git@github.com:BlackBeltTechnology/pi-flows.git");
+		expect(entry?.source).toBe("https://github.com/BlackBeltTechnology/pi-flows.git");
 		expect(entry?.toolsRegistered).toContain("subagent");
 		expect(entry?.toolsRegistered).toContain("flow_write");
 	});
@@ -65,12 +66,12 @@ describe("RECOMMENDED_EXTENSIONS manifest", () => {
 		);
 	});
 
-	it("git-sourced entries use the git@github.com:/.git SSH form", () => {
+	it("git-sourced entries use the https://github.com/.../.git HTTPS form", () => {
 		const gitEntries = RECOMMENDED_EXTENSIONS.filter((e) =>
-			e.source.startsWith("git@github.com:"),
+			e.source.startsWith("https://github.com/"),
 		);
 		for (const entry of gitEntries) {
-			expect(entry.source).toMatch(/^git@github\.com:[^/]+\/[^/]+\.git$/);
+			expect(entry.source).toMatch(/^https:\/\/github\.com\/[^/]+\/[^/]+\.git$/);
 		}
 		expect(gitEntries.map((e) => e.id).sort()).toEqual(
 			["pi-anthropic-messages", "pi-flows"].sort(),
@@ -121,3 +122,35 @@ describe("RecommendedExtension type", () => {
 		expect(entry.id).toBe("x");
 	});
 });
+
+// ── BUNDLED_EXTENSION_IDS manifest (task 2 of bundle-first-party-extensions) ──
+
+describe("BUNDLED_EXTENSION_IDS manifest", () => {
+	it("contains exactly the v0.x initial bundled set", () => {
+		expect([...BUNDLED_EXTENSION_IDS].sort()).toEqual(
+			["pi-anthropic-messages", "pi-flows"].sort(),
+		);
+	});
+
+	it("every bundled id appears in RECOMMENDED_EXTENSIONS", () => {
+		const recommendedIds = new Set(RECOMMENDED_EXTENSIONS.map((e) => e.id));
+		for (const id of BUNDLED_EXTENSION_IDS) {
+			expect(recommendedIds.has(id)).toBe(true);
+		}
+	});
+
+	it("every bundled id has a git-based source (no npm:, no local paths)", () => {
+		for (const id of BUNDLED_EXTENSION_IDS) {
+			const entry = RECOMMENDED_EXTENSIONS.find((e) => e.id === id);
+			expect(entry, `RECOMMENDED_EXTENSIONS missing entry for ${id}`).toBeDefined();
+			const source = entry!.source;
+			const isGit =
+				source.endsWith(".git") ||
+				source.startsWith("git@") ||
+				source.startsWith("git:") ||
+				/^https?:\/\/.+\/.+/.test(source);
+			expect(isGit, `${id} source is not git-based: ${source}`).toBe(true);
+			expect(source.startsWith("npm:"), `${id} must not be an npm source`).toBe(false);
+		}
+	});
+});

package/packages/shared/src/__tests__/resolve-jiti.test.ts

@@ -1,17 +1,53 @@
 import { describe, it, expect } from "vitest";
+import { buildJitiRegisterUrl, resolveJitiImport } from "../resolve-jiti.js";
+
+describe("buildJitiRegisterUrl", () => {
+  // Pure function: given a jiti package.json path, return the file:// URL of
+  // its register hook. The URL contract is the critical invariant — Node's
+  // --import on Windows rejects raw drive-letter paths (parses "C:" as a
+  // URL scheme). See change: fix-windows-server-parity.
+
+  it("returns a file:// URL", () => {
+    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
+    expect(url.startsWith("file://")).toBe(true);
+  });
+
+  it("URL is parseable by new URL() without throwing", () => {
+    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
+    expect(() => new URL(url)).not.toThrow();
+  });
+
+  it("points at lib/jiti-register.mjs under the package dir", () => {
+    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
+    expect(url.endsWith("/lib/jiti-register.mjs")).toBe(true);
+  });
+
+  it("handles Windows drive-letter paths (regression for ERR_UNSUPPORTED_ESM_URL_SCHEME)", () => {
+    // This is the exact shape that crashed pre-fix: a raw path with a
+    // drive letter was passed to `node --import` and Node parsed "B:" as
+    // a URL scheme. A file:// URL sidesteps the parser entirely.
+    const url = buildJitiRegisterUrl("B:\\Dev\\Nodejs\\global\\node_modules\\@mariozechner\\jiti\\package.json");
+    expect(url.startsWith("file:///")).toBe(true);
+    expect(() => new URL(url)).not.toThrow();
+    expect(new URL(url).protocol).toBe("file:");
+    // The drive letter survives as part of the pathname, not as a protocol
+    expect(url.toLowerCase()).toContain("/b:/");
+    expect(url.endsWith("/lib/jiti-register.mjs")).toBe(true);
+  });
+
+});
 
 describe("resolveJitiImport", () => {
-  it("throws with clear error when pi-coding-agent is not resolvable", async () => {
-    // In test context (vitest, not inside pi's jiti loader),
-    // peer deps are not resolvable — should throw
-    const { resolveJitiImport } = await import("../resolve-jiti.js");
+  // Integration-lite: in vitest context (not inside pi's jiti loader),
+  // process.argv[1] points at the test runner, not pi — so peer-dep
+  // resolution fails and the function throws a helpful error. The
+  // URL-contract behavior is covered by buildJitiRegisterUrl above.
 
+  it("throws with clear error when pi-coding-agent is not resolvable", () => {
     expect(() => resolveJitiImport()).toThrow("Cannot find pi's TypeScript loader");
   });
 
-  it("error message mentions pi-coding-agent", async () => {
-    const { resolveJitiImport } = await import("../resolve-jiti.js");
-
+  it("error message mentions pi-coding-agent", () => {
     expect(() => resolveJitiImport()).toThrow("pi-coding-agent");
   });
 });

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

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { createSemaphore } from "../semaphore.js";
+
+function defer<T = void>(): { promise: Promise<T>; resolve: (v: T) => void; reject: (e: any) => void } {
+  let resolve!: (v: T) => void;
+  let reject!: (e: any) => void;
+  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+describe("createSemaphore", () => {
+  it("throws when max < 1", () => {
+    expect(() => createSemaphore(0)).toThrow();
+    expect(() => createSemaphore(-1)).toThrow();
+  });
+
+  it("runs tasks immediately up to the cap", async () => {
+    const sem = createSemaphore(2);
+    const a = defer<string>();
+    const b = defer<string>();
+    const pa = sem.run(() => a.promise);
+    const pb = sem.run(() => b.promise);
+    expect(sem.size()).toBe(2);
+    a.resolve("a");
+    b.resolve("b");
+    expect(await pa).toBe("a");
+    expect(await pb).toBe("b");
+    expect(sem.size()).toBe(0);
+  });
+
+  it("caps concurrency: third task waits", async () => {
+    const sem = createSemaphore(2);
+    const a = defer<string>();
+    const b = defer<string>();
+    const c = defer<string>();
+
+    let cStarted = false;
+    const pa = sem.run(() => a.promise);
+    const pb = sem.run(() => b.promise);
+    const pc = sem.run(() => { cStarted = true; return c.promise; });
+
+    // Wait a microtask for queue placement
+    await Promise.resolve();
+    expect(cStarted).toBe(false);
+    expect(sem.size()).toBe(3); // active + queued
+
+    a.resolve("a");
+    await pa;
+    // c should now be started
+    await Promise.resolve();
+    expect(cStarted).toBe(true);
+    b.resolve("b");
+    c.resolve("c");
+    expect(await pb).toBe("b");
+    expect(await pc).toBe("c");
+  });
+
+  it("FIFO order of queued tasks", async () => {
+    const sem = createSemaphore(1);
+    const order: string[] = [];
+    const blockers = [defer<void>(), defer<void>(), defer<void>()];
+    const ps = blockers.map((d, i) =>
+      sem.run(async () => { order.push(`start-${i}`); await d.promise; order.push(`end-${i}`); }),
+    );
+    await Promise.resolve();
+    blockers[0].resolve(); await ps[0];
+    blockers[1].resolve(); await ps[1];
+    blockers[2].resolve(); await ps[2];
+    expect(order).toEqual(["start-0", "end-0", "start-1", "end-1", "start-2", "end-2"]);
+  });
+
+  it("releases slot on reject so queued tasks still run", async () => {
+    const sem = createSemaphore(1);
+    const failed = sem.run(async () => { throw new Error("boom"); });
+    await expect(failed).rejects.toThrow("boom");
+    const ok = sem.run(async () => "ok");
+    expect(await ok).toBe("ok");
+  });
+
+  it("setMax increases cap and drains queued tasks immediately", async () => {
+    const sem = createSemaphore(1);
+    const a = defer<void>();
+    const b = defer<void>();
+    let bStarted = false;
+    const pa = sem.run(() => a.promise);
+    const pb = sem.run(() => { bStarted = true; return b.promise; });
+    await Promise.resolve();
+    expect(bStarted).toBe(false);
+
+    sem.setMax(2);
+    await Promise.resolve();
+    expect(bStarted).toBe(true);
+
+    a.resolve(); b.resolve();
+    await pa; await pb;
+  });
+
+  it("setMax shrinking does not interrupt in-flight tasks but caps new ones", async () => {
+    const sem = createSemaphore(3);
+    const a = defer<void>();
+    const b = defer<void>();
+    const pa = sem.run(() => a.promise);
+    const pb = sem.run(() => b.promise);
+
+    sem.setMax(1);
+    const c = defer<void>();
+    let cStarted = false;
+    const pc = sem.run(() => { cStarted = true; return c.promise; });
+    await Promise.resolve();
+    expect(cStarted).toBe(false);
+
+    a.resolve(); b.resolve();
+    await pa; await pb;
+    await Promise.resolve();
+    expect(cStarted).toBe(true);
+    c.resolve();
+    await pc;
+  });
+});

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

@@ -0,0 +1,131 @@
+/**
+ * Tests for platform/spawn-mechanism.ts pure selector + argv builders.
+ *
+ * Every test passes `platform` explicitly. Never mutates process.platform.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  selectMechanism,
+  buildWtArgs,
+  sessionFlagsToArgv,
+  type SpawnMechanismContext,
+} from "../platform/spawn-mechanism.js";
+
+function ctx(overrides: Partial<SpawnMechanismContext> = {}): SpawnMechanismContext {
+  return {
+    platform: "linux",
+    userStrategy: "tmux",
+    electronMode: false,
+    available: { tmux: false, wt: false, wslTmux: false },
+    ...overrides,
+  };
+}
+
+describe("selectMechanism", () => {
+  it("electron mode always returns headless", () => {
+    expect(selectMechanism(ctx({ electronMode: true, platform: "win32", available: { tmux: false, wt: true, wslTmux: true } }))).toBe("headless");
+    expect(selectMechanism(ctx({ electronMode: true, platform: "linux", available: { tmux: true, wt: false, wslTmux: false } }))).toBe("headless");
+    expect(selectMechanism(ctx({ electronMode: true, platform: "darwin", available: { tmux: true, wt: false, wslTmux: false } }))).toBe("headless");
+  });
+
+  it("userStrategy headless always returns headless", () => {
+    expect(selectMechanism(ctx({ userStrategy: "headless", platform: "win32", available: { tmux: false, wt: true, wslTmux: true } }))).toBe("headless");
+    expect(selectMechanism(ctx({ userStrategy: "headless", platform: "linux", available: { tmux: true, wt: false, wslTmux: false } }))).toBe("headless");
+  });
+
+  it("Linux with tmux returns tmux", () => {
+    expect(selectMechanism(ctx({ platform: "linux", available: { tmux: true, wt: false, wslTmux: false } }))).toBe("tmux");
+  });
+
+  it("macOS with tmux returns tmux", () => {
+    expect(selectMechanism(ctx({ platform: "darwin", available: { tmux: true, wt: false, wslTmux: false } }))).toBe("tmux");
+  });
+
+  it("Linux without tmux returns headless", () => {
+    expect(selectMechanism(ctx({ platform: "linux", available: { tmux: false, wt: false, wslTmux: false } }))).toBe("headless");
+  });
+
+  it("Windows with wt returns wt", () => {
+    expect(selectMechanism(ctx({ platform: "win32", available: { tmux: false, wt: true, wslTmux: false } }))).toBe("wt");
+  });
+
+  it("Windows with wt AND wsl-tmux prefers wt", () => {
+    expect(selectMechanism(ctx({ platform: "win32", available: { tmux: false, wt: true, wslTmux: true } }))).toBe("wt");
+  });
+
+  it("Windows with only wsl-tmux returns wsl-tmux", () => {
+    expect(selectMechanism(ctx({ platform: "win32", available: { tmux: false, wt: false, wslTmux: true } }))).toBe("wsl-tmux");
+  });
+
+  it("Windows with nothing available returns headless", () => {
+    expect(selectMechanism(ctx({ platform: "win32", available: { tmux: false, wt: false, wslTmux: false } }))).toBe("headless");
+  });
+
+  it("unknown platform falls back to headless", () => {
+    expect(selectMechanism(ctx({ platform: "openbsd" as NodeJS.Platform, available: { tmux: true, wt: false, wslTmux: false } }))).toBe("headless");
+  });
+});
+
+describe("buildWtArgs", () => {
+  it("produces argv in expected order", () => {
+    const argv = buildWtArgs({
+      cwd: "C:\\proj",
+      title: "proj",
+      piArgv: ["C:\\node.exe", "cli.js", "--mode", "rpc"],
+    });
+    expect(argv).toEqual([
+      "-w", "0",
+      "new-tab",
+      "-d", "C:\\proj",
+      "--title", "proj",
+      "--",
+      "C:\\node.exe", "cli.js", "--mode", "rpc",
+    ]);
+  });
+
+  it("preserves cwd with spaces as a single argv element", () => {
+    const argv = buildWtArgs({
+      cwd: "C:\\Users\\Bob's Project (2)",
+      title: "x",
+      piArgv: ["pi"],
+    });
+    expect(argv).toContain("C:\\Users\\Bob's Project (2)");
+    expect(argv.filter(a => a.includes("Bob"))).toHaveLength(1);
+  });
+
+  it("places piArgv after -- sentinel with --fork intact", () => {
+    const argv = buildWtArgs({
+      cwd: "C:\\proj",
+      title: "proj",
+      piArgv: ["node.exe", "cli.js", "--fork", "C:\\x\\session.jsonl"],
+    });
+    const sentinelIdx = argv.indexOf("--");
+    expect(sentinelIdx).toBeGreaterThan(0);
+    expect(argv.slice(sentinelIdx + 1)).toEqual(["node.exe", "cli.js", "--fork", "C:\\x\\session.jsonl"]);
+  });
+
+  it("never includes -p profile flag", () => {
+    const argv = buildWtArgs({ cwd: "C:\\x", title: "y", piArgv: ["pi"] });
+    expect(argv).not.toContain("-p");
+  });
+});
+
+describe("sessionFlagsToArgv", () => {
+  it("returns --session file for continue mode", () => {
+    expect(sessionFlagsToArgv({ sessionFile: "/s/abc.jsonl", mode: "continue" })).toEqual(["--session", "/s/abc.jsonl"]);
+  });
+
+  it("returns --fork file for fork mode", () => {
+    expect(sessionFlagsToArgv({ sessionFile: "C:\\s\\abc.jsonl", mode: "fork" })).toEqual(["--fork", "C:\\s\\abc.jsonl"]);
+  });
+
+  it("returns empty array with no file", () => {
+    expect(sessionFlagsToArgv({})).toEqual([]);
+    expect(sessionFlagsToArgv({ mode: "continue" })).toEqual([]);
+    expect(sessionFlagsToArgv({ mode: "fork" })).toEqual([]);
+  });
+
+  it("returns empty array with file but no mode", () => {
+    expect(sessionFlagsToArgv({ sessionFile: "/s/x.jsonl" })).toEqual([]);
+  });
+});