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

package/packages/server/src/__tests__/event-wiring-providers-list.test.ts

@@ -0,0 +1,87 @@
+/**
+ * End-to-end test: `providers_list` arriving from a (fake) bridge updates
+ * the provider-catalogue cache, and `getAuthStatus()` reflects it.
+ * See change: replace-hardcoded-provider-lists.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { WebSocket } from "ws";
+import { createServer, type DashboardServer } from "../server.js";
+import { _resetForTests, getLatestCatalogue } from "../provider-catalogue-cache.js";
+import { getAuthStatus } from "../provider-auth-storage.js";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+async function connectSession(piPort: number, sessionId: string): Promise<WebSocket> {
+  const ws = new WebSocket(`ws://localhost:${piPort}`);
+  await new Promise<void>((resolve) => {
+    ws.on("open", () => {
+      ws.send(JSON.stringify({
+        type: "session_register",
+        sessionId,
+        cwd: "/tmp",
+        source: "cli",
+      }));
+      ws.send(JSON.stringify({ type: "replay_complete", sessionId }));
+      setTimeout(resolve, 60);
+    });
+  });
+  return ws;
+}
+
+describe("providers_list — server wiring", () => {
+  let server: DashboardServer;
+  let piPort: number;
+  let browserPort: number;
+  let testPort = 19500;
+
+  beforeEach(async () => {
+    _resetForTests();
+    testPort += 2;
+    browserPort = testPort;
+    piPort = testPort + 1;
+    server = await createServer({
+      port: browserPort,
+      piPort,
+      dev: true,
+      autoShutdown: false,
+      shutdownIdleSeconds: 999,
+      tunnel: false,
+      editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server.stop();
+    _resetForTests();
+  });
+
+  it("incoming providers_list updates the cache and is visible via getAuthStatus", async () => {
+    const piWs = await connectSession(piPort, "p1");
+    expect(getLatestCatalogue()).toEqual([]);
+
+    piWs.send(JSON.stringify({
+      type: "providers_list",
+      sessionId: "p1",
+      providers: [
+        { id: "deepseek", displayName: "DeepSeek", hasOAuth: false, configured: false },
+        { id: "fireworks", displayName: "Fireworks", hasOAuth: false, configured: false, envVar: "FIREWORKS_API_KEY" },
+      ],
+    }));
+
+    await wait(80);
+
+    const cached = getLatestCatalogue();
+    expect(cached).toHaveLength(2);
+    expect(cached.map((p) => p.id).sort()).toEqual(["deepseek", "fireworks"]);
+
+    const status = getAuthStatus();
+    const deepseekRow = status.find((r) => r.id === "deepseek");
+    const fireworksRow = status.find((r) => r.id === "fireworks");
+    expect(deepseekRow).toBeDefined();
+    expect(deepseekRow?.flowType).toBe("api_key");
+    expect(fireworksRow?.envVar).toBe("FIREWORKS_API_KEY");
+
+    piWs.close();
+  });
+});

package/packages/server/src/__tests__/has-openspec-dir.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Unit tests for `hasOpenSpecDir` — synchronous spawn-free probe used by
+ * the WS on-connect snapshot to disambiguate "no openspec here" from
+ * "openspec here, polling pending".
+ *
+ * See change: fix-cold-boot-openspec-protocol.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { hasOpenSpecDir } from "../directory-service.js";
+
+describe("hasOpenSpecDir", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "has-openspec-dir-"));
+  });
+
+  afterEach(() => {
+    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("returns true when <cwd>/openspec/changes exists as a directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec", "changes"), { recursive: true });
+    expect(hasOpenSpecDir(tmp)).toBe(true);
+  });
+
+  it("returns false when openspec dir is absent (ENOENT)", () => {
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns false when openspec exists but openspec/changes does not", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns false when openspec/changes is a regular file, not a directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    fs.writeFileSync(path.join(tmp, "openspec", "changes"), "not a dir");
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns false when openspec/changes is a symlink to a non-directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    const target = path.join(tmp, "target.txt");
+    fs.writeFileSync(target, "x");
+    fs.symlinkSync(target, path.join(tmp, "openspec", "changes"));
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns true when openspec/changes is a symlink to a directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    const target = path.join(tmp, "target-dir");
+    fs.mkdirSync(target);
+    fs.symlinkSync(target, path.join(tmp, "openspec", "changes"));
+    expect(hasOpenSpecDir(tmp)).toBe(true);
+  });
+
+  it("returns false for a non-existent cwd", () => {
+    expect(hasOpenSpecDir("/this/path/does/not/exist/__nope__")).toBe(false);
+  });
+});

package/packages/server/src/__tests__/health-shape.test.ts

@@ -0,0 +1,43 @@
+/**
+ * Tests for /api/health response shape after Phase A additions.
+ *
+ * Asserts:
+ *  - `pid` field is present (regression pin).
+ *  - `starter` field is present, defaults to "Standalone".
+ *
+ * Note: the "Standalone default for missing DASHBOARD_STARTER" case is
+ * also covered exhaustively in packages/shared/src/__tests__/dashboard-starter.test.ts.
+ * This test pins the contract at the HTTP layer so a refactor cannot silently
+ * drop either field from the health response.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { createTestServer, type TestServerHandle } from "../test-support/test-server.js";
+
+let handle: TestServerHandle | undefined;
+
+describe("GET /api/health — Phase A shape", () => {
+  afterEach(async () => {
+    if (handle) {
+      try { await handle.stop(); } catch { /* already stopped */ }
+      handle = undefined;
+    }
+  });
+
+  it("includes pid field (regression pin)", async () => {
+    handle = await createTestServer();
+    const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.pid).toBe("number");
+    expect(body.pid).toBe(process.pid);
+  });
+
+  it("includes starter field defaulting to Standalone", async () => {
+    handle = await createTestServer();
+    const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    // When bootstrapState has no starter set, defaults to "Standalone".
+    expect(body.starter).toBe("Standalone");
+  });
+});

package/packages/server/src/__tests__/idle-timer-respects-terminals.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createIdleTimer } from "../idle-timer.js";
+import type { PiGateway } from "../pi-gateway.js";
+import type { ServerConfig } from "../server.js";
+
+// See change: fix-terminal-half-height-dual-mount.
+// Pure unit tests against the idle-timer's predicate-driven gating.
+// Avoids the full-server I/O races that have the auto-shutdown.test.ts
+// suite skipped under fake timers.
+
+function makeConfig(): ServerConfig {
+  return {
+    port: 0,
+    piPort: 0,
+    dev: true,
+    autoShutdown: true,
+    shutdownIdleSeconds: 2,
+    tunnel: false,
+    pingInterval: 0,
+    editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+  } as ServerConfig;
+}
+
+function makeGateway(connectionCount = 0): PiGateway {
+  return {
+    connectionCount: () => connectionCount,
+    onEmpty: undefined,
+    onConnection: undefined,
+  } as unknown as PiGateway;
+}
+
+describe("idle-timer respects active terminals", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("does NOT shut down when one or more terminals are alive", async () => {
+    const gateway = makeGateway(0);
+    let terminalCount = 1;
+    const timer = createIdleTimer(makeConfig(), gateway, () => terminalCount > 0);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    // Advance well past shutdownIdleSeconds.
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(stopFn).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+    exitSpy.mockRestore();
+    timer.cancel();
+  });
+
+  it("shuts down when no pi sessions AND no terminals are alive", async () => {
+    const gateway = makeGateway(0);
+    const timer = createIdleTimer(makeConfig(), gateway, () => false);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    // First tick: realIdleMs is 0 because lastConnectionTimestamp = 0.
+    // The implementation guards on realIdleMs < shutdownIdleSeconds*1000
+    // and restarts; so we need two ticks separated by enough wall time.
+    await vi.advanceTimersByTimeAsync(2000);
+    // After the first tick the timer has restarted; advance again.
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(stopFn).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    exitSpy.mockRestore();
+  });
+
+  it("re-arms (does not shut down) when terminals appear mid-countdown", async () => {
+    const gateway = makeGateway(0);
+    let terminalCount = 0;
+    const timer = createIdleTimer(makeConfig(), gateway, () => terminalCount > 0);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    // Just before the timer fires, a terminal appears.
+    await vi.advanceTimersByTimeAsync(1500);
+    terminalCount = 1;
+    // Let it fire.
+    await vi.advanceTimersByTimeAsync(1500);
+
+    expect(stopFn).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+    exitSpy.mockRestore();
+    timer.cancel();
+  });
+
+  it("default predicate (no terminals) preserves legacy single-arg call site behavior", async () => {
+    // Caller may construct without the third arg; default is () => false.
+    const gateway = makeGateway(0);
+    const timer = createIdleTimer(makeConfig(), gateway);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(stopFn).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    exitSpy.mockRestore();
+  });
+});

package/packages/server/src/__tests__/is-unread-trigger.test.ts

@@ -67,8 +67,10 @@ describe("isUnreadTrigger", () => {
         isUnreadTrigger(
           "agent_end",
           { status: "streaming", currentTool: null },
-          // @ts-expect-error simulating the broader status union
-          { status: "ended", currentTool: null },
+          // The status union is currently "streaming" | "idle" | "active";
+          // "ended" is not in the union but is a valid runtime value
+          // upstream, so we cast for the simulation.
+          { status: "ended" as unknown as "idle", currentTool: null },
         ),
       ).toBe(false);
     });

package/packages/server/src/__tests__/jj-routes.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Unit tests for the jj REST routes module — focused on the pure helpers
+ * (`checkInitColocatedPreconditions`) and validation logic. Full route
+ * integration tests are deferred until the test harness wires up a live
+ * Fastify instance + browserGateway mock.
+ *
+ * See change: add-jj-workspace-plugin.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+
+const { statusPorcelain } = vi.hoisted(() => ({
+  statusPorcelain: vi.fn(),
+}));
+
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/git.js", async () => {
+  const real = await vi.importActual<
+    typeof import("@blackbelt-technology/pi-dashboard-shared/platform/git.js")
+  >("@blackbelt-technology/pi-dashboard-shared/platform/git.js");
+  return { ...real, statusPorcelain };
+});
+
+import { checkInitColocatedPreconditions } from "../routes/jj-routes.js";
+
+describe("checkInitColocatedPreconditions", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "jj-routes-test-"));
+    statusPorcelain.mockReset();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns INVALID_CWD when cwd is empty", () => {
+    expect(checkInitColocatedPreconditions("")?.code).toBe("INVALID_CWD");
+  });
+
+  it("returns INVALID_CWD when cwd does not exist", () => {
+    expect(checkInitColocatedPreconditions("/nonexistent/path/12345")?.code).toBe("INVALID_CWD");
+  });
+
+  it("returns ALREADY_JJ when .jj/ exists", () => {
+    fs.mkdirSync(path.join(tmpDir, ".jj"));
+    expect(checkInitColocatedPreconditions(tmpDir)?.code).toBe("ALREADY_JJ");
+  });
+
+  it("returns NOT_GIT_REPO when neither .jj/ nor .git/ exist", () => {
+    expect(checkInitColocatedPreconditions(tmpDir)?.code).toBe("NOT_GIT_REPO");
+  });
+
+  it("returns DIRTY_INDEX when git status has staged entries", () => {
+    fs.mkdirSync(path.join(tmpDir, ".git"));
+    statusPorcelain.mockReturnValue({
+      ok: true,
+      value: "M  src/foo.ts\nA  src/bar.ts\n",
+    });
+    const result = checkInitColocatedPreconditions(tmpDir);
+    expect(result?.code).toBe("DIRTY_INDEX");
+    expect(result?.message).toContain("2 entries");
+  });
+
+  it("returns null on clean .git/ tree (working-tree dirt is fine)", () => {
+    fs.mkdirSync(path.join(tmpDir, ".git"));
+    // Lines starting with " M" (space then M) are working-tree-only changes.
+    // Lines starting with "??" are untracked files. Both are SAFE per spec
+    // scenario "Init allowed on unstaged dirty working tree".
+    statusPorcelain.mockReturnValue({
+      ok: true,
+      value: " M src/working-tree-mod.ts\n?? src/new-untracked.ts\n",
+    });
+    expect(checkInitColocatedPreconditions(tmpDir)).toBeNull();
+  });
+
+  it("returns null on totally clean tree", () => {
+    fs.mkdirSync(path.join(tmpDir, ".git"));
+    statusPorcelain.mockReturnValue({ ok: true, value: "" });
+    expect(checkInitColocatedPreconditions(tmpDir)).toBeNull();
+  });
+
+  it("returns null when statusPorcelain itself fails (defensive: don't refuse on probe error)", () => {
+    fs.mkdirSync(path.join(tmpDir, ".git"));
+    statusPorcelain.mockReturnValue({
+      ok: false,
+      error: { kind: "not-found", binary: "git" },
+    });
+    expect(checkInitColocatedPreconditions(tmpDir)).toBeNull();
+  });
+});

package/packages/server/src/__tests__/openspec-connect-snapshot.test.ts

@@ -0,0 +1,92 @@
+/**
+ * On-connect snapshot semantics: emits exactly one `openspec_update`
+ * per known cwd, with correct `pending` value.
+ *
+ * See change: fix-cold-boot-openspec-protocol.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { buildOpenSpecConnectSnapshot } from "../browser-gateway.js";
+import type { OpenSpecData } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+function ds(map: Record<string, OpenSpecData | undefined>) {
+  return {
+    knownDirectories: vi.fn(() => Object.keys(map)),
+    getOpenSpecData: vi.fn((cwd: string) => map[cwd]),
+  };
+}
+
+describe("buildOpenSpecConnectSnapshot", () => {
+  it("emits cached payload for cwds with initialized data (no pending field)", () => {
+    const cached: OpenSpecData = { initialized: true, changes: [{ name: "x" } as never] };
+    const msgs = buildOpenSpecConnectSnapshot(ds({ "/p": cached }), () => true);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toEqual({ type: "openspec_update", cwd: "/p", data: cached });
+  });
+
+  it("emits pending: true when openspec dir exists but cache is empty", () => {
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds({ "/p": { initialized: false, changes: [] } }),
+      (cwd) => cwd === "/p",
+    );
+    expect(msgs).toEqual([
+      {
+        type: "openspec_update",
+        cwd: "/p",
+        data: { initialized: false, pending: true, changes: [] },
+      },
+    ]);
+  });
+
+  it("emits pending: true when openspec dir exists but cache is undefined", () => {
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds({ "/p": undefined }),
+      () => true,
+    );
+    expect(msgs).toEqual([
+      {
+        type: "openspec_update",
+        cwd: "/p",
+        data: { initialized: false, pending: true, changes: [] },
+      },
+    ]);
+  });
+
+  it("emits pending: false when no openspec dir exists", () => {
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds({ "/p": undefined }),
+      () => false,
+    );
+    expect(msgs).toEqual([
+      {
+        type: "openspec_update",
+        cwd: "/p",
+        data: { initialized: false, pending: false, changes: [] },
+      },
+    ]);
+  });
+
+  it("emits exactly one message per known cwd, mixed states preserved", () => {
+    const cached: OpenSpecData = { initialized: true, changes: [{ name: "x" } as never] };
+    const map = { "/hot": cached, "/cold": undefined, "/none": undefined };
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds(map),
+      (cwd) => cwd === "/cold",
+    );
+    expect(msgs).toHaveLength(3);
+    expect(msgs[0]).toEqual({ type: "openspec_update", cwd: "/hot", data: cached });
+    expect(msgs[1]).toEqual({
+      type: "openspec_update",
+      cwd: "/cold",
+      data: { initialized: false, pending: true, changes: [] },
+    });
+    expect(msgs[2]).toEqual({
+      type: "openspec_update",
+      cwd: "/none",
+      data: { initialized: false, pending: false, changes: [] },
+    });
+  });
+
+  it("returns empty array when there are no known directories", () => {
+    expect(buildOpenSpecConnectSnapshot(ds({}), () => true)).toEqual([]);
+  });
+});

package/packages/server/src/__tests__/openspec-tasks-parser.test.ts

@@ -69,6 +69,53 @@ describe("parseTasksMarkdown", () => {
     const tasks = parseTasksMarkdown("- [ ] 1.1 Loose task");
     expect(tasks[0].group).toBe("");
   });
+
+  // ─── relax-tasks-parser-id-optional ───────────────────────────────────────
+  // The parser MUST accept top-level checkboxes with or without a `1.1`-style
+  // numeric id prefix. Id-less lines get a synthesized `L<line>` id.
+
+  it("parses id-less checkboxes with synthesized L<line> ids", () => {
+    const md = [
+      "## 1. Workflow matrix", // line 1
+      "",                       // line 2
+      "- [ ] Verify runner image",  // line 3
+      "- [x] Add matrix row",       // line 4
+    ].join("\n");
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toEqual([
+      { id: "L3", text: "Verify runner image", done: false, line: 3, group: "1. Workflow matrix" },
+      { id: "L4", text: "Add matrix row", done: true, line: 4, group: "1. Workflow matrix" },
+    ]);
+  });
+
+  it("parses files mixing id-ed and id-less checkboxes", () => {
+    const md = [
+      "## 1. Mix",          // 1
+      "",                    // 2
+      "- [ ] 1.1 Has id",   // 3
+      "- [x] No id here",   // 4
+      "- [ ] 1.3 Skipped 1.2 on purpose", // 5
+    ].join("\n");
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toEqual([
+      { id: "1.1", text: "Has id", done: false, line: 3, group: "1. Mix" },
+      { id: "L4", text: "No id here", done: true, line: 4, group: "1. Mix" },
+      { id: "1.3", text: "Skipped 1.2 on purpose", done: false, line: 5, group: "1. Mix" },
+    ]);
+  });
+
+  it("still ignores indented checkboxes (id-less or id-ed)", () => {
+    const md = [
+      "## G",
+      "  - [ ] indented id-less",
+      "  - [ ] 1.1 indented id-ed",
+      "- [ ] top-level id-less",
+    ].join("\n");
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].id).toBe("L4");
+    expect(tasks[0].text).toBe("top-level id-less");
+  });
 });
 
 describe("readTasks + toggleTask (writer)", () => {
@@ -175,4 +222,71 @@ describe("readTasks + toggleTask (writer)", () => {
     const after = fs.readFileSync(tasksFile, "utf-8");
     expect(after).toBe(weirdMd.replace("- [ ] 1.1 Task one", "- [x] 1.1 Task one"));
   });
+
+  // ─── relax-tasks-parser-id-optional ───────────────────────────────────────
+
+  describe("id-less round-trip", () => {
+    const idlessMd = [
+      "## 1. Workflow matrix",     // 1
+      "",                            // 2
+      "- [ ] Verify runner image",  // 3
+      "- [x] Add matrix row",       // 4
+      "",                            // 5
+      "## 2. Verify rename behavior", // 6
+      "- [ ] Inspect releases",      // 7
+    ].join("\n");
+
+    beforeEach(() => {
+      fs.writeFileSync(tasksFile, idlessMd, "utf-8");
+    });
+
+    it("toggle ticks an id-less task addressed by L<line>, no synthetic id leaks into the file", async () => {
+      const result = await toggleTask(tmpDir, CWD_CHANGE[1], "L3", true, 3);
+      expect(result).toEqual({
+        id: "L3",
+        text: "Verify runner image",
+        done: true,
+        line: 3,
+        group: "1. Workflow matrix",
+      });
+      const after = fs.readFileSync(tasksFile, "utf-8");
+      // CRITICAL: line shape preserved — no "L3" appears in the file body
+      expect(after).toBe(idlessMd.replace("- [ ] Verify runner image", "- [x] Verify runner image"));
+      expect(after).not.toContain("L3");
+    });
+
+    it("toggle unticks an id-less task addressed by L<line>", async () => {
+      const result = await toggleTask(tmpDir, CWD_CHANGE[1], "L4", false, 4);
+      expect(result.done).toBe(false);
+      const after = fs.readFileSync(tasksFile, "utf-8");
+      expect(after).toBe(idlessMd.replace("- [x] Add matrix row", "- [ ] Add matrix row"));
+      expect(after).not.toContain("L4");
+    });
+
+    it("toggle of id-less line with wrong synthesized id throws LineMismatchError", async () => {
+      // Line 3 is id-less; passing L99 (or any other L<n>) must reject
+      await expect(toggleTask(tmpDir, CWD_CHANGE[1], "L99", true, 3)).rejects.toBeInstanceOf(
+        LineMismatchError,
+      );
+      expect(fs.readFileSync(tasksFile, "utf-8")).toBe(idlessMd);
+    });
+
+    it("toggle of id-less line with a numeric-style id throws LineMismatchError", async () => {
+      // Line 3 has no numeric id; passing "1.1" must reject
+      await expect(toggleTask(tmpDir, CWD_CHANGE[1], "1.1", true, 3)).rejects.toBeInstanceOf(
+        LineMismatchError,
+      );
+      expect(fs.readFileSync(tasksFile, "utf-8")).toBe(idlessMd);
+    });
+
+    it("toggle of id-ed line addressed by L<n> throws LineMismatchError", async () => {
+      // Switch fixture to id-ed for this case
+      fs.writeFileSync(tasksFile, initialMd, "utf-8");
+      // Line 3 has id "1.1"; addressing it as "L3" must reject
+      await expect(toggleTask(tmpDir, CWD_CHANGE[1], "L3", true, 3)).rejects.toBeInstanceOf(
+        LineMismatchError,
+      );
+      expect(fs.readFileSync(tasksFile, "utf-8")).toBe(initialMd);
+    });
+  });
 });