feat(linkedin): newsletter Step 5-6 fact-check + persona sweep before lock (S9)

plugins/linkedin-thought-leadership/commands/newsletter.md

@@ -70,11 +70,12 @@ single most important correction from the Seres process (plan §0.4, principle 5
 | 9 | **Hook / conversion gate** | persona gate on the distribution text post-lock: "would YOU click?" | **`persona-reviewer`** (conversion mode) |
 | 10 | **Scheduling** | register the edition in the plugin queue/state for native scheduling | `hooks/scripts/queue-manager.mjs` |
 
-> **Build status:** Steps 0–4 are implemented below. Steps 5–10 are added in
+> **Build status:** Steps 0–6 are implemented below. Steps 7–10 are added in a
-> subsequent build sessions (plan steps S9–S10). Until then, this command takes
+> subsequent build session (plan step S10). Until then, this command takes an
-> an edition from load → calibration → verified research → draft →
+> edition from load → calibration → verified research → draft →
-> consistency/quality pass, persisting each phase to `edition-state.json` and
+> consistency/quality → fact-check sweep → pre-lock persona sweep, persisting
-> the HANDOVER and stopping cleanly between sessions.
+> each phase to `edition-state.json` and the HANDOVER and stopping cleanly
+> between sessions.
 
 ---
 
@@ -336,13 +337,152 @@ Consistency + quality pass complete.
 Next: Step 5 — Fact-check sweep (guilty-until-disproven, BEFORE lock).
 ```
 
+## Step 5: Fact-check sweep — guilty-until-disproven (BEFORE lock)
+
+Every factual claim in the consistency-passed draft (Step 4) is now treated as
+**guilty until proven** — it is not true until a primary or credible source
+confirms it. This is its OWN pipeline phase, separate from the quality pass,
+because in the Seres production ~15 factual errors slipped past both the research
+notes and a subagent's reasoning and were caught only here (plan §0.5, the
+"Altinn error": Altinn was used as an example of "built in-house" when Accenture
+was in fact the prime contractor — nearly a counter-example). Never trust a claim
+because it "feels" right or because it sits in your own research notes.
+
+> **This sweep runs BEFORE lock.** No edition is locked (Step 8) with an
+> unresolved 🔴 claim. Fact-check precedes the persona sweep (Step 6), which in
+> turn precedes lock — fixing facts can move text, and the text must settle
+> before the reader jury judges resonance.
+
+**Procedure:**
+
+1. **Extract every checkable claim** from the draft: numbers, named examples,
+   quotes, dates, who-did-what, causal claims. Skip opinions and predictions —
+   they are not claims to verify. Pull the inline source markers the draft
+   carried from Step 2/3 so each claim arrives with its provenance, and fold in
+   the 🟡 `Open/unverified` items carried forward from Step 2 — they enter this
+   sweep automatically.
+
+2. **Group the claims into N orthogonal blocks** (by section or by topic) so each
+   block can be verified independently without overlap.
+
+3. **Fan out in parallel — issue all N `fact-checker` calls in a SINGLE message**
+   (multiple `Task` tool-uses in one turn, `subagent_type: fact-checker`) so they
+   run concurrently, from THIS command layer in the foreground (principle 4, plan
+   §3). Each call gets one claim-block and returns the agent's standard
+   verification log + risk-sort (🔴/🟡/🟢) + gate decision (PASS/REWORK/BLOCK).
+   Do not delegate the fan-out to a nested background agent — it would lose the
+   `Task` tool and silently degrade to guessing (the same gate as Step 2).
+
+4. **Detect degradation (gate).** Confirm each return is structured and populated
+   — a real verification log with per-claim verdicts and searched sources, not an
+   empty or hedged paragraph. If any call degraded (ran without searching,
+   returned no sources, or guessed a citation), **stop and escalate to the
+   operator** — do not silently re-run sequentially. `[GATE]`
+
+5. **Merge into one verification log + risk sort.** Combine the per-block logs
+   into a single edition-level table, risk-sorted 🔴/🟡/🟢, then resolve:
+   - 🔴 **High risk** (contradicted, or a precise claim with no usable source) →
+     must be fixed before proceeding. Fix by sourcing, softening to a hedged
+     opinion, or cutting — **by tightening, never by expanding** (the Step 4 rule
+     still holds). Re-run the relevant `fact-checker` call on the fix.
+   - 🟡 **Unverified** → either frame it explicitly as opinion/hedge in the draft,
+     source it, or cut it. A 🟡 left asserted as bare fact is a REWORK.
+   - 🟢 **Verified** → keep; record its source in the verification log.
+
+   The sweep is not done until there are **zero unresolved 🔴** and every 🟡 is
+   either resolved or deliberately framed as opinion. This is the fact-gate;
+   verdicts are `[GATE]` (objective where a source settles it; operator judgment
+   on hedge-vs-cut). Flag any time-sensitive figure (e.g. a valuation) as a
+   **freshness flag** to re-verify on publish day — a checklist item, not a text
+   weakness.
+
+6. **Persist + checkpoint state.** Write the merged verification log into the
+   edition-HANDOVER §4 (immutable rules + fact-check log — the durable record of
+   what was checked), set `currentPhase: "factcheck"` in `edition-state.json`,
+   and append a "fact-check complete → next: persona sweep (BEFORE lock)" pointer
+   to the HANDOVER §6.
+
+```
+Fact-check sweep complete.
+- Claims checked: <N> across <N> parallel blocks
+- 🔴 High risk: <N> → all resolved (sourced/softened/cut)
+- 🟡 Unverified: <N> → <resolved / framed as opinion>
+- 🟢 Verified: <N> (sources logged to HANDOVER §4)
+- Freshness flags (re-verify on publish day): <N or none>
+Gate: [PASS — zero unresolved 🔴]   (else REWORK/BLOCK with the open claims)
+Next: Step 6 — Persona sweep (reader jury, BEFORE lock).
+```
+
+## Step 6: Persona sweep — reader jury, BEFORE lock
+
+The fact-checked draft now faces the **reader jury**: the personas selected in
+Step 1 read it read-only and judge whether it *lands* — not whether it is correct
+(that was Step 5), not whether it is original. This is the **single most
+important ordering rule in the whole pipeline.** In the Seres production this
+sweep was originally run *after* the texts were locked (Step 8), which forced
+reopening locked texts — the biggest single process error of the series (plan
+§0.4). **It runs here, FØR lås / before lock, without exception.**
+
+> **Order assertion (enforced).** This persona sweep (Step 6) precedes lock
+> (Step 8). The pipeline may NOT proceed to Step 8 until the primær persona
+> returns a clean JA from this sweep. A wiring that locked first and reviewed
+> after would reproduce the exact Seres failure — do not do it. `[GATE]`
+
+**Procedure:**
+
+1. **Load the active personas** chosen in Step 1, with exactly one marked
+   **primær**. Each persona's five fields (rolle, avkobler, overbeviser,
+   ekspertise, sjargong) come from `config/personas.local.md` (or the template).
+
+2. **Fan out one `persona-reviewer` call per persona, in parallel** — issue them
+   in a SINGLE message (multiple `Task` tool-uses, `subagent_type:
+   persona-reviewer`), from THIS command layer in the foreground (principle 4).
+   Pass each call its persona name and **`mode: resonans`** (the before-lock mode
+   — all six axes, ≤5 flags as direction). This is NOT conversion mode, which is
+   the post-lock hook-gate in Step 9. One persona per run — never mix two.
+
+3. **Collect verdicts and gate.** Each call returns per-axis flags
+   (LØST/DELVIS/IKKE), ≤5 direction-only flags, a per-persona verdict (JA/NEI),
+   and a gate decision. Aggregate per the agent's rule:
+   - **primær JA** + no real (non-ceiling) sekundær IKKE → PASS, ready to lock.
+   - **primær NEI**, or a fixable DELVIS/IKKE → REWORK.
+   - **primær NEI on Krok or Leder-takeaway** → BLOCK (the reader never starts,
+     or leaves with nothing to do) — must be reworked before lock.
+   A *sekundær* NEI from a role mismatch or expertise ceiling is a SIGNAL the gate
+   works — accept it; do not distort the text to chase it (plan §0.5, "primær
+   trumfer"). The jury returns **direction only** — the editor (this session)
+   holds the pen; never paste a persona's rewritten copy. `[GATE]`
+
+4. **Convergence loop.** If the gate is REWORK/BLOCK, fold the flags into the
+   draft **by tightening** (the Step 4 rule holds — close the gap, hold the length
+   flat), then **re-run the same `persona-reviewer` calls** against the revised
+   draft. Each round re-judges every prior flag as LØST / DELVIS / IKKE. Loop
+   until the primær returns a clean JA (in Seres this took 2 rounds). Re-run only
+   the personas whose verdicts are still open.
+
+5. **Persist + checkpoint state.** Record the final per-persona verdicts and the
+   resolved flags in the edition-HANDOVER §5 (method / persona calibration), set
+   `currentPhase: "persona"` in `edition-state.json`, and append a "persona sweep
+   PASS (primær JA) → next: lock/delivery" pointer to the HANDOVER §6.
+
+```
+Persona sweep complete (BEFORE lock).
+- Personas run: <N> (primær: <name>)
+- Convergence rounds: <N>
+- primær verdict: JA   (else: still NEI — loop open, NOT ready to lock)
+- Accepted sekundær ceiling-NOs (signal, not failure): <N or none>
+Gate: [PASS — primær JA, ready to lock]   (else REWORK/BLOCK)
+Next: Step 7 — Annotation (optional), then Step 8 — LOCK → delivery.
+```
+
 ---
 
-## Steps 5–10 (added in subsequent build sessions)
+## Steps 7–10 (added in a subsequent build session)
 
-The fact-check sweep, the pre-lock persona sweep, optional annotation,
+Optional annotation (render annotatable review HTML), lock/delivery (POST.html
-lock/delivery, the post-lock hook-gate, and scheduling are implemented in plan
+"all in one place"), the post-lock hook/conversion gate (`persona-reviewer` in
-steps S9–S10. Each will append its phase here, reading the phase contract from
+konverter-modus), and scheduling are implemented in plan step S10. Each will
+append its phase here, reading the phase contract from
 `config/edition-state.template.json` and (once extracted in S12) the long-form
 quality rules from `references/longform-quality-rules.md`.