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/specifics-bank/tests/cli-usage.test.ts

@@ -0,0 +1,142 @@
+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 } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { addSpecific, emptyBank, specificId, saveBank } from "../src/bank.js";
+
+// Resolve the package root so the subprocess `src/cli.ts` path + the `tsx` loader
+// resolve regardless of the runner's cwd.
+const bankDir = 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: bankDir,
+  });
+  return { status: res.status, stdout: res.stdout, stderr: res.stderr };
+}
+
+const tmp = () => mkdtempSync(join(tmpdir(), "specifics-cli-usage-"));
+
+const CONTENT = "Vi målte 40 prosent kortere ledetid etter omleggingen.";
+
+/** A bank + an edition-state whose slot-map binds one slot to the bank specific. */
+function fixture(dir: string): { bankPath: string; editionPath: string; id: string } {
+  const bankPath = join(dir, "specifics-bank.json");
+  const id = specificId(CONTENT);
+  const bank = addSpecific(emptyBank(), {
+    type: "number",
+    content: CONTENT,
+    topicTags: ["ai"],
+    provenance: { capturedAt: "2026-06-20", source: "test" },
+  }).bank;
+  saveBank(bankPath, bank);
+
+  const editionPath = join(dir, "edition-state.json");
+  writeFileSync(
+    editionPath,
+    JSON.stringify({
+      currentArticle: "05",
+      articles: {
+        "05": {
+          title: "Da pipelinen brøt sammen",
+          livedSpecifics: {
+            status: "bound",
+            slots: [
+              { slotId: "kp1", kind: "key-point", label: "ledetid", binding: { type: "specific", specificId: id } },
+              { slotId: "kp2", kind: "key-point", label: "annet", binding: { type: "abstrakt", rationale: "bevisst" } },
+            ],
+          },
+        },
+      },
+    }),
+    "utf8",
+  );
+  return { bankPath, editionPath, id };
+}
+
+describe("specifics-bank CLI — record-usage (Step 8 lock)", () => {
+  test("stamps the edition on the bound specifics and persists it", () => {
+    const dir = tmp();
+    try {
+      const { bankPath, editionPath, id } = fixture(dir);
+
+      const res = run(["record-usage", "--edition", editionPath, "--edition-id", "seres/05", "--bank", bankPath]);
+      assert.equal(res.status, 0, res.stderr);
+
+      const onDisk = JSON.parse(readFileSync(bankPath, "utf8"));
+      const stamped = onDisk.specifics.find((s: { id: string }) => s.id === id);
+      assert.deepEqual(stamped.usedIn, ["seres/05"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("only specific-bound slots are stamped — abstrakt/ekstern consume no bank material", () => {
+    const dir = tmp();
+    try {
+      const { bankPath, editionPath } = fixture(dir);
+      const res = run(["record-usage", "--edition", editionPath, "--edition-id", "seres/05", "--bank", bankPath, "--json"]);
+      assert.equal(res.status, 0, res.stderr);
+
+      const out = JSON.parse(res.stdout);
+      assert.equal(out.recorded.length, 1);
+      assert.deepEqual(out.unknown, []);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("re-running after a pivot re-lock is idempotent", () => {
+    const dir = tmp();
+    try {
+      const { bankPath, editionPath, id } = fixture(dir);
+      run(["record-usage", "--edition", editionPath, "--edition-id", "seres/05", "--bank", bankPath]);
+      const again = run(["record-usage", "--edition", editionPath, "--edition-id", "seres/05", "--bank", bankPath, "--json"]);
+      assert.equal(again.status, 0, again.stderr);
+
+      const out = JSON.parse(again.stdout);
+      assert.deepEqual(out.recorded, []);
+      assert.equal(out.alreadyRecorded.length, 1);
+
+      const onDisk = JSON.parse(readFileSync(bankPath, "utf8"));
+      const stamped = onDisk.specifics.find((s: { id: string }) => s.id === id);
+      assert.deepEqual(stamped.usedIn, ["seres/05"], "a re-lock must not double-stamp");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("an edition with no bound specifics is a no-op, exit 0", () => {
+    const dir = tmp();
+    try {
+      const { bankPath } = fixture(dir);
+      const empty = join(dir, "empty-edition.json");
+      writeFileSync(empty, JSON.stringify({ currentArticle: "06", articles: { "06": {} } }), "utf8");
+
+      const res = run(["record-usage", "--edition", empty, "--edition-id", "seres/06", "--bank", bankPath, "--json"]);
+      assert.equal(res.status, 0, res.stderr);
+      assert.deepEqual(JSON.parse(res.stdout).recorded, []);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("bad invocations exit 2", () => {
+    const dir = tmp();
+    try {
+      const { bankPath, editionPath } = fixture(dir);
+      assert.equal(run(["record-usage", "--bank", bankPath]).status, 2); // no --edition
+      assert.equal(
+        run(["record-usage", "--edition", editionPath, "--bank", bankPath]).status,
+        2, // no --edition-id: an unattributable use is worse than none
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});