# Plan — RE-R3a: persist the relevance score + rank the morning brief on it

> **Brief:** `docs/research-engine/brief-re-r3a.md`. **Slice:** RE-R3a (research-engine rung-2 — R3 slice 1,
> research-deepening: the relevance half of hull 5 + the hull-3 schema remainder).
> **TDD-order (two-phase RED — light-Voyage BLOCKER fold):** Step 1 records RED in two phases —
> **(A)** true logic-RED for `store`/`brief`/`cli` against the pre-edit code (inline fixtures, no new import);
> **(B)** for `score`/`item`, land non-throwing stubs for the new `score.ts` exports first (Node16 ESM throws a
> missing named import at module-load, not on assertion), then record the value-assertion RED against the stubs.
> Then GREEN: S-score envelope → S-types + S-store (first-sight persist + v2→v3 migrate) → S-item (validate +
> bridge) → S-brief (composite-sort + render band+mode) → S-cli (doc-only) → wire `trend-spotter.md` + README →
> gate floors + Section 16j → behavioural → land.
> **Counts recounted live at land, never pinned/guessed.**
> **Go-gate decisions (confirmed "Go" 2026-06-24):** D1 4-field `TrendScore` · D2 composite primary within
> bucket · D3 first-sight · D4 one slice (data-then-visible commit order) · D6 mode shown in per-entry render.
> **Light-Voyage hardened:** scope-guardian ALIGNED (0) / brief-reviewer PROCEED_WITH_RISKS (6 MINOR) /
> plan-critic REVISE (1 BLOCKER, 4 MAJOR, 4 MINOR) — all folded (see §Plan-critic — folded).

## Goal

Stop discarding the relevance judgment the `trend-spotter` agent already computes. Persist a 4-field
`TrendScore { mode, dimensions, composite, priority }` on the store record (schema v2→v3, additive lossless
migrate — the R2a pattern), computed deterministically from the agent's five judgment scores by the already-built
`score.ts` (`composite`+`band`, one owner). Then make `rankForBrief` order each bucket on composite first, and
`renderBrief` surface the band + mode. No re-score-on-recapture, no saturation/status, no scheduler, no new
source file — those stay later R3 slices.

## Files touched (exhaustive — for scope-guardian)

| File | Change | SC |
|---|---|---|
| `scripts/trends/src/score.ts` | **EDIT** — `TrendScore` interface + `requiredDimensions(mode)` (ordered) + `scoreEnvelope(mode, dimensions)` (composes the existing `composite`+`band`, no new arithmetic; throws on bad dim by contract) | SC1 |
| `scripts/trends/src/types.ts` | **EDIT** — `import type { TrendScore }`; `TrendRecord.score?: TrendScore`; `SCHEMA_VERSION` 2→3; doc-comment | SC4 |
| `scripts/trends/src/store.ts` | **EDIT** — `TrendInput.score?: TrendScore`; `addTrend` persists `score` first-sight on add (conditional spread), duplicate does NOT update; migrate comment v1→v2→v3 (logic unchanged) | SC3, SC4 |
| `scripts/trends/src/item.ts` | **EDIT** — `TrendItem.score?: {mode,dimensions}`; `normalizeItem` validates (non-array `score`/`dimensions`; mode; the mode's five dims in [1,10]) → structured error, carries validated dims; `itemToInput` carries `scoreEnvelope(...)` (throws by contract on direct bad dims) | SC2 |
| `scripts/trends/src/brief.ts` | **EDIT** — `rankForBrief` comparator: composite primary (`?? -1`), buckets unchanged; `renderBrief`/`renderBulletEntry` surface `· <priority> (<mode>)` (full pinned shapes); `briefSummary` band only; exact `ranking:` descriptor | SC5, SC6 |
| `scripts/trends/src/cli.ts` | **EDIT (doc-only behavior)** — capture persists score automatically via `itemToInput` (no logic change); header doc-comment note | SC7 |
| `scripts/trends/tests/score.test.ts` | **EDIT** — `requiredDimensions` (both modes, ordered + order pinned) + `scoreEnvelope` (composite/priority = existing funcs; bad dim throws) | SC1 |
| `scripts/trends/tests/item.test.ts` | **EDIT** — score validation (valid carried/validated dims; bad mode/missing/out-of-range/non-array/array-dims → structured error, no throw) + `itemToInput` envelope + `itemToInput` direct bad-dim throws | SC2 |
| `scripts/trends/tests/store.test.ts` | **EDIT** — first-sight persist (new persists; duplicate keeps first score, topics union; score-free add) + v2→v3 migration (lossless/idempotent + score-survives-round-trip, mirrors `:403-476` with `2`→`3`) | SC3, SC4 |
| `scripts/trends/tests/brief.test.ts` | **EDIT** — composite-primary within bucket; unscored last (`-1`); total order; full render lines (`· <priority> (<mode>)` scored / unchanged unscored); summary band; unscored single-match-top summary; quote-safe summary; exact `ranking:` string; determinism | SC5, SC6 |
| `scripts/trends/tests/cli.test.ts` | **EDIT** — capture batch with score → record carries computed composite/priority (read back via `list --json`); bad score → `errors[]`, valid added, exit 0 | SC7 |
| `agents/trend-spotter.md` | **EDIT** — Step 4.5 capture batch carries per-item `"score":{"mode":"kortform","dimensions":{…}}`; prose ("carry the Step-2 scores"); domain-general; contains literal `"dimensions"` (currently absent → grep non-vacuous) | SC8 |
| `scripts/trends/README.md` | **EDIT** — item `score` field (judgment in) + persisted `TrendScore` (out) + brief ranks on composite | — |
| `scripts/test-runner.sh` | **EDIT** — `TRENDS_TESTS_FLOOR` 104→recount + breakdown comment (`:701`); NEW unconditional **Section 16j** (after 16i `~:1171` / before 18 `:1173`); `ASSERT_BASELINE_FLOOR` 94→**99**; header-enumeration chain (16i clause `:46-49`, Section-18 clause `:49`) | SC8 |
| `docs/research-engine/{brief,plan}-re-r3a.md` | **NEW** — slice docs (TRACKED, like `docs/second-brain/*`) | — |
| `STATE.md` | **EDIT at land** — Telling-block reconcile (trends floor, ASSERT floor 99, schema v3, gate total). *Land bookkeeping, LOCAL-ONLY.* | — |

**Not touched (scope fence):** `references/trend-scoring-modes.md` (SSOT weights/bands unchanged) · the
SessionStart hook + its tests (R3a touches no hook; no frontmatter-schema change; no new hook test) ·
`queryByTopic`/`history`/`newestCaptureDate` (store query unchanged) · the `score` CLI digest path + the `add`
manual path (`cli.ts`) · `config/*` · no new `.ts`/`.mjs` file · `agents/*` count (19) · `commands/*` (29) ·
`references/*` (27) · `.gitignore` (trends lines present).

## Step 1 — (RED, two phases) failing tests across score/item/store/brief/cli

RED discipline (R2a/R2b) + the light-Voyage BLOCKER fold: a missing **named** import throws at module-load under
Node16 ESM (`package.json:8` `node --import tsx --test`; `tsconfig.json` `module: Node16`), so `score`/`item`
(which reference new `score.ts` exports) cannot be assertion-RED before those exports exist. Split the RED proof:

**Phase A — true logic-RED against the pre-edit code** (`store`/`brief`/`cli` build fixtures inline; `TrendStore`/
`TrendRecord` are `import type`, erased by tsx; they import no new runtime symbol):
- `store.test.ts`: `addTrend(emptyStore, inputWithScore)` → record has `score`; a second `addTrend` (same
  title+url, **different** score) → stored score **unchanged**, `added:false`, topics unioned; score-free add →
  score-free record. **Migration:** a `schemaVersion:2` store with score-less records → `loadStore` gives
  `schemaVersion:3`, records intact, `"score" in record === false` (not invented); round-trip writes
  `schemaVersion:3`; a v3 store with `score` is idempotent; **a v3 store's `score` survives load+resave**
  (read back, re-save, re-read — `score` byte-identical). *(Mirror the RE-R2a block `store.test.ts:403-476`,
  retitled `(RE-R3a / score v2→v3)`, every `schemaVersion` assertion literal flipped `2`→`3`.)*
- `brief.test.ts`: two **same-overlap, same-freshness** records, composites 9 vs 6 → the 9 sorts first in its
  bucket; a **scored** vs **unscored** same-bucket pair → scored first (the `-1` sentinel); a same-title/diff-url
  **both-unscored** pair → fixed by `url asc` (total order intact); `renderBrief` for a scored top entry contains
  the **full line** `… (<age>d) · <priority> (<mode>) · Pillarer: …`, for an unscored one the **unchanged** line
  (no token) — assert full lines, not substrings; a scored bullet contains `… (<age>d) · <priority> (<mode>) ·
  🔗 …`; `briefSummary` names the band on a scored top, omits it on an unscored top, and is one line with no `"`
  **even when the top title contains a guillemet/quote**; a store whose only fresh match is a **single-pillar
  unscored** record → summary with no `· <priority>` token; the `ranking:` line equals the pinned string
  verbatim; two `renderBrief` calls byte-identical.
- `cli.test.ts`: a `capture` batch (subprocess, `--store` temp) with a valid per-item `score` → a following
  `list --store <tmp> --json` shows the record's `score` with the computed composite/priority; a batch with one
  bad score (`timing:99`) → JSON `errors[]` non-empty, the valid items added, **exit 0**.

**Phase B — stub-first, then value-assertion RED** (`score`/`item` reference new exports):
- Land **non-throwing stubs** in `score.ts` so the imports resolve: `requiredDimensions → []`; `scoreEnvelope →
  { mode, dimensions, composite: 0, priority: "Skip" }`. (These are the wrong-value stubs Step 2 replaces.)
- `score.test.ts`: `requiredDimensions("kortform")`/`("long-form")` deep-equal the two **ordered** five-key
  lists (and a guard that the order matches `Object.keys(KORTFORM_WEIGHTS)` so a SSOT reorder fails);
  `scoreEnvelope(mode, dims)` returns `{mode, dimensions, composite, priority}` with composite/priority **equal
  to `composite(dims,mode)` / `band(...).priority`** (assert against the existing functions — not hard-coded —
  so they share one owner); a bad dim makes `scoreEnvelope` throw (it calls `composite`). Fails on assertion
  against the stubs (`[] ≠ expected`, `composite 0 ≠ real`).
- `item.test.ts`: a valid `score` → `normalizeItem` `ok:true` carrying the **validated** dims; bad `mode` / a
  missing dimension / a dim `0` or `11` / a non-object `score` / an **array** `dimensions` → `ok:false` with an
  `invalid score` error (**does not throw**); absent `score` → key omitted. `itemToInput(validItemWithScore,
  "2026-06-24")` → `score` equals `scoreEnvelope(mode,dims)`; without score → no `score`; **`itemToInput` with an
  out-of-range dim throws** (the defense-in-depth contract). Fails on assertion against the stubs.

**RED proof (record in commit, two phases):** Phase A — `(cd scripts/trends && npm test)` before any src edit →
the `store`/`brief`/`cli` new cases fail on **assertion** (logic-RED), not module-not-found. Phase B — after the
non-throwing stubs land, the `score`/`item` cases fail on **value assertion** against the stubs. The plan does
**not** claim a single "all five fail before any code" run.

## Step 2 — (GREEN) `score.ts` envelope

In `scripts/trends/src/score.ts`:
- `export interface TrendScore { mode: ScoreMode; dimensions: DimensionScores; composite: number; priority:
  Priority }`.
- `export function requiredDimensions(mode: ScoreMode): string[] { return Object.keys(WEIGHTS[mode]); }` —
  **ordered** (insertion order of the SSOT weight literal); `score.test` pins the order.
- `export function scoreEnvelope(mode: ScoreMode, dimensions: DimensionScores): TrendScore { const c =
  composite(dimensions, mode); return { mode, dimensions, composite: c, priority: band(c).priority }; }` —
  composes the existing pure functions; **no new arithmetic**; throws via `composite` on a bad dim (its
  contract). Replace the Phase-B stubs. Make `score.test` green.

## Step 3 — (GREEN) `types.ts` + `store.ts` (schema v3 + first-sight persist)

- `types.ts`: `import type { TrendScore } from "./score.js";`; add `score?: TrendScore;` to `TrendRecord`
  (doc-comment marks it as the realized `:21-23` field); `SCHEMA_VERSION = 3`.
- `store.ts`: add `score?: TrendScore;` to `TrendInput` (`import type { TrendScore } from "./score.js"`);
  in `addTrend`'s new-record branch add `...(input.score !== undefined ? { score: input.score } : {})` (after the
  `summary` spread `:136`); the **duplicate** branch is unchanged (topics union only — score is first-sight,
  D3). Extend the `loadStore` migrate comment to *"v1→v2→v3 all additive-optional … the migration is the version
  stamp alone"* — **no logic change** (`Math.max(onDisk, SCHEMA_VERSION)` `:87` already handles v3; `saveStore`
  `JSON.stringify` `:95` preserves `score`). Make `store.test` green (first-sight + v2→v3 + survives-round-trip).

## Step 4 — (GREEN) `item.ts` (validate + bridge)

- `TrendItem` gains `score?: { mode: ScoreMode; dimensions: DimensionScores };` (`import type { ScoreMode,
  DimensionScores } from "./score.js"` + `import { requiredDimensions } from "./score.js"`).
- `normalizeItem`: after the `publishedAt` validation (`:99-106`), if `r.score !== undefined && r.score !==
  null`, validate: `score` is a **non-array** object; `mode` ∈ `{kortform, long-form}`; `dimensions` is a
  **non-array** object; **for each key in `requiredDimensions(mode)`**, the value is a number in [1,10]. On any
  failure `errors.push("invalid score: <reason>")`; on success build `score = { mode, dimensions }` from the
  **validated** values (not raw `r.score.dimensions`). Carried into the returned `TrendItem` via conditional
  spread (key omitted when absent/invalid). **Never throws** — structured errors only (the `publishedAt`
  discipline).
- `itemToInput`: add `...(item.score !== undefined ? { score: scoreEnvelope(item.score.mode,
  item.score.dimensions) } : {})` (`import { scoreEnvelope } from "./score.js"`). On the **capture path** the
  dims are pre-validated by `normalizeItem`, so `scoreEnvelope`→`composite` cannot throw there; called
  **directly** with bad dims it throws by contract (defense-in-depth — SC2 asserts it). Make `item.test` green.

## Step 5 — (GREEN) `brief.ts` (composite sort + render band+mode)

- `rankForBrief` comparator (`:94-98`): prepend `(b.trend.score?.composite ?? -1) - (a.trend.score?.composite
  ?? -1) ||` before the existing `b.overlap - a.overlap || …`. **Sentinel `-1`** (composite ≥ 1.0 always; `-1`
  sorts unscored last and subtracts cleanly). Buckets (`:100-104`) and totals unchanged.
- `renderTopEntry` (`:132-141`): when `e.trend.score` is present, insert `· ${e.trend.score.priority}
  (${e.trend.score.mode})` into the meta line **between `(${e.ageDays}d)` and `· Pillarer`** (unscored:
  unchanged). `renderBulletEntry` (`:143-145`): when scored, insert `· ${score.priority} (${score.mode})`
  **before `· 🔗`** (unscored: unchanged). Both shapes asserted as **full lines** in `brief.test`.
- `briefSummary` (`:122-130`): in the fresh>0 branch, when `top.trend.score` is present include `·
  ${top.trend.score.priority}` in the top mention (**band only — no mode** to keep the one-line headline clean):
  `… Topp: «<title>» (<pillar> · <priority> · <age>d).`; when the top is unscored omit the token:
  `… Topp: «<title>» (<pillar> · <age>d).` Keep it one line, no `"`/`\n`.
- `renderBrief`'s `ranking:` line (`:160`) → the **exact pinned** string
  `composite desc, then pillar-overlap desc, then publishedAt desc (capturedAt fallback); freshDays
  ${ranking.freshDays}` (asserted byte-for-byte). `BRIEF_SCHEMA_VERSION` stays 1. Make `brief.test` green.

## Step 6 — (GREEN) `cli.ts` (doc-only) + `cli.test`

`capture` (`:243-269`) already folds through `itemToInput` (`:254`), which now carries `score` → capture
persists it with **no logic change**. Update only the header doc-comment (`:15-21`): note `capture` persists an
optional relevance score computed from the item's judgment scores. Make `cli.test`'s capture-persists-score +
bad-score-in-errors cases green. *(No `today()` exact-value assertions in `cli.test` — the wall clock is read at
the edge; composite/priority are deterministic and asserted on the read-back record.)*

## Step 7 — wire `trend-spotter.md` (Open Q#1 default = WIRE) + README

In `agents/trend-spotter.md` Step 4.5 (`:291-298`), extend each capture-batch item with **`"score": {"mode":
"kortform", "dimensions": {"pillar": N, "audience": N, "timing": N, "angle": N, "authority": N}}`** — the same
five judgment scores computed in Step 2 (`:134`). Add prose: don't discard the Step-2 scores; fold them into the
capture batch so the store persists the relevance assessment and the morning brief ranks on it. Mode defaults
`kortform`; `long-form` when invoked from `/linkedin:newsletter` (the long-form dims are
`pillar/depth/angle/authority/currency`, `trend-scoring-modes.md:59-65`). The replacement prose **must contain
the literal `"dimensions"`** (Section 16j `grep -qF`; verified absent today → non-vacuous). Keep the "skip
silently if no deps" escape hatch + domain-general phrasing (Section 17). Update `scripts/trends/README.md`: the
item `score` field (judgment in), the persisted `TrendScore` (composite/priority out), and that the brief now
ranks on composite.

## Step 8 — gate: floors + new unconditional Section 16j

In `scripts/test-runner.sh`:
- Set `TRENDS_TESTS_FLOOR` (`:701`, currently 104) to the **`tests N` line** reported by `(cd scripts/trends &&
  npm test)` after Steps 1–6 — recounted live, NOT additive-guessed. Stays **inside** the `if [ -x …/tsx ]`
  deps guard. **Append** `+ RE-R3a: score +N` to the inline breakdown comment (`:701`) so it can't drift.
- Add **Section 16j** ("Trends Score Wiring", RE-R3a), mirroring Section 16i's shape (`:1122-1171`). **Placement
  (verified):** file order is 17→16g→16h→16i→18 (`:947/:1014/:1078/:1122/:1173`), so **16i is the last section
  before Section 18** — insert 16j **after 16i's closing `fi`/`echo ""` (~`:1171`), before the Section 18 block
  (`:1173`)** (anti-erosion Section 18 must stay last so it counts every prior check). Five **unconditional**,
  deps-absent-safe checks (pure `grep -qF`/self-test, no `tsx`), the self-test emitting **one** pass/fail like
  16i:
  (1) a non-vacuity self-test (a probe carrying `score?.composite` accepted, one without rejected);
  (2) `grep -qF 'export interface TrendScore' scripts/trends/src/score.ts`;
  (3) `grep -qF 'score?: TrendScore' scripts/trends/src/types.ts`;
  (4) `grep -qF '"dimensions"' agents/trend-spotter.md` (the capture batch carries the judgment);
  (5) `grep -qF 'score?.composite' scripts/trends/src/brief.ts` (the brief ranks on it — payoff wired, not
  merely doc'd).
- Bump `ASSERT_BASELINE_FLOOR` (`:1193`, currently 94) → **exactly 99** (94 + the 5 new unconditional 16j
  emitters; the self-test emits one pass/fail like 16i, so 99 is deterministic — "live recount" is the safety
  net, not a guess). Update the **header-enumeration prose chain** by inserting the 16j clause **between** the
  16i clause (`:46-49`) and the Section-18 clause (`:49`), preserving sentence flow (it's prose, not an append).
- **NOT touched here:** the hook suite (no `HOOK_TESTS_FLOOR` in `test-runner.sh`; R3a adds no hook test). It
  must still pass untouched (`node --test hooks/scripts/__tests__/`) as a regression sanity at land.

## Step 9 — behavioural verification

`(cd scripts/trends && npm install)` if needed, then run brief §7's four behavioural steps (capture A>B with
scores, `list --json` to confirm persisted composite/priority, `brief --json` to confirm A precedes B + the band
in the summary + `· <priority> (kortform)` in the entry line, a bad-score item lands in `errors[]` with exit 0).
Run full `bash scripts/test-runner.sh` → `FAIL=0` (`ASSERT_BASELINE_FLOOR` 99); run `node --test
hooks/scripts/__tests__/` → still green (untouched regression).

## Step 10 — land

Recount all touched floors live; reconcile STATE.md "Telling" block (trends N/N, ASSERT floor 99, schema v3,
gate total). Commit order (house style): **(1)** docs commit `docs/research-engine/{brief,plan}-re-r3a.md` (no
suffix, tracked); **(2)** code commit — the six `src/*.ts` + five test files + `agents/trend-spotter.md` +
`scripts/trends/README.md` + `scripts/test-runner.sh` with `[skip-docs]`. (Per D4, the code commit MAY be split
into a data commit [score/types/store/item/cli + their tests] and a visible commit [brief + its tests + agent
wire] if the R2a/R2b two-commit rhythm is preferred.) Push freely (window lifted; gitleaks at commit; `origin` =
PUBLIC `open/` — STATE/`*.local.*` never pushed). No version bump (additive; `v0.5.2` dev).

## Verification (testable)

| SC | Check | Command | Expected |
|---|---|---|---|
| — | RED Phase A | `(cd scripts/trends && npm test)` before src edits | store/brief/cli new cases fail on assertion (logic-RED), not module-not-found |
| — | RED Phase B | `npm test` after non-throwing stubs | score/item cases fail on value assertion against stubs (`[] ≠ expected`, `composite 0 ≠ real`) |
| SC1 | score envelope | `npm test` (score.test) | `requiredDimensions` both modes ordered (order pinned); `scoreEnvelope` composite/priority = existing funcs; bad dim throws |
| SC2 | item validate + bridge + contract | `npm test` (item.test) | valid score carried (validated dims); bad mode/missing/out-of-range/non-array/array-dims → structured error (no throw); `itemToInput` envelope; direct bad-dim throws |
| SC3 | first-sight persist | `npm test` (store.test) | new persists score; duplicate keeps first score (topics union); score-free add works |
| SC4 | migration v2→v3 | `npm test` (store.test) | v2 loads as v3, records intact, no score invented; round-trip writes v3; v3 idempotent; score survives load+resave |
| SC5 | brief ranks on composite | `npm test` (brief.test) + manual | composite primary within bucket; unscored last (`-1`); total order; deterministic |
| SC6 | render band+mode | `npm test` (brief.test) | full lines `· <priority> (<mode>)` scored / unchanged unscored; summary band (no mode); unscored single-match summary; quote-safe; exact `ranking:` string |
| SC7 | CLI persists score | `npm test` (cli.test) + manual | capture batch w/ score → record carries composite/priority; bad score → `errors[]`, valid added, exit 0 |
| SC8 | gate + wiring + de-niche | `bash scripts/test-runner.sh` | `FAIL=0`; trends ≥ floor; Section 16j green; `ASSERT_BASELINE_FLOOR`=99; Section 17; counts 27/19/29 |

## Risks

- **R1 — composite/band drift from the SSOT** (someone re-implements the math in `scoreEnvelope`). *Mitigated:*
  `scoreEnvelope` *composes* `composite()`+`band()` (one owner); SC1 asserts equality against those functions;
  `score.test.ts:12-30` (weights) + the band-string assertions already pin them to the SSOT.
- **R2 — a bad score crashes the capture loop.** *Mitigated:* `normalizeItem` fully validates the score (mode +
  the mode's five dims in [1,10], non-array objects) → structured error into `errors[]`; on the capture path
  `itemToInput`→`composite` is unreachable for bad dims; SC2 + SC7 assert no-throw + `errors[]` routing.
  `itemToInput` called **directly** with bad dims throws by contract (SC2) — defense-in-depth, not a leak.
- **R3 — comparator NaN from the unscored sentinel** (`-Infinity - -Infinity`). *Mitigated:* sentinel is `-1`
  (composite ≥ 1.0 = min 1×Σweights); subtracts cleanly; SC5 asserts the both-unscored total order holds.
- **R4 — losing the brief's determinism** (composite ties not fully broken). *Mitigated:* the new term is a
  leading tie-break; the existing `overlap → effectiveDate → title → url` chain still gives a total order (the
  `(title,url)` pair is the unique dedupe id, `store.ts:66-68`); SC5 asserts byte-identical output + the
  same-title/diff-url case.
- **R5 — `extractYaml` mis-reads the `summary`** if the band token introduces a `"`/newline. *Mitigated:* the
  band strings (`Immediate`/`High`/…) are bare words; the summary stays one line, no `"` — asserted in SC6 even
  with a guillemet/quote in the top title; the surfacing hook is untouched.
- **R6 — migration not actually lossless** (a v2 record mutated on load, or a new field stripped on resave).
  *Mitigated:* the migration is the version stamp alone (logic unchanged); `saveStore` `JSON.stringify` `:95`
  strips nothing; SC4 mirrors the proven R2a `store.test:403-476` and adds a score-survives-round-trip case.
- **R7 — editing `trend-spotter.md` trips the de-niche guard.** *Mitigated:* Section 17 runs in the gate; the
  added `score`/`dimensions` are the rubric's generic dimension names + the user's pillars, vendor/sector-free.
- **R8 — new gate checks must survive a deps-absent fresh clone.** *Mitigated:* Section 16j is pure
  `grep`/self-test on tracked source (no `tsx`) → unconditional; `TRENDS_TESTS_FLOOR` stays inside the deps guard.
- **R9 — import cycle.** *Mitigated:* `score.ts` imports nothing internal today (`:1-17`, verified leaf). R3a
  adds three new **one-way** inbound edges to it — `score.ts ← types.ts` (`TrendScore` type), `score.ts ←
  store.ts` (`TrendScore` type on `TrendInput`), `score.ts ← item.ts` (`ScoreMode`/`DimensionScores` types +
  `requiredDimensions`/`scoreEnvelope` values). The DAG stays acyclic: `score.ts (leaf) ← {types, store, item,
  brief, cli}`, since `score.ts` imports none of them back.
- **R10 — mode-mixing makes the ranking apples-to-oranges** (kortform vs long-form composites ranked together).
  *Accepted for R3a, mitigated visibly:* almost all records are `kortform` (the default); the body entry line
  **shows the mode** (`<priority> (<mode>)`, D6/SC6) so the operator can see when adjacent entries used different
  instruments; a mode-segmented brief is a documented R3-later non-goal (brief §4).

## Plan-critic — folded

Three Opus reviewers ran, each verifying claims against live code: **scope-guardian ALIGNED** (0 findings; counts
27/19/29 + "no new source file" verified live); **brief-reviewer PROCEED_WITH_RISKS** (all four load-bearing
claims verified TRUE; 6 MINOR); **plan-critic REVISE** (1 BLOCKER, 4 MAJOR, 4 MINOR; score 72/C). Resolution,
each verified against live code:

- **[BLOCKER — plan-critic] Step 1 RED-proof self-contradictory for score/item under ESM** (a missing named
  import throws at module-load, not on assertion; the stub-first fix inverted the stated ordering). ✅ Step 1 is
  now **explicitly two-phase**: Phase A true logic-RED for `store`/`brief`/`cli` against pre-edit code; Phase B
  stub-first then value-assertion RED for `score`/`item`. The header blockquote + brief §5 + §TDD-order state it;
  the "all five fail before any code" claim is removed.
- **[MAJOR — plan-critic] no-throw guarantee overstated** (`itemToInput` is public; direct bad-dim calls throw).
  ✅ Step 4 + R2 + brief §5 reword it **path-specific** (no throw on the capture path because `normalizeItem`
  gates it; direct calls throw by contract); SC2 adds a direct-throw assertion + a carries-validated-dims
  assertion.
- **[MAJOR — plan-critic] mode-mixing waved away + "mode shown per entry" contradicted the render spec.** ✅ D6:
  the render now shows `· <priority> (<mode>)` per body entry (Step 5); brief §4 adds a mode-blind-ranking
  non-goal with the rationale (mode visible, mostly kortform); SC6 asserts the full line incl. mode; R10 added.
- **[MAJOR — plan-critic] `requiredDimensions` order contract ambiguous** (SC1 hard-coded arrays vs membership
  use). ✅ pinned **ordered** (Step 2 + SC1 deep-equal the SSOT-order array; `score.test` pins the order;
  `normalizeItem` consumes as a set).
- **[MAJOR — plan-critic] `ASSERT_BASELINE_FLOOR` "~99" not pinned.** ✅ pinned **99** (94 + 5 unconditional 16j
  emitters; the self-test emits one pass/fail like 16i) — Step 8 + SC8 + brief §3.
- **[MINOR — brief-reviewer] SC4 ref `:403-471` stale + v2 assertions** → ✅ `:403-476` + "flip every
  `schemaVersion` literal 2→3" note (SC4, Step 1).
- **[MINOR — brief-reviewer] R1 SSOT-pin cite was the doc-comment** (`score.ts:9-13`) → ✅ now `score.test.ts:12-30`
  (R1, brief §2/§5).
- **[MINOR — brief-reviewer] bullet `· <priority>` placement substring-only** → ✅ full pinned line shape
  (priority+mode before `🔗`), asserted as a full line (Step 5, SC6).
- **[MINOR — brief-reviewer] three diverging `ranking:` descriptor strings** → ✅ one verbatim target string,
  asserted byte-for-byte (Step 5, SC6).
- **[MINOR — brief-reviewer] unscored single-match-top summary path untested** → ✅ added as a Phase-A
  brief.test case + SC6.
- **[MINOR — brief-reviewer] `normalizeItem` non-array object case understated in the brief** → ✅ "non-array"
  added to both `score` and `dimensions` object checks (Step 4, brief §3, SC2 array-dims case).
- **[MINOR — plan-critic] header-chain line-ref `:33-49` loose** → ✅ tightened to the 16i clause `:46-49` /
  Section-18 clause `:49` (Step 8).
- **[MINOR — plan-critic] R9 DAG omitted the new `score.ts ←` edges** → ✅ R9 now lists all three one-way edges.
- **[MINOR — plan-critic] SC6 quote-safety regression with the new token** → ✅ SC6 asserts the summary stays
  one-line/no-`"` with a scored top title containing a guillemet/quote.
- **[MINOR — plan-critic] SC4 forward-compat / score-survives-round-trip untested** → ✅ added to SC4 + Step 1
  store.test.
- **[plan-critic headless-readiness] N/A** — R3a executes **in-session, operator-driven** (driftsmodell), not as
  a headless autonomous run, so per-step revert/halt clauses aren't needed (R1/R2a/R2b had none either).

**scope-guardian — ALIGNED:** every SC1–SC8 traces to a step; zero creep; all §4 non-goals held (no
re-score-on-recapture, no saturation/status/first-mover field, no scheduler, no seen-log, no brief-diff, no
A1–A4, no mode-filter, no `score` in the `add` path, no new source file/agent/command); counts 27/19/29 verified
live; exactly 6 `src/*.ts` + 5 `tests/*.test.ts`, all edited, none added.