import { mkdir, readFile, writeFile } from "node:fs/promises";
import { test, expect } from "@playwright/test";
import {
  channelStage,
  generateReport,
  pathExists,
  readJson,
  resetData,
  resolvePath,
  writeSettings,
} from "./helpers";
import { baseUrl } from "./baseUrl";

// End-to-end coverage for the automatic priority-queue runner
// (common/controller/autoRunner.ts). Uses the fake-whisper fixture (wired via
// WHISPER_BIN in dev:test) so transcriptions complete near-instantly, a single
// worker + maxWorkers:1 so picks are fully serialized and deterministic, and the
// runner's pick log (/api/auto-queue/status) to assert the cross-channel order
// the policy produced. The pure selection rules are unit-tested in
// common/jobs/autoQueuePolicy.test.ts; this proves the runner actually drives
// transcriptions in that order across channels.

type Leaf = {
  id: string;
  match: { type: string; value?: string; bucket?: string; operation?: string };
  weight?: number;
  maxWorkers?: number | null;
};
type Group = {
  id: string;
  mode: string;
  children: (Group | Leaf)[];
  maxWorkers?: number | null;
};

// One enabled local worker using the fake whisper engine.
const ONE_WORKER = [
  {
    id: "w1",
    name: "W1",
    kind: "local",
    enabled: true,
    priority: 0,
    appId: "whisper-cpp",
    config: {},
  },
];

// Two enabled local workers; tests can then disable one via a saved default.
const TWO_WORKERS = [
  { id: "gpu", name: "GPU", kind: "local", enabled: true, priority: 0, appId: "whisper-cpp", config: {} },
  { id: "cpu", name: "CPU", kind: "local", enabled: true, priority: 1, appId: "whisper-cpp", config: {} },
];

async function makeChannel(slug: string, ids: string[]) {
  const root = resolvePath(`test-transcripts/channels/${slug}`);
  await mkdir(`${root}/data`, { recursive: true });
  await writeFile(
    `${root}/config.json`,
    JSON.stringify({
      handling: "transcribe",
      name: slug,
      url: `https://example.com/@${slug}`,
      audioFormat: "mp3",
    }),
  );
  for (const id of ids) {
    await mkdir(`${root}/data/${id}`, { recursive: true });
    await writeFile(`${root}/data/${id}/audio.mp3`, `fake audio ${id}\n`);
  }
  // Seed a static snapshot so the runner sees these as downloaded-no-transcript.
  await writeFile(
    `${root}/snapshot.json`,
    JSON.stringify({
      generatedAt: "2026-06-01T00:00:00.000Z",
      totals: { videos: ids.length, transcribed: 0, downloaded: ids.length },
      buckets: {
        noTranscript: [],
        downloadedNoTranscript: ids,
        untranscoded: [],
        multipleAudioFormats: [],
        transcribedWithAudio: [],
        untranscribable: [],
        noMetadata: [],
        failedListed: [],
        missingFromArchive: [],
        duplicateDirs: [],
        partialDownloads: [],
        corruptSource: [],
        nonStandardVtt: [],
        skippedByFilter: [],
      },
      undownloadedIds: [],
    }),
  );
}

function transcriptionAutoQueue(root: Group, maxWorkers: number | null = 1) {
  return { transcription: { enabled: true, maxWorkers, root }, download: {} };
}

function downloadAutoQueue(root: Group, maxWorkers: number | null = null) {
  return { transcription: {}, download: { enabled: true, maxWorkers, root } };
}

// A YouTube channel with undownloaded videos: a playlist of watch URLs whose ids
// match, and a snapshot listing them as undownloadedIds. Same platform for both
// channels so the runner's per-platform gate serializes downloads → a
// deterministic cross-channel order.
async function makeDownloadChannel(slug: string, ids: string[]) {
  const root = resolvePath(`test-transcripts/channels/${slug}`);
  await mkdir(`${root}/data`, { recursive: true });
  await writeFile(
    `${root}/config.json`,
    JSON.stringify({
      handling: "youtube",
      name: slug,
      url: `https://www.youtube.com/@${slug}/videos`,
    }),
  );
  await writeFile(
    `${root}/playlist`,
    ids.map((id) => `https://www.youtube.com/watch?v=${id}`).join("\n") + "\n",
  );
  await writeFile(
    `${root}/snapshot.json`,
    JSON.stringify({
      generatedAt: "2026-06-01T00:00:00.000Z",
      totals: { videos: ids.length, transcribed: 0, downloaded: 0 },
      buckets: {
        noTranscript: [],
        downloadedNoTranscript: [],
        untranscoded: [],
        multipleAudioFormats: [],
        transcribedWithAudio: [],
        untranscribable: [],
        noMetadata: [],
        failedListed: [],
        missingFromArchive: [],
        duplicateDirs: [],
        partialDownloads: [],
        corruptSource: [],
        nonStandardVtt: [],
        skippedByFilter: [],
      },
      undownloadedIds: ids,
    }),
  );
}

async function startRunner(
  request: import("@playwright/test").APIRequestContext,
  kind: "transcription" | "download" = "transcription",
) {
  const res = await request.post(`${baseUrl}/api/auto-queue/control`, {
    // Behind the ops token since release 19 (A3): it starts and stops lanes.
    headers: { authorization: "Bearer test-worker-token" },
    data: { kind, action: "start" },
  });
  expect(res.ok()).toBeTruthy();
  return res.json();
}

async function stopRunner(
  request: import("@playwright/test").APIRequestContext,
  kind: "transcription" | "download" = "transcription",
) {
  await request.post(`${baseUrl}/api/auto-queue/control`, {
    // Behind the ops token since release 19 (A3): it starts and stops lanes.
    headers: { authorization: "Bearer test-worker-token" },
    data: { kind, action: "stop" },
  });
}

type KindStatus = {
  runner: {
    running: boolean;
    jobId: string | null;
    idleReason: string | null;
  };
  policy: { order?: string; snoozeUntil?: number | null };
  pendingByLeaf: Record<string, number>;
  pendingHeadByLeaf: Record<string, string[]>;
  nextUp: { videoId: string; leafId: string } | null;
  picks: { leafId: string; videoId: string; channelSlug: string }[];
};
type Status = { transcription: KindStatus; download: KindStatus };

async function getStatus(
  request: import("@playwright/test").APIRequestContext,
): Promise<Status> {
  const res = await request.get(`${baseUrl}/api/auto-queue/status`);
  expect(res.ok()).toBeTruthy();
  return res.json();
}

// Chronological pick order (the status log is newest-first).
function pickOrder(
  status: Status,
  kind: "transcription" | "download" = "transcription",
): string[] {
  return status[kind].picks.map((p) => p.videoId).reverse();
}

async function allTranscribed(slug: string, ids: string[]): Promise<boolean> {
  for (const id of ids) {
    if (
      !(await pathExists(`test-transcripts/channels/${slug}/data/${id}/transcript.json`))
    ) {
      return false;
    }
  }
  return true;
}

test.afterEach(async ({ request }) => {
  // Stop any runner left from a test so its loop can't bleed into the next spec.
  await stopRunner(request, "transcription");
  await stopRunner(request, "download");
});

test("strict priority: drains the high-priority channel first, then falls back", async ({
  request,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2"]);
  await makeChannel("beta", ["b1", "b2"]);

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [
      { id: "leaf-alpha", match: { type: "channel", value: "alpha" } },
      { id: "leaf-beta", match: { type: "channel", value: "beta" } },
    ],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(root),
  });

  await startRunner(request);

  await expect
    .poll(async () => (await getStatus(request)).transcription.picks.length, {
      timeout: 60_000,
    })
    .toBe(4);

  // Every alpha video is picked before any beta video, and in-channel order
  // holds. THIS is what the test is about, and it stays an exact assertion.
  expect(pickOrder(await getStatus(request))).toEqual(["a1", "a2", "b1", "b2"]);

  // The transcripts are POLLED, not asserted outright. A pick is recorded when
  // the runner hands work out; a transcript appears when that work finishes, so
  // the fourth pick is observable before the fourth transcript is written — and
  // asserting instantly is a ~1-in-3 race under load, which is how this landed
  // red. Polling does not weaken the claim: all four transcripts must still
  // exist, and the ordering assertion above is untouched.
  await expect
    .poll(
      async () =>
        (await allTranscribed("alpha", ["a1", "a2"])) &&
        (await allTranscribed("beta", ["b1", "b2"])),
      { timeout: 30_000 },
    )
    .toBe(true);
});

test("respects the saved worker default: a disabled worker is never used", async ({
  request,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2", "a3", "a4"]);

  // Both workers are enabled in settings, but the saved default
  // (.worker-defaults.json) enables only gpu — cpu must stay disabled, and the
  // runner must honor that (regression for the boot-time reconfigure() bug that
  // bypassed applyDefaults()).
  await mkdir(resolvePath("test-transcripts/.workers"), { recursive: true });
  await writeFile(
    resolvePath("test-transcripts/.workers/defaults.json"),
    JSON.stringify({ enabledWorkerIds: ["gpu"] }),
  );

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: TWO_WORKERS,
    // No runner cap, so without the fix the runner would use BOTH workers.
    autoQueue: transcriptionAutoQueue(root, null),
  });

  await startRunner(request);

  const ids = ["a1", "a2", "a3", "a4"];
  await expect
    .poll(async () => allTranscribed("alpha", ids), { timeout: 60_000 })
    .toBe(true);

  // Every transcription ran on gpu — cpu (disabled by the saved default) was never used.
  for (const id of ids) {
    const outcome = await readJson<{ worker?: { id?: string } }>(
      `test-transcripts/channels/alpha/data/${id}/transcribe-outcome.json`,
    );
    expect(outcome.worker?.id).toBe("gpu");
  }
});

test("round-robin: alternates between the two channels", async ({ request }) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2"]);
  await makeChannel("beta", ["b1", "b2"]);

  const root: Group = {
    id: "root",
    mode: "round-robin",
    children: [
      { id: "leaf-alpha", match: { type: "channel", value: "alpha" } },
      { id: "leaf-beta", match: { type: "channel", value: "beta" } },
    ],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(root),
  });

  await startRunner(request);

  await expect
    .poll(async () => (await getStatus(request)).transcription.picks.length, {
      timeout: 60_000,
    })
    .toBe(4);

  // SWRR with equal weights interleaves the channels: a, b, a, b.
  const order = pickOrder(await getStatus(request));
  expect(order).toEqual(["a1", "b1", "a2", "b2"]);
});

test("UI: build a policy in the editor, save it, and start the runner", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2"]);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: {
      transcription: {
        enabled: false,
        maxWorkers: 1,
        root: { id: "root", mode: "strict", children: [] },
      },
      download: {},
    },
  });

  await page.goto("/operations/transcription");
  await expect(
    page.getByRole("heading", { name: "Transcription", exact: true }),
  ).toBeVisible();
  // Scope to the Auto-transcribe section. There is exactly one runner section
  // per page now — the lane <select> is gone — but the scoping stays, because
  // it is what keeps every locator in this suite unambiguous.
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });
  await expect(section.getByText("Runner stopped")).toBeVisible();
  await awaitHydration(section);

  // Add a channel rule and point it at alpha.
  await section.getByRole("button", { name: "+ Channel rule" }).click();
  await section.getByLabel("channel rule value").selectOption("alpha");
  // Enable and save.
  await section.getByLabel(/Enable auto-transcribe/).check();
  await section.getByRole("button", { name: "Save policy" }).click();
  await expect(section.getByText("Saved.")).toBeVisible();

  // The policy persisted to settings.
  const settings = await readJson<{
    autoQueue: { transcription: { enabled: boolean; root: { children: { match?: { value?: string } }[] } } };
  }>("test-settings.json");
  expect(settings.autoQueue.transcription.enabled).toBe(true);
  expect(
    settings.autoQueue.transcription.root.children.some(
      (c) => c.match?.value === "alpha",
    ),
  ).toBe(true);

  // Start the runner from the UI; it should transcribe alpha's videos.
  //
  // Clicked ONLY IF IT IS STILL OFFERED. Saving an enabled policy starts the
  // runner itself (saveAutoQueueAction calls startAutoRunner), so Start is
  // disabled the moment the 3-second poll notices — and an unconditional click
  // is a race against that poll, not an assertion about anything. The claim
  // here is that the runner ends up RUNNING and does the work, not that one
  // particular button was what started it, so both halves are asserted
  // directly.
  const start = section.getByRole("button", { name: "Start Auto-transcribe" });
  if (await start.isEnabled()) await start.click();
  await expect(section.getByText("Runner running")).toBeVisible({
    timeout: 20_000,
  });
  await expect
    .poll(async () => allTranscribed("alpha", ["a1", "a2"]), { timeout: 60_000 })
    .toBe(true);
});

test("UI: Move to top jumps a rule to the front of its siblings", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", []);
  await makeChannel("beta", []);
  await makeChannel("gamma", []);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: {
      transcription: {
        enabled: false,
        maxWorkers: 1,
        root: { id: "root", mode: "strict", children: [] },
      },
      download: {},
    },
  });

  await page.goto("/operations/transcription");
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });

  await awaitHydration(section);

  // Add three channel rules pointing at alpha, beta, gamma (in that order).
  for (const slug of ["alpha", "beta", "gamma"]) {
    await section.getByRole("button", { name: "+ Channel rule" }).click();
    const values = section.getByLabel("channel rule value");
    await values.last().selectOption(slug);
  }

  // Move the last rule (gamma) straight to the top.
  const topButtons = section.getByRole("button", { name: "Move to top" });
  await topButtons.last().click();

  await section.getByLabel(/Enable auto-transcribe/).check();
  await section.getByRole("button", { name: "Save policy" }).click();
  await expect(section.getByText("Saved.")).toBeVisible();

  // gamma is now first in the persisted sibling order.
  const settings = await readJson<{
    autoQueue: {
      transcription: { root: { children: { match?: { value?: string } }[] } };
    };
  }>("test-settings.json");
  expect(
    settings.autoQueue.transcription.root.children.map((c) => c.match?.value),
  ).toEqual(["gamma", "alpha", "beta"]);
});

test("status: reports the runner running and snapshot-derived pending counts", async ({
  request,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2", "a3"]);

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
  };
  // No workers enabled -> the runner has zero eligible slots, so it parks and
  // launches nothing, leaving the pending count observable and stable.
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: [],
    autoQueue: transcriptionAutoQueue(root, null),
  });

  await startRunner(request);

  await expect
    .poll(async () => (await getStatus(request)).transcription.runner.running, {
      timeout: 15_000,
    })
    .toBe(true);

  const status = await getStatus(request);
  expect(status.transcription.pendingByLeaf["leaf-alpha"]).toBe(3);
  // With no eligible workers nothing should have been picked.
  expect(status.transcription.picks.length).toBe(0);
});

test("/jobs: the runner shows in its own labeled section, not Other", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2"]);
  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(root),
  });

  // Start the perpetual runner; it stays "running" (active) even once idle.
  await page.request.post(`${baseUrl}/api/auto-queue/control`, {
    // Behind the ops token since release 19 (A3): it starts and stops lanes.
    headers: { authorization: "Bearer test-worker-token" },
    data: { kind: "transcription", action: "start" },
  });

  await page.goto("/jobs");
  await expect(
    page.getByRole("heading", { name: "Auto-transcribe" }),
  ).toBeVisible();
  // The runner is no longer dumped under a generic "Other" section.
  await expect(page.getByRole("heading", { name: "Other" })).toHaveCount(0);
});

const IDLE_SETTINGS = (root: Group) => ({
  adminTitle: "Test Admin",
  maxTranscriptPageBytes: 8388608,
  sleepBetweenDownloadsSeconds: 0,
  minFreeDiskGB: 0,
  workers: ONE_WORKER,
  autoQueue: transcriptionAutoQueue(root),
});

const ALPHA_ROOT: Group = {
  id: "root",
  mode: "strict",
  children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
};

async function runnerRunning(
  request: import("@playwright/test").APIRequestContext,
): Promise<boolean> {
  return (await getStatus(request)).transcription.runner.running;
}

test("/jobs: Drain and Cancel buttons work on the runner job", async ({
  page,
  request,
}) => {
  await resetData(null);
  await makeChannel("alpha", []); // enabled but no pending work -> idle/running
  await writeSettings(IDLE_SETTINGS(ALPHA_ROOT));
  await startRunner(request);

  await page.goto("/jobs");
  const section = page.locator(
    "section[aria-label='System jobs: Auto-transcribe']",
  );
  await expect(section.getByRole("button", { name: "Drain" })).toBeVisible();
  await expect(section.getByRole("button", { name: /^Cancel$/ })).toBeVisible();

  // Drain stops the (idle) runner — the job ends and leaves the active list.
  await section.getByRole("button", { name: "Drain" }).click();
  await expect.poll(() => runnerRunning(request), { timeout: 15_000 }).toBe(false);

  // Start it again and Cancel from the row.
  await startRunner(request);
  await page.reload();
  await expect(section.getByRole("button", { name: /^Cancel$/ })).toBeVisible();
  await section.getByRole("button", { name: /^Cancel$/ }).click();
  await expect.poll(() => runnerRunning(request), { timeout: 15_000 }).toBe(false);
});

test("Transcription page: the Drain button stops the runner gracefully", async ({
  page,
  request,
}) => {
  await resetData(null);
  await makeChannel("alpha", []);
  await writeSettings(IDLE_SETTINGS(ALPHA_ROOT));
  await startRunner(request);

  await page.goto("/operations/transcription");
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });
  await expect.poll(() => runnerRunning(request), { timeout: 15_000 }).toBe(true);

  await section.getByRole("button", { name: "Drain Auto-transcribe" }).click();
  await expect.poll(() => runnerRunning(request), { timeout: 15_000 }).toBe(false);
});

// Regression: draining the runner while one of its units is PARKED in the worker
// pool (waiting for a slot a manual transcription is holding) used to hang
// forever — the runner never forwarded its drainSignal to the parked acquire, so
// the unit's promise never settled and the drain loop spun on `inFlight > 0`.
// Stage exactly that: one worker, a manual "Transcribe missing" on a slowop video
// holds it busy, the auto-runner then launches a unit that parks behind it. Drain
// must still complete.
test("Drain completes when an auto-transcribe unit is parked behind a busy worker", async ({
  page,
  request,
}) => {
  await resetData(null);
  // "busy": a transcribe channel with a single slowop video. The fake-whisper
  // fixture runs ~50s when the video id contains "slowop", so a manual transcribe
  // holds the only worker long enough for the auto unit to park and for us to
  // drain. "alpha": a normal pending video the auto-runner will pick.
  const busy = resolvePath("test-transcripts/channels/busy");
  await mkdir(`${busy}/data/slowop1`, { recursive: true });
  await writeFile(
    `${busy}/config.json`,
    JSON.stringify({ handling: "transcribe", name: "busy", url: "https://example.com/@busy" }),
  );
  await writeFile(`${busy}/data/slowop1/audio.mp3`, "fake audio slowop1\n");
  await makeChannel("alpha", ["a1"]);

  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(ALPHA_ROOT), // runner targets ONLY alpha
  });

  // 1) Manual foreground transcription holds the single worker (slowop → ~50s).
  await generateReport(page, "busy");
  await page.goto(channelStage("busy", "transcribe"));
  await page.getByRole("button", { name: "Transcribe missing" }).click();
  // Wait until it's actually running (worker leased), so the auto unit will park.
  await expect
    .poll(
      async () => {
        const res = await request.get(`${baseUrl}/api/jobs/active`);
        const body = await res.json();
        const jobs = Array.isArray(body) ? body : (body.jobs ?? []);
        return jobs.some(
          (j: { kind?: string; status?: string }) =>
            j.kind === "whisper-all" && j.status === "running",
        );
      },
      { timeout: 20_000 },
    )
    .toBe(true);

  // 2) Start the auto-runner; it picks a1 and parks behind the busy worker.
  await startRunner(request);
  await expect
    .poll(
      async () =>
        (await getStatus(request)).transcription.picks.some(
          (p) => p.videoId === "a1",
        ),
      { timeout: 30_000 },
    )
    .toBe(true);

  // 3) Drain the runner. The parked a1 unit must unblock (skip) so the runner
  //    finalizes instead of hanging.
  await page.goto("/operations/transcription");
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });
  await section.getByRole("button", { name: "Drain Auto-transcribe" }).click();
  await expect.poll(() => runnerRunning(request), { timeout: 15_000 }).toBe(false);

  // Cleanup: hard-cancel the lingering slowop manual job so the worker frees and
  // doesn't bleed into the next spec (afterEach only stops runners). The
  // runner's own table row now carries a Cancel as well; the loop already
  // swallows a button that vanished under it.
  await page.goto("/jobs");
  for (const btn of await page.getByRole("button", { name: /^Cancel$/ }).all()) {
    await btn.click().catch(() => {});
  }
});

// Regression: draining the runner while one of its units is actively RUNNING (a
// worker leased and a transcription in progress, not merely parked) used to hang
// the whole server. The runner's terminal `while (inFlight) await waitNext()`
// loop short-circuited to an immediately-resolved promise once drainSignal was
// aborted, turning it into a timer-less microtask spin that starved the event
// loop — so the running unit's child-exit (a macrotask) never fired, inFlight
// never emptied, and a CPU core spun forever. (The earlier parked-unit fix only
// covered units that settle via microtasks.) Drain must let the running unit
// finish and the runner must finalize.
test("Drain completes (and lets the unit finish) when an auto-transcribe unit is running", async ({
  page,
  request,
}) => {
  await resetData(null);
  // A single slowop video the auto-runner picks: the fake-whisper fixture runs
  // ~7s of real wall-time for a "slowop" dir, a wide window to drain mid-run.
  // The worker is free, so the runner leases it and the unit RUNS (not parks).
  await makeChannel("alpha", ["slowop1"]);
  await writeSettings(IDLE_SETTINGS(ALPHA_ROOT));

  // 1) Start the runner; it picks slowop1, leases the free worker, and starts
  //    transcribing. Wait until the pick is recorded (unit launched/running) and
  //    the transcript isn't written yet (still mid-run), so the drain lands while
  //    the unit is genuinely in flight.
  await startRunner(request);
  await expect
    .poll(
      async () =>
        (await getStatus(request)).transcription.picks.some(
          (p) => p.videoId === "slowop1",
        ),
      { timeout: 30_000 },
    )
    .toBe(true);
  expect(
    await pathExists("test-transcripts/channels/alpha/data/slowop1/transcript.json"),
  ).toBe(false);

  // 2) Drain the runner. Pre-fix this hung forever (event-loop starvation);
  //    post-fix the loop paces on a real timer, the running unit finishes, and
  //    the runner finalizes well within the timeout.
  await page.goto("/operations/transcription");
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });
  await section.getByRole("button", { name: "Drain Auto-transcribe" }).click();
  await expect.poll(() => runnerRunning(request), { timeout: 30_000 }).toBe(false);

  // 3) Drain is a soft-cancel: the in-flight unit was allowed to COMPLETE, not
  //    killed — so its transcript now exists.
  expect(await allTranscribed("alpha", ["slowop1"])).toBe(true);
});

test("download: prioritizes channels across the per-platform queue", async ({
  request,
}) => {
  await resetData(null);
  // Same platform (youtube) for both, so the per-platform gate serializes the
  // downloads and the cross-channel pick order is deterministic.
  await makeDownloadChannel("alpha", ["a1", "a2"]);
  await makeDownloadChannel("beta", ["b1", "b2"]);

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [
      { id: "leaf-alpha", match: { type: "channel", value: "alpha" } },
      { id: "leaf-beta", match: { type: "channel", value: "beta" } },
    ],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: downloadAutoQueue(root),
  });

  await startRunner(request, "download");

  await expect
    .poll(async () => (await getStatus(request)).download.picks.length, {
      timeout: 60_000,
    })
    .toBe(4);

  // alpha (higher priority) downloads before beta; same-platform serialization
  // keeps in-channel order too.
  expect(pickOrder(await getStatus(request), "download")).toEqual([
    "a1",
    "a2",
    "b1",
    "b2",
  ]);
});

// A FILTERED download channel whose snapshot advertises a metadata-scan
// backlog. The fake yt-dlp titles every video "Synthetic <id>", so an include
// of /guest/ keeps guestvid* and rejects plainvid* with no fixture metadata.
// The channel's yt-dlp invocation log, or "" before the first one.
async function readText(relPath: string): Promise<string> {
  return readFile(resolvePath(relPath), "utf8").catch(() => "");
}

async function makeFilteredDownloadChannel(
  slug: string,
  ids: string[],
  unscanned: number,
) {
  const root = resolvePath(`test-transcripts/channels/${slug}`);
  await mkdir(`${root}/data`, { recursive: true });
  await writeFile(
    `${root}/config.json`,
    JSON.stringify({
      handling: "youtube",
      name: slug,
      url: `https://www.youtube.com/@${slug}/videos`,
      downloadFilter: { include: "guest" },
    }),
  );
  await writeFile(
    `${root}/playlist`,
    ids.map((id) => `https://www.youtube.com/watch?v=${id}`).join("\n") + "\n",
  );
  await writeFile(
    `${root}/snapshot.json`,
    JSON.stringify({
      generatedAt: "2026-06-01T00:00:00.000Z",
      totals: { videos: 0, transcribed: 0, downloaded: 0 },
      buckets: {},
      undownloadedIds: ids,
      metadataScan: { scanned: 0, errors: 0, unscanned },
    }),
  );
}

test("the download lane scans a filtered channel before it downloads from it", async ({
  request,
}) => {
  // THE SCAN DECIDES WHAT THE DOWNLOADS ARE, so it is not another kind of work
  // competing with them — it goes first. Without it every non-matching video on
  // a filtered channel is prefetched, rejected and discarded one yt-dlp
  // invocation at a time, against a source that is counting them; one batch
  // answers the whole channel.
  await resetData(null);
  await makeFilteredDownloadChannel(
    "filtered",
    ["guestvid0001", "plainvid0001", "plainvid0002"],
    3,
  );

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-all", match: { type: "all" } }],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: downloadAutoQueue(root),
  });

  await startRunner(request, "download");

  const invocationsPath =
    "test-transcripts/channels/filtered/fake-ytdlp.invocations";
  await expect
    .poll(
      async () =>
        (await readText(invocationsPath)).includes("prefetch:") ||
        (await pathExists(
          "test-transcripts/channels/filtered/data/guestvid0001/transcript.en.vtt",
        )),
      { timeout: 60_000 },
    )
    .toBe(true);

  const invocations = await readText(invocationsPath);
  const scanAt = invocations.indexOf("metadata-scan:");
  const firstPrefetchAt = invocations.indexOf("prefetch:");
  // The scan ran, and it ran BEFORE a single video was prefetched.
  expect(scanAt).toBeGreaterThanOrEqual(0);
  expect(firstPrefetchAt).toBeGreaterThan(scanAt);

  // And it read the whole listing in ONE batch — which is the saving. What is
  // deliberately NOT asserted here is that the non-matches are never prefetched
  // afterwards: the scan asks for a snapshot regen and the runner picks up the
  // new work list on a later tick, so whether a plain video slips through in
  // that window is a race with the regen, not a fact about the feature. The
  // settlement itself is pinned in title-filter.spec.ts.
  const scan = await readJson<{ entries: Record<string, unknown> }>(
    "test-transcripts/channels/filtered/metadata-scan.json",
  );
  expect(Object.keys(scan.entries).sort()).toEqual([
    "guestvid0001",
    "plainvid0001",
    "plainvid0002",
  ]);

  // ONE SCAN PER CHANNEL PER RUNNER. The loop keeps ticking every three
  // seconds; a second scan would mean the source is re-asked for the whole
  // listing forever.
  await expect
    .poll(async () => (await getStatus(request)).download.picks.length, {
      timeout: 30_000,
    })
    .toBeGreaterThan(0);
  expect(
    (await readText(invocationsPath)).split("metadata-scan:").length - 1,
  ).toBe(1);
});

// A React state update that lands before hydration is discarded silently, so a
// select or a click made too early leaves the page looking changed while the
// component still holds the old value — and the next save writes the old value.
// The lane stamps data-hydrated once its client mount effect has run.
async function awaitHydration(
  section: import("@playwright/test").Locator,
): Promise<void> {
  await expect(section).toHaveAttribute("data-hydrated", "true", {
    timeout: 20_000,
  });
}

// --- Ordering within a rule (policy.order) ----------------------------------
//
// The fixtures here write snapshot.json directly and stand up no LMDB index and
// no metadata.info.json, so the recency key comes from the LAST layer of
// common/controller/recencyIndex.ts: the YYYYMMDD_ prefix on the video dir name.
// That is deliberate — it exercises the ordering end to end (policy → runner →
// pick order) without needing a real index in the test corpus.

test("UI: the order select round-trips through save", async ({ page }) => {
  await resetData(null);
  await makeChannel("alpha", []);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: {
      transcription: {
        enabled: false,
        maxWorkers: 1,
        root: { id: "root", mode: "strict", children: [] },
      },
      download: {},
    },
  });

  await page.goto("/operations/transcription");
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });

  await awaitHydration(section);
  const order = section.getByLabel("video order for auto-transcribe");
  await expect(order).toHaveValue("listed");
  await order.selectOption("newest");
  // Proves the change reached React state, not just the DOM node — and covers
  // the new unsaved-changes marker on the way past.
  await expect(section.getByText("Unsaved changes")).toBeVisible();
  await section.getByRole("button", { name: "Save policy" }).click();
  await expect(section.getByText("Saved.")).toBeVisible();

  await expect
    .poll(
      async () => {
        const s = await readJson<{
          autoQueue?: { transcription?: { order?: string } };
        }>("test-settings.json").catch(() => null);
        return s?.autoQueue?.transcription?.order ?? null;
      },
      { timeout: 10_000 },
    )
    .toBe("newest");

  // And it comes back that way, rather than being silently dropped by the
  // action's explicit field list on the way through.
  await page.reload();
  await expect(
    page
      .locator("section", {
        has: page.getByRole("heading", { name: "Auto-transcribe" }),
      })
      .getByLabel("video order for auto-transcribe"),
  ).toHaveValue("newest");
});

test("newest first: the freshest upload jumps the older backlog", async ({
  request,
}) => {
  await resetData(null);
  // Deliberately created oldest-first, which is also how they sort
  // lexicographically — so "listed" order would serve them in exactly the wrong
  // order and any pass here has to come from the recency key.
  await makeChannel("alpha", [
    "20240101_old",
    "20250601_mid",
    "20260812_new",
  ]);

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: {
      transcription: { enabled: true, maxWorkers: 1, order: "newest", root },
      download: {},
    },
  });

  await startRunner(request);
  await expect
    .poll(async () => (await getStatus(request)).transcription.picks.length, {
      timeout: 60_000,
    })
    .toBe(3);

  expect(pickOrder(await getStatus(request))).toEqual([
    "20260812_new",
    "20250601_mid",
    "20240101_old",
  ]);
});

test("listed order is unchanged — the same fixture serves oldest first", async ({
  request,
}) => {
  // The compatibility half of the claim above: with no `order` field at all (an
  // existing settings.json), the identical fixture must still drain in the
  // order it always did.
  await resetData(null);
  await makeChannel("alpha", [
    "20240101_old",
    "20250601_mid",
    "20260812_new",
  ]);

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(root, 1),
  });

  await startRunner(request);
  await expect
    .poll(async () => (await getStatus(request)).transcription.picks.length, {
      timeout: 60_000,
    })
    .toBe(3);

  expect(pickOrder(await getStatus(request))).toEqual([
    "20240101_old",
    "20250601_mid",
    "20260812_new",
  ]);
});

// --- "It's running — why isn't it doing anything?" ---------------------------

test("a running runner says why it is idle", async ({ page, request }) => {
  await resetData(null);
  // A channel with nothing pending: the runner comes up, finds no work, and
  // used to sit there looking identical to one that was wedged.
  await makeChannel("alpha", []);

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(root, 1),
  });

  await startRunner(request);
  await expect
    .poll(
      async () => (await getStatus(request)).transcription.runner.idleReason,
      { timeout: 20_000 },
    )
    .toBe("no-pending");

  await page.goto("/operations/transcription");
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });
  await expect(section.getByText(/nothing pending/)).toBeVisible({
    timeout: 20_000,
  });
});

// --- Snooze -----------------------------------------------------------------

test("snooze idles the runner without stopping it, and Wake now resumes", async ({
  page,
  request,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1"]);

  const root: Group = {
    id: "root",
    mode: "strict",
    children: [{ id: "leaf-alpha", match: { type: "channel", value: "alpha" } }],
  };
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: {
      transcription: {
        enabled: true,
        maxWorkers: 1,
        snoozeUntil: Date.now() + 3_600_000,
        root,
      },
      download: {},
    },
  });

  await startRunner(request);

  // IDLE, not stopped: the loop stays up so it can notice the deadline pass.
  await expect
    .poll(
      async () => {
        const s = (await getStatus(request)).transcription;
        return { running: s.runner.running, idle: s.runner.idleReason };
      },
      { timeout: 20_000 },
    )
    .toEqual({ running: true, idle: "snoozed" });
  expect(await allTranscribed("alpha", ["a1"])).toBe(false);

  // Waking is a live settings change, not a restart: the same runner picks the
  // work up on its next iteration.
  await page.goto("/operations/transcription");
  const section = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });
  await expect(section.getByText(/Snoozed until/)).toBeVisible({
    timeout: 20_000,
  });
  await awaitHydration(section);
  await section.getByRole("button", { name: "Wake Auto-transcribe now" }).click();

  await expect
    .poll(async () => allTranscribed("alpha", ["a1"]), { timeout: 60_000 })
    .toBe(true);
  expect((await getStatus(request)).transcription.runner.running).toBe(true);
});

// --- The console: the board, the rail, and the two sweep lanes -------------
//
// ONE PAGE PER OPERATION. The rail used to be a summary above a <select> that
// chose which lane you could act on; it is the switcher itself now, and each
// row's NAME is the link. That is what these three tests pin: the board lists
// every pipeline, the rows go somewhere, and the old address still lands.

test("UI: the board carries every pipeline, and each row links to it", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2"]);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(ALPHA_ROOT),
  });

  await page.goto("/operations");
  await expect(
    page.getByRole("heading", { name: "Operations", exact: true }),
  ).toBeVisible();
  await awaitHydration(page.locator('[data-board="operations"]'));

  // The rail carries a row per pipeline — the two the runners dispatch, the one
  // digest owns, every speaker operation that is switched on, and sync, the one
  // channel-scoped row. It is the CATALOG view: what this install can do, not
  // what it is doing.
  const rail = page.locator("li[data-operation]");
  await expect(rail.filter({ hasText: "Sync" }).first()).toBeVisible();
  await expect(rail.filter({ hasText: "Download" }).first()).toBeVisible();
  await expect(rail.filter({ hasText: "Transcription" }).first()).toBeVisible();
  await expect(rail.filter({ hasText: "Digest" }).first()).toBeVisible();

  // THE ROW'S NAME IS THE LINK, and its accessible name is the operation alone
  // — a link wrapping the whole row would be named by figures that change on
  // every poll.
  await expect(
    rail.getByRole("link", { name: "Transcription", exact: true }),
  ).toHaveAttribute("href", "/operations/transcription");
  // Sync's row is composed rather than folded from a band — it has no per-video
  // population — but it is the same anatomy, and its name links to its page.
  await expect(
    rail.getByRole("link", { name: "Sync", exact: true }),
  ).toHaveAttribute("href", "/operations/sync");
  await rail.getByRole("link", { name: "Digest", exact: true }).click();
  await expect(page).toHaveURL(/\/operations\/digest$/);

  // NOTHING ON THE BOARD IS A RUNNER PANEL. The board is about every operation;
  // one operation in full is what /operations/<id> is for.
  await page.goto("/operations");
  await expect(page.locator("section[data-lane]")).toHaveCount(0);
});

test("UI: /auto-queue still lands, and an unknown operation is a 404", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1"]);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(ALPHA_ROOT),
  });

  // A RETIRED ROUTE REDIRECTS, NEVER 404s — the nav rule this repo shares with
  // umtool. Every bookmark, every link in a commit message, every note in
  // plans/ that says /auto-queue still lands on the console.
  await page.goto("/auto-queue");
  await expect(page).toHaveURL(/\/operations$/);
  await expect(
    page.getByRole("heading", { name: "Operations", exact: true }),
  ).toBeVisible();

  // The catalog IS the route table, so an id the registry does not know is a
  // 404 rather than an empty console.
  const res = await page.goto("/operations/not-an-operation");
  expect(res?.status()).toBe(404);
});

test("UI: each operation page carries its own lane, and the rail as context", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1", "a2"]);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(ALPHA_ROOT),
  });

  // ONE RUNNER SECTION PER PAGE. Auto-download is not hidden here, it is simply
  // not on this page — which is what deleting the switcher bought: no second
  // pane to keep mounted, and no policy edit to lose across a switch.
  await page.goto("/operations/transcription");
  const transcribe = page.locator("section", {
    has: page.getByRole("heading", { name: "Auto-transcribe" }),
  });
  await awaitHydration(transcribe);
  await expect(transcribe).toBeVisible();
  await expect(page.locator('section[data-lane="download"]')).toHaveCount(0);
  // The rail is still above it — on this corpus a lane is usually idle BECAUSE
  // another one is, so the context travels with the operation.
  await expect(page.locator("li[data-operation]").first()).toBeVisible();

  await page.goto("/operations/download");
  await expect(
    page.locator("section", {
      has: page.getByRole("heading", { name: "Auto-download" }),
    }),
  ).toBeVisible();

  // A RUNNER PAGE HAS ITS PAUSE TOO, beside Start/Drain/Stop. Those three act on
  // the runner; this holds the LANE, which outlives it — and until slice 7 the
  // only way to hold a runner lane was the dashboard.
  //
  // It writes the same settings key the dashboard's button does, so the key is
  // what is asserted, not just the label. Since slice 1.4 that key is the lane's
  // own `autoQueue.download.held`, not the loose `downloadsPaused` flag. The
  // pause is released again at the end so this test leaves the fixture as it
  // found it.
  const download = page.locator('section[data-lane="download"]');
  await awaitHydration(download);
  const downloadsPaused = async () =>
    (
      await readJson<{ autoQueue?: { download?: { held?: boolean } } }>(
        "test-settings.json",
      ).catch(() => ({}) as { autoQueue?: { download?: { held?: boolean } } })
    ).autoQueue?.download?.held ?? false;
  const pause = download.getByRole("button", { name: "Pause Downloads" });
  await expect(pause).toBeVisible();
  await pause.click();
  await expect.poll(downloadsPaused, { timeout: 20_000 }).toBe(true);
  const resume = download.getByRole("button", { name: "Resume Downloads" });
  await expect(resume).toBeVisible();
  await resume.click();
  await expect.poll(downloadsPaused, { timeout: 20_000 }).toBe(false);

  // The digest lane is a page of its own, and it is a RUNNER console like the
  // two above it — the same section, the same four controls. Until slice 1.3 it
  // was a sweep panel on `data-sweep-lane`; that attribute is gone, and no
  // second section on the page answers to a lane.
  await page.goto("/operations/digest");
  const digest = page.locator('section[data-lane="digest"]');
  await awaitHydration(digest);
  await expect(page.locator("section[data-sweep-lane]")).toHaveCount(0);
  // THE ARBITER'S BUTTONS, ASSERTED GONE. Its three tests were deleted with it,
  // so without this nothing in the suite would notice `ArbiterBar` coming back —
  // and it was a live Start button over a dispatcher that never ran a unit in
  // production. The board is where it sat, so the board is where it is missed.
  await page.goto("/operations");
  await awaitHydration(page.locator('[data-board="operations"]'));
  await expect(
    page.getByRole("button", { name: /the arbiter/i }),
  ).toHaveCount(0);
  await page.goto("/operations/digest");
  await awaitHydration(digest);
  await expect(
    digest.getByRole("heading", { name: "Auto-digest" }),
  ).toBeVisible();
  await expect(
    digest.getByRole("button", { name: "Start Auto-digest" }),
  ).toBeVisible();
  // THE RUNNER AND THE GATE ARE DIFFERENT CONTROLS, and both must be here —
  // conflating them is how an operator loses a week of GPU time.
  await expect(
    digest.getByRole("button", { name: "Pause Digests" }),
  ).toBeVisible();
  // The sweep's own controls are gone from this page and from everywhere else —
  // BOTH halves. Asserting only the arm half would let a disarm button survive
  // over an action that no longer exists.
  await expect(
    page.getByRole("button", { name: "Start Digest sweep" }),
  ).toHaveCount(0);
  await expect(
    page.getByRole("button", { name: "Stop Digest sweep" }),
  ).toHaveCount(0);
  await expect(page.getByRole("button", { name: /Stop sweeping/i })).toHaveCount(
    0,
  );
});

test("the digest lane offers Shortest first, and has no Reach axis", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1"]);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    autoQueue: transcriptionAutoQueue(ALPHA_ROOT),
  });

  await page.goto("/operations/digest");
  const digest = page.locator('section[data-lane="digest"]');
  await awaitHydration(digest);

  // REACH RETIRED WITH THE SWEEP. A runner's order already applies across every
  // channel and bucket a rule claims, so there is no second axis to offer —
  // which rule goes FIRST is the tree's job. The control is gone, not disabled:
  // a disabled dropdown would imply a setting that does not exist.
  await expect(digest.getByLabel("Reach", { exact: true })).toHaveCount(0);

  // "Shortest first" is offered on this lane ALONE, because it is the only lane
  // whose runner can price its candidates.
  const order = digest.getByLabel("video order for auto-digest");
  await expect(order.locator("option")).toHaveText([
    "Listed order",
    "Newest first",
    "Oldest first",
    "Shortest first",
  ]);
  // HOLD THE LANE FIRST, and this is not decoration. `saveAutoQueueAction`
  // spells every policy field explicitly — its own comment says why — so a
  // field it forgets is dropped on every save, and since slice 1.4 the lane's
  // GATE is such a field. A rule reorder that silently resumed a held lane is
  // the exact regression this half is here to catch.
  await digest.getByRole("button", { name: "pause digests" }).click();
  await expect
    .poll(
      async () =>
        (
          await readJson<{
            autoQueue?: { digest?: { held?: boolean } };
          }>("test-settings.json").catch(() => null)
        )?.autoQueue?.digest?.held ?? null,
      { timeout: 15_000 },
    )
    .toBe(true);

  await order.selectOption("newest");
  await digest.getByRole("button", { name: "Save policy" }).click();

  // It lands on the LANE POLICY, not in settings.digest — `recencyOrder` and
  // `recencyReach` retired with the sweep that read them — and the hold above
  // is still there afterwards.
  await expect
    .poll(
      async () => {
        const s = await readJson<{
          autoQueue?: { digest?: { order?: string; held?: boolean } };
          digest?: { recencyOrder?: string; recencyReach?: string };
        }>("test-settings.json").catch(() => null);
        return [
          s?.autoQueue?.digest?.order,
          s?.digest?.recencyOrder ?? "gone",
          s?.digest?.recencyReach ?? "gone",
          `held=${String(s?.autoQueue?.digest?.held)}`,
        ].join("/");
      },
      { timeout: 15_000 },
    )
    .toBe("newest/gone/gone/held=true");
});

// THE DELETION, FROM THE BROWSER. Until S0-pause a settings.json spelling one
// of the four RETIRED pause fields and carrying no `held` still held its lane:
// `isGateHeld` fell back to the field and `getSettings` copied the answer onto
// the lane. Both are gone, on the precondition that the live settings.json had
// already been written with all four `held` keys — so a file that still spells
// a retired field must now hold NOTHING, and must lose the field the first time
// the editor writes it.
//
// That second half is what a unit test cannot see: the strip happens in
// `writeSettings`, which builds its output from only the known operational
// fields, and this asserts it through a real save from a real page.
//
// The DIGEST lane, not transcription, and that is the asymmetry rather than a
// shortcut: transcription's live hold is the worker pool, and no UI surface may
// read its stored value (see lib/pauseGates.ts), so a fixture flag could not be
// observed through a page without contradicting that rule.
test("a retired pause field holds nothing, and does not survive a write", async ({
  page,
}) => {
  await resetData(null);
  await makeChannel("alpha", ["a1"]);
  await writeSettings({
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    workers: ONE_WORKER,
    // The pre-1.4 spelling, and nothing else: no `autoQueue.digest` block, so
    // no `held` for the sanitizer to find either.
    digest: { digestsPaused: true },
  });

  const res = await page.request.get(`${baseUrl}/api/auto-queue/status`);
  expect(res.ok()).toBeTruthy();
  const payload = (await res.json()) as Record<string, { held?: boolean }>;
  expect(payload.digest?.held).toBe(false);

  await page.goto("/operations/digest");
  const digest = page.locator('section[data-lane="digest"]');
  await awaitHydration(digest);
  // The lane reads as running, so the control on offer is the pause.
  const pause = digest.getByRole("button", { name: "pause digests" });
  await expect(pause).toBeEnabled({ timeout: 30_000 });
  await pause.click();

  // The click persists the KEY — and the write drops the retired field, so a
  // stale settings.json cannot resurrect a pause after an operator lifts one.
  await expect
    .poll(
      async () => {
        const s = await readJson<{
          autoQueue?: { digest?: { held?: boolean } };
          digest?: { digestsPaused?: boolean };
        }>("test-settings.json").catch(() => null);
        if (!s) return null;
        return `held=${String(s.autoQueue?.digest?.held)}/retired=${String(
          "digestsPaused" in (s.digest ?? {}),
        )}`;
      },
      { timeout: 20_000 },
    )
    .toBe("held=true/retired=false");
});

test("/jobs: a runner is a lane on a strip, not a card", async ({
  page,
  request,
}) => {
  await resetData(null);
  await makeChannel("alpha", []); // enabled, nothing pending -> running but idle
  await writeSettings(IDLE_SETTINGS(ALPHA_ROOT));
  await startRunner(request);

  await page.goto("/jobs");
  const lane = page.locator(
    "section[aria-label='System jobs: Auto-transcribe']",
  );
  // Still addressable exactly as before — heading, aria-label, controls.
  await expect(lane.getByRole("heading", { name: "Auto-transcribe" })).toBeVisible();
  await expect(lane.getByRole("button", { name: /^Cancel$/ })).toBeVisible();
  // What is NEW: it says why it is not working, instead of a card that said
  // nothing at all.
  await expect(lane.getByText(/nothing pending/)).toBeVisible({
    timeout: 15_000,
  });

  // The sweep-fed lanes are on the strip too, with no job of their own.
  await expect(
    page.locator("section[aria-label='System jobs: Digest']"),
  ).toBeVisible();
  // And the generic bucket stays gone.
  await expect(page.getByRole("heading", { name: "Other" })).toHaveCount(0);
});