feat(linkedin-studio): N11 — serie-destillat + skjelett-sjekk + specifics-bank bruks-logging [skip-docs]

Every long-form gate agent sees ONE edition, so «the reader has heard this
before» was structurally invisible — and the specifics-bank dedupe actively
encouraged re-surfacing the same material. At series cadence that is the
fastest-growing defect class. N11 makes it visible BEFORE the skeleton is
approved, at two grains:

- Series grain — new scripts/editions package: each locked edition's spent
  anecdotes/arguments/hooks are written to <serie>/linkedin/series-distillate.json
  at Step 8 lock (distil-append), and the next skeleton is checked against it at
  Step 2.5 (distil-check) with the finding folded into the annotation gate the
  operator already reads. Advisory, never blocking: a deliberate callback is a
  legitimate move, an unnoticed retread is not.
- Material grain — specifics-bank usedIn log: record-usage stamps «used in
  edition NN» on the specifics an edition actually consumed (read from the bound
  slot-map, so abstrakt/ekstern stamp nothing). At lock, so it means published;
  idempotent under a pivot re-lock. Additive-optional, schema stays v1.

Placement deviates from the plan text (${DATA}) after premise-verification:
per-series state belongs in the series root beside edition-state.json, where
Step 0 already resolves the path and no slug→path map is needed. Operator
approved. The distillate module also lands in scripts/editions now rather than
at N12, since the AC required a testable roundtrip and N12 planned that package
anyway — N12 extends it instead of creating it.

Similarity is character-trigram Jaccard, not word overlap: the plugin is
language-general and inflection (migrere/migreringen) breaks word tokens.
Calibrated on real paraphrase pairs — retellings 0.44-0.55, unrelated 0.04-0.06,
same-topic-different-story 0.24 — so the default threshold sits in the gap at
0.40. Word-Jaccard scored a shortened hook paraphrase at 0.11.

TDD (Iron Law): tests written first and verified red before implementation, for
both the new package and the bank logging.

Suites: editions 27/0 (new suite line + guard, floor 27) · specifics-bank
28 -> 45 · test-runner 163 -> 173 (Section 16r: 9 unconditional greps +
non-vacuity self-test; anti-erosion floor 146 -> 155) · trends 300/0 ·
brain 134/0 · hooks 140/0 · tests 35/0 · render 60/0. tsc --noEmit clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QxvWAjte7vPcF79QeSRvRJ

scripts/editions/tests/cli.test.ts

@@ -0,0 +1,152 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Resolve the package root (scripts/editions) so the subprocess `src/cli.ts` path +
+// the `tsx` loader resolve regardless of the runner's cwd.
+const editionsDir = fileURLToPath(new URL("..", import.meta.url));
+
+function run(args: string[]): { status: number | null; stdout: string; stderr: string } {
+  const res = spawnSync("node", ["--import", "tsx", "src/cli.ts", ...args], {
+    encoding: "utf8",
+    cwd: editionsDir,
+  });
+  return { status: res.status, stdout: res.stdout, stderr: res.stderr };
+}
+
+const tmp = () => mkdtempSync(join(tmpdir(), "editions-cli-"));
+
+const EXTRACT = {
+  editionId: "05",
+  title: "Da pipelinen brøt sammen",
+  lockedAt: "2026-07-20",
+  anecdotes: ["Jeg brukte tre uker på å migrere pipeline-en, og halvparten av tiden gikk til testdata."],
+  arguments: ["Modellen var ikke problemet — det var dataene ingen hadde ryddet på fem år."],
+  hooks: ["De fleste AI-prosjekter dør ikke av dårlig modell. De dør av dårlig data."],
+};
+
+describe("editions CLI — distil-append / distil-check round-trip (N11 AC)", () => {
+  test("append -> check round-trips through a real file and flags the reuse", () => {
+    const dir = tmp();
+    try {
+      const distillate = join(dir, "linkedin", "series-distillate.json");
+      const extract = join(dir, "extract.json");
+      const skeleton = join(dir, "skeleton.json");
+      writeFileSync(extract, JSON.stringify(EXTRACT), "utf8");
+
+      // 1. lock writes the distillate (file did not exist)
+      const appended = run(["distil-append", "--distillate", distillate, "--series", "seres", "--extract", extract]);
+      assert.equal(appended.status, 0, appended.stderr);
+      assert.ok(existsSync(distillate), "distil-append must create the distillate file");
+      const onDisk = JSON.parse(readFileSync(distillate, "utf8"));
+      assert.equal(onDisk.series, "seres");
+      assert.equal(onDisk.editions.length, 1);
+      assert.equal(onDisk.editions[0].editionId, "05");
+
+      // 2. a later skeleton reusing the same hook is flagged, with attribution
+      writeFileSync(skeleton, JSON.stringify({ hooks: [EXTRACT.hooks[0]] }), "utf8");
+      const checked = run(["distil-check", "--distillate", distillate, "--skeleton", skeleton, "--json"]);
+      assert.equal(checked.status, 0, checked.stderr);
+      const report = JSON.parse(checked.stdout);
+      assert.equal(report.verdict, "REUSE");
+      assert.equal(report.hits[0].editionId, "05");
+      assert.equal(report.hits[0].kind, "hook");
+
+      // 3. fresh material on the same distillate is CLEAR
+      writeFileSync(
+        skeleton,
+        JSON.stringify({ hooks: ["Innkjøpsavdelingen krevde en garanti vi ikke kunne gi uten revisjon."] }),
+        "utf8",
+      );
+      const clear = run(["distil-check", "--distillate", distillate, "--skeleton", skeleton, "--json"]);
+      assert.equal(clear.status, 0, clear.stderr);
+      assert.equal(JSON.parse(clear.stdout).verdict, "CLEAR");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("re-appending the same edition replaces it — a pivot re-lock does not duplicate", () => {
+    const dir = tmp();
+    try {
+      const distillate = join(dir, "series-distillate.json");
+      const extract = join(dir, "extract.json");
+      writeFileSync(extract, JSON.stringify(EXTRACT), "utf8");
+      run(["distil-append", "--distillate", distillate, "--series", "seres", "--extract", extract]);
+
+      writeFileSync(extract, JSON.stringify({ ...EXTRACT, title: "Revidert" }), "utf8");
+      const again = run(["distil-append", "--distillate", distillate, "--series", "seres", "--extract", extract]);
+      assert.equal(again.status, 0, again.stderr);
+
+      const onDisk = JSON.parse(readFileSync(distillate, "utf8"));
+      assert.equal(onDisk.editions.length, 1);
+      assert.equal(onDisk.editions[0].title, "Revidert");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("distil-check against a distillate that does not exist yet is CLEAR, not an error", () => {
+    const dir = tmp();
+    try {
+      const skeleton = join(dir, "skeleton.json");
+      writeFileSync(skeleton, JSON.stringify({ hooks: ["første utgave i serien"] }), "utf8");
+      const res = run([
+        "distil-check",
+        "--distillate",
+        join(dir, "absent.json"),
+        "--skeleton",
+        skeleton,
+        "--json",
+      ]);
+      assert.equal(res.status, 0, res.stderr);
+      const report = JSON.parse(res.stdout);
+      assert.equal(report.verdict, "CLEAR");
+      assert.equal(report.comparedAgainst, 0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("human-readable output names the reused unit and its edition", () => {
+    const dir = tmp();
+    try {
+      const distillate = join(dir, "d.json");
+      const extract = join(dir, "extract.json");
+      const skeleton = join(dir, "skeleton.json");
+      writeFileSync(extract, JSON.stringify(EXTRACT), "utf8");
+      run(["distil-append", "--distillate", distillate, "--series", "seres", "--extract", extract]);
+      writeFileSync(skeleton, JSON.stringify({ hooks: [EXTRACT.hooks[0]] }), "utf8");
+
+      const res = run(["distil-check", "--distillate", distillate, "--skeleton", skeleton]);
+      assert.equal(res.status, 0, res.stderr);
+      assert.match(res.stdout, /REUSE/);
+      assert.match(res.stdout, /05/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("bad invocations exit 2 with usage on stderr", () => {
+    const dir = tmp();
+    try {
+      assert.equal(run(["distil-append", "--series", "seres"]).status, 2); // no --extract/--distillate
+      assert.equal(run(["distil-check"]).status, 2); // no --skeleton
+      assert.equal(run(["nonsense"]).status, 2);
+      assert.equal(run([]).status, 2);
+
+      // an extract missing required fields is a usage error, not a silent empty entry
+      const bad = join(dir, "bad.json");
+      writeFileSync(bad, JSON.stringify({ title: "no id" }), "utf8");
+      const res = run(["distil-append", "--distillate", join(dir, "d.json"), "--series", "s", "--extract", bad]);
+      assert.equal(res.status, 2);
+      assert.match(res.stderr, /editionId/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});