import { test, expect } from "@playwright/test";
import { writeFile, readFile, rm } from "node:fs/promises";
import { join } from "node:path";
// Imported by RELATIVE path, not by package name. The other specs only ever
// import types from `yt-dlp-transcript-common/...`, which are erased at compile
// time; `common` publishes no `exports` map, so a runtime import of the package
// specifier does not resolve under playwright's loader. The relative path does,
// the same way ./helpers does — and pulling in the REAL effectiveDigest matters
// here: asserting override survival against a reimplementation of the merge
// would prove nothing about the merge that ships.
import {
  effectiveDigest,
  type DigestOverrides,
  type DigestRecord,
} from "../../common/lib/digest";
import {
  channelStage,
  generateReport,
  pathExists,
  readJson,
  resetData,
  resolvePath,
  writeChannelConfig,
  writeDigestVideo,
  writeSettings,
} from "./helpers";

// The digest lane, end to end through the real job path.
//
// The local engine is an HTTP stub (e2e/fixtures/ollama-stub.mjs, a third
// playwright webServer) rather than a fake binary, because ollama-direct POSTs
// to ${ollamaUrl}/api/chat and has no binary to replace. The metered lane's
// engine IS a subprocess and so uses the ordinary fake-binary idiom
// (e2e/fixtures/bin/fake-claude.mjs, wired in via CLAUDE_BIN).
//
// Post-mutation assertions poll with reload where they read a rendered page:
// the channel page serves a persisted snapshot regenerated on a ~1s debounce.
// Assertions that read the SIDECARS go straight to disk and need no polling —
// the batch"s closing summary line is the happens-before edge.

const CHANNEL = "digest-channel";
const VIDEO = "digestvid0001";

function digestPath(channel: string, video: string): string {
  return join("test-transcripts", "channels", channel, "data", video, "ai-digest.json");
}

function overridesPath(channel: string, video: string): string {
  return join(
    "test-transcripts",
    "channels",
    channel,
    "data",
    video,
    "ai-digest.overrides.json",
  );
}

// Settings with the digest block spelled out. sanitizeDigest fills the rest.
function digestSettings(over: Record<string, unknown> = {}) {
  return {
    adminTitle: "Test Admin",
    maxTranscriptPageBytes: 8388608,
    sleepBetweenDownloadsSeconds: 0,
    minFreeDiskGB: 0,
    digest: {
      localAppId: "ollama-direct",
      remoteAppId: "claude-code",
      sections: ["chapters"],
      ...over,
    },
  };
}

// The batch's closing summary line. Waiting on THAT rather than on a generic
// "succeeded" is what makes these assertions a happens-before edge for the
// sidecar reads below: the line is emitted after the last write.
const BATCH_DONE = "Digest batch:";

async function runDigest(page: import("@playwright/test").Page, slug: string) {
  await generateReport(page, slug);
  await page.goto(channelStage(slug, "digest"));
  await page.getByRole("button", { name: "Digest channel" }).click();
  await expect(page.getByLabel("Digest channel output")).toContainText(
    BATCH_DONE,
    { timeout: 60_000 },
  );
}

// ---------------------------------------------------------------------------
// 1. Override survival — the single most important test in this file.
//
// A full sweep is weeks of wall-clock, so a hand correction that regeneration
// destroys is work that can never be affordably redone. The two sidecars exist
// for exactly this, and nothing else in the suite would notice if the generator
// started writing through to the human file.
// ---------------------------------------------------------------------------

test("a human override survives a regeneration and reads back as human", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  await runDigest(page, CHANNEL);

  const first = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  const generated = first.sections.chapters?.items ?? [];
  expect(generated.length).toBeGreaterThan(0);
  expect(generated[0].decidedBy).toBe("ai");

  // A human retitles the first chapter and suppresses the second, using the
  // ids the generator produced.
  const overrides: DigestOverrides = {
    version: 1,
    chapters: [
      {
        ...generated[0],
        title: "Hand-written chapter title",
        decidedBy: "human",
      },
      ...(generated[1]
        ? [{ ...generated[1], decidedBy: "human" as const, enabled: false }]
        : []),
    ],
    note: "corrected by hand in e2e",
  };
  await writeFile(
    resolvePath(overridesPath(CHANNEL, VIDEO)),
    JSON.stringify(overrides, null, 2),
  );
  const overridesBefore = await readFile(
    resolvePath(overridesPath(CHANNEL, VIDEO)),
    "utf8",
  );

  // Force a genuine regeneration by changing the requested model — that is a
  // real identity change, not a test-only escape hatch, so this exercises the
  // same path a prompt or model change would take in production.
  await writeSettings(
    digestSettings({ apps: { "ollama-direct": { model: "qwen2.5:7b-v2" } } }),
  );
  await runDigest(page, CHANNEL);

  const second = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  expect(second.sections.chapters?.provenance.modelRequested).toBe(
    "qwen2.5:7b-v2",
  );

  // The human file is untouched, byte for byte. The generator must not be able
  // to reach it at all.
  const overridesAfter = await readFile(
    resolvePath(overridesPath(CHANNEL, VIDEO)),
    "utf8",
  );
  expect(overridesAfter).toBe(overridesBefore);

  // And the composed view a reader would see honors it: the retitle wins and
  // reports decidedBy "human"; the suppressed item is gone without being
  // deleted from either file.
  const composed = effectiveDigest(second, overrides);
  const kept = composed.chapters.find(
    (c) => c.title === "Hand-written chapter title",
  );
  expect(kept).toBeTruthy();
  expect(kept?.decidedBy).toBe("human");
  expect(composed.hasOverrides).toBe(true);
  if (generated[1]) {
    expect(composed.chapters.some((c) => c.id === generated[1].id)).toBe(false);
  }
});

// ---------------------------------------------------------------------------
// 2. Dedup sharing — the correctness crux.
//
// Content similarity says nothing about TIMING. A mirror with a longer intro
// matches on text at shifted times, so sharing a digest onto it would place
// every chapter wrong while the artifact looked perfectly healthy.
// ---------------------------------------------------------------------------

type ClusterFixture = {
  clusterId: string;
  members: string[];
  contained?: boolean;
  // Pinned explicitly in these fixtures rather than left to pickCanonicalSlug.
  // The rule's tie-break for equal-duration, equally-transcribed members is
  // LEXICOGRAPHIC on the slug, which silently made the intended mirror the
  // canonical and inverted the assertion. Naming it here keeps each test about
  // the thing it is testing — the alignment gate — instead of about the
  // tie-break.
  canonicalSlug?: string;
};

async function writeDuplicateReport(clusters: ClusterFixture[]) {
  const report = {
    version: 1,
    generatedAt: new Date().toISOString(),
    runConfig: {
      thresholdSeconds: null,
      durationToleranceSeconds: 2,
      nearThreshold: 0.6,
      containmentThreshold: 0.8,
      shingleSize: 5,
    },
    totals: {
      videosScanned: clusters.reduce((a, c) => a + c.members.length, 0),
      clusters: clusters.length,
      videosInClusters: clusters.reduce((a, c) => a + c.members.length, 0),
    },
    clusters: clusters.map((c) => ({
      clusterId: c.clusterId,
      ...(c.canonicalSlug ? { canonicalSlug: c.canonicalSlug } : {}),
      matchKind: "transcript-exact",
      score: 1,
      contained: c.contained ?? false,
      durationBucket: 300,
      crossPlatform: true,
      crossChannel: true,
      videoRefs: c.members.map((slug) => {
        const [channelSlug, id] = slug.split("/");
        return {
          slug,
          channelSlug,
          channel: channelSlug,
          platform: "youtube",
          id,
          title: `Mirror of ${id}`,
          duration: 600,
          uploadDate: "20240101",
          hasTranscript: true,
        };
      }),
    })),
  };
  await writeFile(
    resolvePath(join("test-transcripts", "duplicates.json")),
    JSON.stringify(report, null, 2),
  );
}

test("a digest is shared to an aligned mirror and refused to a shifted one", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  // canonical + a byte-aligned mirror + a mirror whose cues are shifted 40s by
  // a longer intro. All three carry identical TEXT — only the timings differ,
  // which is precisely the case a text-similarity check cannot distinguish.
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "canon00000001" });
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "aligned000001" });
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "canon00000002" });
  await writeDigestVideo({
    channelSlug: CHANNEL,
    videoId: "shifted000001",
    startOffsetSeconds: 40,
  });

  // Each cluster gets its OWN canonical member. Clusters partition the corpus,
  // and DigestClusterPlan.bySlug is keyed by slug — so a video listed in two
  // clusters would have its role silently overwritten by whichever cluster is
  // read last, and only one of the two outcomes would ever be observed.
  await writeDuplicateReport([
    {
      clusterId: "cluster-aligned",
      members: [`${CHANNEL}/canon00000001`, `${CHANNEL}/aligned000001`],
      canonicalSlug: `${CHANNEL}/canon00000001`,
    },
    {
      clusterId: "cluster-shifted",
      members: [`${CHANNEL}/canon00000002`, `${CHANNEL}/shifted000001`],
      canonicalSlug: `${CHANNEL}/canon00000002`,
    },
  ]);

  await runDigest(page, CHANNEL);

  const aligned = await readJson<DigestRecord>(
    digestPath(CHANNEL, "aligned000001"),
  );
  expect(aligned.derivedFrom?.slug).toBe(`${CHANNEL}/canon00000001`);
  // Sharing only happens at near-zero offset, and the record says why it was
  // considered safe.
  expect(Math.abs(aligned.derivedFrom?.offsetSeconds ?? 99)).toBeLessThanOrEqual(5);
  expect(aligned.sections.chapters?.items.length).toBeGreaterThan(0);

  // The shifted mirror was refused the share. It may still have been generated
  // for in its own right — what must never happen is it CARRYING the canonical
  // member's digest.
  const shifted = await pathExists(digestPath(CHANNEL, "shifted000001"));
  if (shifted) {
    const rec = await readJson<DigestRecord>(digestPath(CHANNEL, "shifted000001"));
    expect(rec.derivedFrom).toBeUndefined();
  }
});

test("a contained cluster never shares, however well it aligns", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "canon00000001" });
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "clipped000001" });

  // Identical timings — this pair would sail through the alignment gate. It is
  // refused earlier, because containment means one member is a CLIP: the long
  // video's chapters describe material the clip does not contain.
  await writeDuplicateReport([
    {
      clusterId: "cluster-contained",
      members: [`${CHANNEL}/canon00000001`, `${CHANNEL}/clipped000001`],
      canonicalSlug: `${CHANNEL}/canon00000001`,
      contained: true,
    },
  ]);

  await runDigest(page, CHANNEL);

  const clip = await readJson<DigestRecord>(digestPath(CHANNEL, "clipped000001"));
  expect(clip.derivedFrom).toBeUndefined();
  // It got its own digest instead of being skipped — a clip is a different
  // artifact and deserves one.
  expect(clip.sections.chapters?.items.length).toBeGreaterThan(0);
});

test("a human canonical override beats the rule", async ({ page }) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  // Equal duration and both transcribed, so the rule falls through to the
  // lexicographic tie-break and would pick "aaa…". The human names the other.
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "aaa000000001" });
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "zzz000000001" });

  await writeDuplicateReport([
    {
      clusterId: "cluster-human",
      members: [`${CHANNEL}/aaa000000001`, `${CHANNEL}/zzz000000001`],
    },
  ]);
  await writeFile(
    resolvePath(join("test-transcripts", "duplicates.overrides.json")),
    JSON.stringify({
      version: 1,
      clusters: {
        "cluster-human": {
          canonicalSlug: `${CHANNEL}/zzz000000001`,
          decidedAt: new Date().toISOString(),
          note: "e2e: operator picked the later id",
        },
      },
    }),
  );

  await runDigest(page, CHANNEL);

  // The human's choice generated; the other received the share.
  const shared = await readJson<DigestRecord>(digestPath(CHANNEL, "aaa000000001"));
  expect(shared.derivedFrom?.slug).toBe(`${CHANNEL}/zzz000000001`);
  const canonical = await readJson<DigestRecord>(
    digestPath(CHANNEL, "zzz000000001"),
  );
  expect(canonical.derivedFrom).toBeUndefined();
});

// ---------------------------------------------------------------------------
// 3. The job path
// ---------------------------------------------------------------------------

test("the Digest stage queues a job and writes the sidecar", async ({ page }) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  await runDigest(page, CHANNEL);

  await page.goto("/jobs");
  const firstRow = page.getByRole("row").nth(1);
  await expect(firstRow).toContainText("digest:local");
  await expect(firstRow).toContainText("Digest channel (local)");

  const record = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  expect(record.sections.chapters?.provenance.appId).toBe("ollama-direct");
  expect(record.sections.chapters?.provenance.lane).toBe("local-gpu");
  expect(record.digestSchemaVersion).toBe(1);
  // A default-configuration record carries NO promptVariant, which is what
  // keeps every digest written before that field existed fresh.
  expect(record.sections.chapters?.provenance.promptVariant).toBeUndefined();
});

test("a second run with unchanged versions is a no-op", async ({ page }) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  await runDigest(page, CHANNEL);
  const first = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  const generatedAt = first.sections.chapters?.provenance.generatedAt;

  await runDigest(page, CHANNEL);
  await expect(page.getByLabel("Digest channel output")).toContainText(
    "1 already current",
  );

  // The freshness skip is what makes a re-run minutes instead of a second
  // multi-week sweep, so "nothing was rewritten" is the assertion.
  const second = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  expect(second.sections.chapters?.provenance.generatedAt).toBe(generatedAt);
});

// ---------------------------------------------------------------------------
// 4. Two lanes, two queue keys
// ---------------------------------------------------------------------------

test("the two lanes land on different queue keys", async ({ page }) => {
  await resetData(null);
  // longTailSeconds is lowered so the fixture video falls INSIDE the metered
  // lane's window. digestChannelAction routes the remote lane with
  // minDurationSeconds: settings.digest.longTailSeconds, because the metered
  // lane exists for the >4h tail — at the default the 10-minute fixture would be
  // out of scope and the run would legitimately find nothing to do.
  await writeSettings(digestSettings({ remoteEnabled: true, longTailSeconds: 60 }));
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  await generateReport(page, CHANNEL);
  await page.goto(channelStage(CHANNEL, "digest"));
  await page.getByRole("button", { name: "Digest channel" }).click();
  await expect(page.getByLabel("Digest channel output")).toContainText(
    BATCH_DONE,
    { timeout: 60_000 },
  );

  // Switch to the metered lane. The control follows the lane's own default key —
  // if it did not, both lanes would share one key and the registry's
  // concurrency-1-per-key rule would serialize a GPU lane behind a network one.
  await generateReport(page, CHANNEL);
  await page.goto(channelStage(CHANNEL, "digest"));
  await page.getByLabel("lane for Digest channel").selectOption("remote");
  await expect(page.getByLabel("queue for Digest channel")).toHaveValue(
    "digest:remote",
  );
  // The metered lane must actually have work to do, so invalidate the identity.
  await writeSettings(
    digestSettings({
      remoteEnabled: true,
      longTailSeconds: 60,
      apps: { "claude-code": { model: "haiku" } },
    }),
  );
  await page.reload();
  await page.getByLabel("lane for Digest channel").selectOption("remote");
  await page.getByRole("button", { name: "Digest channel" }).click();
  await expect(page.getByLabel("Digest channel output")).toContainText(
    BATCH_DONE,
    { timeout: 60_000 },
  );

  await page.goto("/jobs");
  const rows = page.getByRole("row");
  await expect(rows.nth(1)).toContainText("digest:remote");
  await expect(rows.nth(2)).toContainText("digest:local");

  // And the metered lane's own engine really ran: the record carries its lane
  // and the cost the CLI wrapper reported.
  const record = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  expect(record.sections.chapters?.provenance.lane).toBe("remote-api");
  expect(record.sections.chapters?.provenance.appId).toBe("claude-code");
  expect(record.sections.chapters?.provenance.costUsd).toBeGreaterThan(0);
});

test("the metered lane is refused while it is disabled in settings", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings({ remoteEnabled: false }));
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  await generateReport(page, CHANNEL);
  await page.goto(channelStage(CHANNEL, "digest"));
  const lane = page.getByLabel("lane for Digest channel");
  // Nothing can spend money until it is explicitly turned on, so the option is
  // disabled at the control rather than rejected after the click.
  //
  // Asserted via the ATTRIBUTE: playwright's toBeDisabled() reports an <option>
  // as enabled regardless of its disabled attribute (it models form-control
  // disabled state, and an <option> is not a form control).
  await expect(lane.locator("option[value='remote']")).toHaveAttribute(
    "disabled",
    "",
  );
});

// ---------------------------------------------------------------------------
// 5. The guards, through the real pipeline
//
// The unit tests pin each guard in isolation; this pins that the guards are
// actually WIRED — that a bad engine response reaches warnings[] on disk and
// that nothing bogus reaches items[].
// ---------------------------------------------------------------------------

test("bad engine output is recorded in warnings and never reaches items", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  // The stub keys its bad-output mode off this sentinel in the request body —
  // the SLOWOP convention the other fakes use.
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: "badout000001" });

  await runDigest(page, CHANNEL);

  const record = await readJson<DigestRecord>(
    digestPath(CHANNEL, "badout000001"),
  );
  const codes = record.warnings.map((w) => w.code);
  expect(codes).toContain("malformed-timestamp");
  expect(codes).toContain("language-drift");
  expect(codes).toContain("out-of-range");

  // Every rejection names the offending value verbatim, because a multi-week
  // sweep is only tunable if its failures are inspectable from the artifact.
  const malformed = record.warnings.find(
    (w) => w.code === "malformed-timestamp",
  );
  expect(malformed?.value).toBe(":00:27");
  expect(malformed?.section).toBe("chapters");

  const items = record.sections.chapters?.items ?? [];
  expect(items.length).toBeGreaterThan(0);
  for (const item of items) {
    expect(item.clock).toMatch(/^\d\d:\d\d:\d\d$/);
    // Nothing that failed a guard survived.
    expect(item.title).not.toMatch(/Malformed stamp|Out of range topic/);
    expect(item.title).toMatch(/^[\p{L}\p{N}\p{P}\p{Zs}]+$/u);
    expect(item.start).toBeLessThanOrEqual(600);
  }
});

test.afterAll(async () => {
  // duplicates.json / duplicates.overrides.json live at the transcripts ROOT, so
  // they survive a channel-scoped reset and would leak into unrelated specs.
  await rm(resolvePath(join("test-transcripts", "duplicates.json")), {
    force: true,
  });
  await rm(resolvePath(join("test-transcripts", "duplicates.overrides.json")), {
    force: true,
  });
});

// ---------------------------------------------------------------------------
// 10. The per-video review panel.
//
// The backend for this (readVideoDigestAction, saveDigestOverridesAction,
// digestBucketAction) shipped with Stage B1 and had NO caller — the digest layer
// produced artifacts nothing could display. A validation run is unreadable while
// its output is invisible, so these cover the three things the panel exists to
// show: what was produced, WHICH configuration produced it, and whether that is
// still the current one.
// ---------------------------------------------------------------------------

test("the video panel renders a digest with its provenance and warnings", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  // Empty state first — it is what an operator sees for most of a sweep.
  await page.goto(`/channels/${CHANNEL}/videos/${VIDEO}`);
  await expect(page.getByLabel("digest empty")).toBeVisible();
  await expect(page.getByLabel("digest freshness")).toHaveText("not generated");

  await runDigest(page, CHANNEL);

  await page.goto(`/channels/${CHANNEL}/videos/${VIDEO}`);
  await expect(page.getByLabel("digest freshness")).toHaveText("current");

  // Chapters, with the clock the model actually emitted.
  const chapters = page.getByLabel("digest chapters").locator("li");
  expect(await chapters.count()).toBeGreaterThan(0);

  // Provenance — the whole point during a bake-off-driven validation.
  const section = page.getByLabel("digest section chapters");
  await expect(section).toContainText("ollama-direct");
  await expect(section).toContainText("promptVersion");
  await expect(section).toContainText("contextHash");
  await expect(section).toContainText("current");

  // Warnings are always accounted for — either a list or an explicit "none".
  // `exact` matters: getByLabel is substring-matched by default, so the plain
  // form would also match "digest warnings empty" and count both states.
  const hasWarnings = await page
    .getByLabel("digest warnings", { exact: true })
    .count();
  const noWarnings = await page
    .getByLabel("digest warnings empty", { exact: true })
    .count();
  expect(hasWarnings + noWarnings).toBe(1);
});

test("the video panel shows the digest as stale after a config change", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });
  await runDigest(page, CHANNEL);

  await page.goto(`/channels/${CHANNEL}/videos/${VIDEO}`);
  await expect(page.getByLabel("digest freshness")).toHaveText("current");

  // A real identity change — the same path a prompt or model change takes.
  await writeSettings(
    digestSettings({ apps: { "ollama-direct": { model: "qwen2.5:7b-v2" } } }),
  );

  await page.goto(`/channels/${CHANNEL}/videos/${VIDEO}`);
  await expect(page.getByLabel("digest freshness")).toContainText("stale");
  await expect(page.getByLabel("digest section chapters")).toContainText(
    "qwen2.5:7b-v2",
  );
});

test("corrections saved from the panel land in the overrides sidecar only", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });
  await runDigest(page, CHANNEL);

  const before = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  const firstId = (before.sections.chapters?.items ?? [])[0]?.id;
  expect(firstId).toBeTruthy();

  await page.goto(`/channels/${CHANNEL}/videos/${VIDEO}`);
  await page.getByText("Correct this digest").click();
  await page
    .getByLabel(`title for chapter ${firstId}`)
    .fill("Renamed from the panel");
  await page.getByLabel("digest override note").fill("panel e2e");
  await page.getByRole("button", { name: "Save corrections" }).click();
  await expect(page.getByRole("status").filter({ hasText: "Saved" })).toBeVisible();

  const overrides = await readJson<DigestOverrides>(
    overridesPath(CHANNEL, VIDEO),
  );
  expect(overrides.chapters?.[0].title).toBe("Renamed from the panel");
  expect(overrides.chapters?.[0].decidedBy).toBe("human");
  expect(overrides.note).toBe("panel e2e");

  // The machine file is untouched — the invariant the two sidecars exist for.
  const after = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  expect(after.sections.chapters?.items[0].title).toBe(
    before.sections.chapters?.items[0].title,
  );

  // And the composed view reports the edit as human.
  await page.goto(`/channels/${CHANNEL}/videos/${VIDEO}`);
  await expect(page.getByLabel("digest chapters")).toContainText(
    "Renamed from the panel",
  );
});

// ---------------------------------------------------------------------------
// Tags — a capability that shipped and then never ran.
//
// `parseTags`, a tags JSON schema, a `sections` branch in digestVideo and a
// per-section checkbox in the settings form all existed for months, and 0 of the
// 109 sidecars on disk had ever contained a tags section. No metric counted them,
// no bake-off round scored them, and nothing here covered them — so the whole
// path could have been broken end to end and every test would still have passed.
// This is the test that makes that impossible to repeat.
// ---------------------------------------------------------------------------

test("a digest run with tags enabled writes a tags section", async ({ page }) => {
  await resetData(null);
  // The one thing this spec varies. Chapters stay on so the test also proves the
  // two sections coexist in ONE record rather than overwriting each other —
  // writeDigestSection merges per section, and a regression there would silently
  // cost whichever section was written first.
  await writeSettings(digestSettings({ sections: ["chapters", "tags"] }));
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  await runDigest(page, CHANNEL);

  const record = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));

  const tags = record.sections.tags?.items ?? [];
  expect(tags.length).toBeGreaterThan(0);
  // Every tag is lowercase, non-empty and carries an id — parseTags' contract.
  for (const t of tags) {
    expect(t.tag).toBe(t.tag.toLowerCase());
    expect(t.tag.trim().length).toBeGreaterThan(0);
    expect(t.id).toBeTruthy();
    expect(t.decidedBy).toBe("ai");
  }
  // Deduplicated: chunks overlap, so the same tag arrives repeatedly and the
  // parser is responsible for collapsing it.
  expect(new Set(tags.map((t) => t.id)).size).toBe(tags.length);

  // Both sections present, each with its OWN provenance — they are generated by
  // separate calls and expire independently.
  expect(record.sections.chapters?.items.length).toBeGreaterThan(0);
  expect(record.sections.tags?.provenance.appId).toBe("ollama-direct");
  expect(record.sections.tags?.provenance.chunks).toBeGreaterThan(0);
  expect(record.sections.tags?.provenance.chunksOk).toBeGreaterThan(0);

  // The timing breakdown must NOT reach the sidecar: it is diagnostic only, and a
  // field landing in provenance would change the freshness identity and silently
  // invalidate every digest in the corpus.
  const provenance = record.sections.tags?.provenance as
    | Record<string, unknown>
    | undefined;
  for (const field of ["loadMs", "promptEvalMs", "evalMs", "totalMs", "durationMs"]) {
    expect(provenance).not.toHaveProperty(field);
  }
});

// Tags are OPT-IN and must stay that way: the default is chapters alone, and a
// sweep that quietly started generating tags would be spending GPU-weeks nobody
// asked for.
test("tags are not generated unless the setting asks for them", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings()); // sections: ["chapters"]
  await writeChannelConfig(CHANNEL);
  await writeDigestVideo({ channelSlug: CHANNEL, videoId: VIDEO });

  await runDigest(page, CHANNEL);

  const record = await readJson<DigestRecord>(digestPath(CHANNEL, VIDEO));
  expect(record.sections.chapters?.items.length).toBeGreaterThan(0);
  expect(record.sections.tags).toBeUndefined();
});

// ---------------------------------------------------------------------------
// Deferred: a transcript with no normalized sidecar, and the button that fixes it
//
// The state this covers is 1,942 videos on the live corpus and was permanently
// invisible to the digest lane: transcribeOne is the ONLY automatic caller of
// normalizeTranscript, so a channel whose subtitles are DOWNLOADED (handling
// "youtube", which passes --skip-download) never writes transcript.cues.json at
// all. buildIndex re-parses the raw VTT when the sidecar is absent, so the
// published site is correct and nothing else in the system notices — but the
// digest lane has no such fallback, and these videos are excluded from a sweep
// that costs GPU-weeks.
//
// The card used to report them under copy that said the normalize pass would
// clear them on its own. Nothing runs it on its own. So this test asserts all
// three halves: the count, the honest copy, and that the button turns a deferred
// video into reachable digest work.
// ---------------------------------------------------------------------------

const UNNORMALIZED = "digestvid0002";

// generateReport short-circuits on an existing snapshot, and the classification
// here is derived from disk — so a re-read after a mutation must drop the
// snapshot first or it reports the pre-normalize world forever.
async function regenerateReport(
  page: import("@playwright/test").Page,
  slug: string,
): Promise<void> {
  await rm(resolvePath(`test-transcripts/channels/${slug}/snapshot.json`), {
    force: true,
  });
  await generateReport(page, slug);
}

test("a transcript with no cues.json is deferred, and Normalize transcripts makes it digestable", async ({
  page,
}) => {
  await resetData(null);
  await writeSettings(digestSettings());
  await writeChannelConfig(CHANNEL);
  // Exactly the live shape: a real VTT, real metadata, no sidecar.
  await writeDigestVideo({
    channelSlug: CHANNEL,
    videoId: UNNORMALIZED,
    skipCuesJson: true,
  });

  const cuesRel = join(
    "test-transcripts",
    "channels",
    CHANNEL,
    "data",
    UNNORMALIZED,
    "transcript.cues.json",
  );
  expect(await pathExists(cuesRel)).toBe(false);

  await generateReport(page, CHANNEL);
  await page.goto(channelStage(CHANNEL, "digest"));

  // Counted as deferred — NOT as reachable work, and NOT as blocked (the video
  // is transcribed; nothing is waiting on the transcription lane).
  const deferredLine = page.getByLabel("digest deferred");
  await expect(deferredLine).toContainText("1");
  await expect(deferredLine).toContainText("transcript.cues.json");
  // The retracted claim. The old copy said the normalize pass clears these; it
  // does, but only when somebody runs it, and nothing does.
  await expect(deferredLine).toContainText("does not clear itself");
  await expect(
    page.getByRole("heading", { name: "Generate digests (0)" }),
  ).toBeVisible();

  // The affordance the card had no version of before this change.
  await page.getByRole("button", { name: "Normalize transcripts" }).click();
  await expect(page.getByLabel("Normalize transcripts output")).toContainText(
    "1 written",
    { timeout: 60_000 },
  );
  expect(await pathExists(cuesRel)).toBe(true);

  // And the point of all of it: the video is now work the digest lane will take.
  await regenerateReport(page, CHANNEL);
  await page.goto(channelStage(CHANNEL, "digest"));
  await expect(
    page.getByRole("heading", { name: "Generate digests (1)" }),
  ).toBeVisible();
  await expect(page.getByLabel("digest deferred")).toHaveCount(0);
  // The button retires with the count it existed to clear.
  await expect(
    page.getByRole("button", { name: "Normalize transcripts" }),
  ).toHaveCount(0);
});