OCR Dir-2: decisive spike — bigram-tiling owner-hand synthesis + a fair held-out measurement (gates the join MRs) #21

Closed
opened 2026-10-20 17:21:09 +02:00 by claude · 7 comments
Collaborator

Part of #20

Part of #20 (and #17 part 2). This is the decider for the join/ligature synthesis bet. Build it and measure; ship the schema + synthesis MRs only if synthesis beats fonts-only on a hand where WordReader is the operative reader. A clean "no" is a valid, shippable outcome (report it, ship nothing).

Why this spike exists (investigation on #20)

The issue's suggested path — "stitch owner letter traces + join traces to read an unseen joined word" — rests on a premise the code falsifies. A throwaway probe over letterlearning.test.ts's font-as-hand methodology (TRAIN fed as corrections, held-out read via WordReader) found:

hand cutLetters OK letter shapes captured WordReader fonts-only held-out CER trusted
readability (separable) 28/28 21 1.000 0/20
readability + slant 0.25 20/28 16 1.000 0/20
allure (joined) 0/28 0 0.350 13/20
hershey-script (joined) 0/28 0 0.450 11/20

Three structural facts fall out:

  1. Material-availability gap. store.letters is populated only via learnLetters→cutLetters (src/ocr/samples.ts:199, src/ocr/recognize.ts:588), which returns null for joined cursive by design. So letter templates exist for separable hands and are absent for the joined hands where WordReader is the reader in play.
  2. Separable regime is a straw-man win. On a separable hand WordReader fonts-only scores CER 1.000 / 0 trusted (a separable trace can't match the joined bundled script fonts). But separable hands are already generalised by the letter reader (recognize + lettersTemplates, shipped in !12 — see the existing letterlearning.test.ts). So "synthesis beats fonts-only=1.0" there beats a path that isn't the operative reader and is redundant with !12.
  3. Joined regime has no material and a baseline already OK. On allure/hershey-script, store.letters is empty (so letter-based synthesis can't run), and fonts-only already reads ~0.35–0.45 because the test "hand" is itself a bundled script font — an unrealistically easy baseline.

Net: letter material exists only where WordReader isn't operative, and is absent where it is. The measurement #20 specifies can't stage the bet fairly as written.

What this spike must do

1. Redesign synthesis as bigram-tiling (not letters + connector)

Because single-letter material is unavailable for joined hands, define the stored join = the whole labelled bigram shape in cap units (both letters + their ligature), keyed by pair ("th"). Synthesise an unseen word's candidate trace by tiling overlapping/abutting bigrams in reading order (unigram letter templates only fill word edges / unpaired gaps), placed by width/advance, then run through traceOf (src/ocr/words.ts:84). Decide the fallback for a pair with no captured bigram (the font's join for that pair? a straight connector? skip the candidate) and how to pick among multiple samples per bigram.

2. Solve labelled-bigram harvesting honestly — or conclude it can't be

splitLineInto (src/ocr/recognize.ts:571) cuts even allure into ⌈n/2⌉ clusters (probe: 65/65), but at widest gaps with no guarantee a cluster covers exactly two adjacent, known letters. Blindly assigning clusters→bigrams is the exact "guess which ink is which word → teach the wrong shapes" hazard learnCorrection already refuses. The spike must only accept a bigram when the cut provably covers exactly two adjacent letters (needs a boundary signal cutLetters doesn't give today), e.g. by restricting capture to the semi-joined regime where some single cuts are clear and the unclear ones collapse exactly two letters. If no reliable labelling exists, that is the "no" — report it.

3. Build a fair measurement (the whole point)

  • The fonts-only baseline must be the operative one: measure on a joined or semi-joined hand where WordReader is the reader in play, NOT a separable hand (CER 1.0 straw man). The existing 4 fonts have no semi-joined member, so either (a) construct a semi-joined hand (e.g. compose separable glyphs with partial joins / intermittent slant), or (b) seed a controlled synthetic store with known owner letters+bigrams and read held-out words rendered in a matching joined hand.
  • Red gate: fonts-only on both sides is an equality that fails before the change.
  • Ship gate: synthesis beats fonts-only on the joined/semi-joined hand, by a margin that survives seed variation. If it only wins on the separable hand, it does not earn its complexity — do not ship.

4. Latency

Synthesis is per-candidate like readFonts, so it MUST reuse the profile+width shortlist (SAMPLE_SHORTLIST, the 150-candidate cap in readFonts, src/ocr/words.ts:256) and the this.traces cache — read cost stays FLAT in store size (mr-15). A latency assertion within !15's budget (see src/__tests__/scaling.test.ts) is part of the contract.

Trust threshold

A synthesised owner word is neither a verified owner word nor a foreign font: give it its own threshold between SAMPLE_TRUST = 0.2 and FONT_TRUST = 0.08 (src/ocr/words.ts:179).

If the spike is positive — suggested MR split

  1. Schema + capture MR: joins?: Record<string, Point[][][]> on SampleStore, a learnJoins (labelled-bigram capture from pair-separable ink) called alongside learnLetters in learnCorrection, a PER_JOIN const, diversity-preserving per-pair cap via the generalised keepDiverse(samples, cap) (from !18), routed through the migrate() seam (from !19). Unit test: joins captured from separable ink, bounded by the cap.
  2. Synthesis MR: WordReader bigram-tiling synthesis + own trust threshold + the fair held-out CER test + the latency assertion. Wire store.letters/store.joins into the WordReader constructor (today it only takes store.words — see src/main.ts:1773).

Dependencies / ordering

Soft-depends on !18 (generalised keepDiverse(samples, cap)) and !19 (migrate() seam) — both currently open. joins? is optional/backward-compatible so not a hard blocker, but land the capture MR after !18/!19 merge to avoid conflicts in src/ocr/samples.ts.

Validation contract

npm install then npx vitest run src/__tests__ → PASS. The synthesis MR additionally ships: a held-out CER test where synthesis beats fonts-only on a joined/semi-joined hand (operative baseline, not CER 1.0), and a latency assertion within !15's budget. (No flake.nix.)

Part of #20 Part of #20 (and #17 part 2). This is the **decider** for the join/ligature synthesis bet. Build it and measure; ship the schema + synthesis MRs **only if** synthesis beats fonts-only on a hand where `WordReader` is the operative reader. A clean "no" is a valid, shippable outcome (report it, ship nothing). ## Why this spike exists (investigation on #20) The issue's suggested path — "stitch owner **letter** traces + **join** traces to read an unseen joined word" — rests on a premise the code falsifies. A throwaway probe over `letterlearning.test.ts`'s font-as-hand methodology (TRAIN fed as corrections, held-out read via `WordReader`) found: | hand | cutLetters OK | letter shapes captured | WordReader **fonts-only** held-out CER | trusted | |---|---|---|---|---| | readability (separable) | 28/28 | 21 | **1.000** | 0/20 | | readability + slant 0.25 | 20/28 | 16 | **1.000** | 0/20 | | allure (joined) | 0/28 | **0** | 0.350 | 13/20 | | hershey-script (joined) | 0/28 | **0** | 0.450 | 11/20 | Three structural facts fall out: 1. **Material-availability gap.** `store.letters` is populated only via `learnLetters`→`cutLetters` (`src/ocr/samples.ts:199`, `src/ocr/recognize.ts:588`), which returns `null` for joined cursive **by design**. So letter templates exist for *separable* hands and are **absent for the joined hands** where `WordReader` is the reader in play. 2. **Separable regime is a straw-man win.** On a separable hand `WordReader` fonts-only scores CER 1.000 / 0 trusted (a separable trace can't match the *joined* bundled script fonts). But separable hands are already generalised by the **letter reader** (`recognize` + `lettersTemplates`, shipped in !12 — see the existing `letterlearning.test.ts`). So "synthesis beats fonts-only=1.0" there beats a path that isn't the operative reader and is redundant with !12. 3. **Joined regime has no material and a baseline already OK.** On allure/hershey-script, `store.letters` is empty (so letter-based synthesis can't run), and fonts-only already reads ~0.35–0.45 **because the test "hand" is itself a bundled script font** — an unrealistically easy baseline. Net: letter material exists only where `WordReader` isn't operative, and is absent where it is. The measurement #20 specifies can't stage the bet fairly as written. ## What this spike must do ### 1. Redesign synthesis as **bigram-tiling** (not letters + connector) Because single-letter material is unavailable for joined hands, define the stored **join = the whole labelled bigram shape** in cap units (both letters + their ligature), keyed by pair (`"th"`). Synthesise an unseen word's candidate trace by tiling overlapping/abutting bigrams in reading order (unigram letter templates only fill word edges / unpaired gaps), placed by width/advance, then run through `traceOf` (`src/ocr/words.ts:84`). Decide the fallback for a pair with **no captured bigram** (the font's join for that pair? a straight connector? skip the candidate) and how to pick among multiple samples per bigram. ### 2. Solve labelled-bigram harvesting honestly — or conclude it can't be `splitLineInto` (`src/ocr/recognize.ts:571`) cuts even allure into ⌈n/2⌉ clusters (probe: 65/65), but at widest gaps with **no guarantee** a cluster covers exactly two *adjacent, known* letters. Blindly assigning clusters→bigrams is the exact "guess which ink is which word → teach the wrong shapes" hazard `learnCorrection` already refuses. The spike must only accept a bigram when the cut **provably** covers exactly two adjacent letters (needs a boundary signal `cutLetters` doesn't give today), e.g. by restricting capture to the **semi-joined** regime where *some* single cuts are clear and the unclear ones collapse exactly two letters. If no reliable labelling exists, that is the "no" — report it. ### 3. Build a **fair** measurement (the whole point) - The fonts-only baseline must be the **operative** one: measure on a **joined or semi-joined hand where `WordReader` is the reader in play**, NOT a separable hand (CER 1.0 straw man). The existing 4 fonts have no semi-joined member, so either (a) construct a semi-joined hand (e.g. compose separable glyphs with partial joins / intermittent slant), or (b) seed a **controlled synthetic store** with known owner letters+bigrams and read held-out words rendered in a *matching* joined hand. - **Red gate:** fonts-only on both sides is an equality that fails before the change. - **Ship gate:** synthesis beats fonts-only **on the joined/semi-joined hand**, by a margin that survives seed variation. If it only wins on the separable hand, it does **not** earn its complexity — do not ship. ### 4. Latency Synthesis is per-candidate like `readFonts`, so it MUST reuse the profile+width shortlist (`SAMPLE_SHORTLIST`, the 150-candidate cap in `readFonts`, `src/ocr/words.ts:256`) and the `this.traces` cache — read cost stays FLAT in store size (mr-15). A latency assertion within !15's budget (see `src/__tests__/scaling.test.ts`) is part of the contract. ## Trust threshold A synthesised owner word is neither a verified owner word nor a foreign font: give it its own threshold **between** `SAMPLE_TRUST = 0.2` and `FONT_TRUST = 0.08` (`src/ocr/words.ts:179`). ## If the spike is positive — suggested MR split 1. **Schema + capture MR:** `joins?: Record<string, Point[][][]>` on `SampleStore`, a `learnJoins` (labelled-bigram capture from pair-separable ink) called alongside `learnLetters` in `learnCorrection`, a `PER_JOIN` const, diversity-preserving per-pair cap via the generalised `keepDiverse(samples, cap)` (from **!18**), routed through the `migrate()` seam (from **!19**). Unit test: joins captured from separable ink, bounded by the cap. 2. **Synthesis MR:** `WordReader` bigram-tiling synthesis + own trust threshold + the fair held-out CER test + the latency assertion. Wire `store.letters`/`store.joins` into the `WordReader` constructor (today it only takes `store.words` — see `src/main.ts:1773`). ## Dependencies / ordering Soft-depends on **!18** (generalised `keepDiverse(samples, cap)`) and **!19** (`migrate()` seam) — both currently **open**. `joins?` is optional/backward-compatible so not a hard blocker, but land the capture MR **after** !18/!19 merge to avoid conflicts in `src/ocr/samples.ts`. ## Validation contract `npm install` then `npx vitest run src/__tests__` → PASS. The synthesis MR additionally ships: a held-out CER test where synthesis beats fonts-only **on a joined/semi-joined hand** (operative baseline, not CER 1.0), and a latency assertion within !15's budget. (No `flake.nix`.)
claude self-assigned this 2026-10-20 17:21:09 +02:00
Author
Collaborator

❌ Agent run failed

1m23s · session saved — new comments resume this run

❌ **Agent run failed** _1m23s · session saved — new comments resume this run_
Author
Collaborator

Agent failed ❌

agent SDK query failed: Error: Claude Code returned an error result: There's an issue with the selected model (claude-opus-4-8). It may not exist or you may not have access to it.
at om.readMessages (file:///usr/local/lib/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs:88:20439)
at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
[runner] spawn env: cwd=/workspace (exists+executable) | executable=/usr/local/lib/node_modules/@anthropic-ai/claude-code/bin/claude.exe (exists+executable) | HOME=/tmp/agent-home

**Agent failed** :x: agent SDK query failed: Error: Claude Code returned an error result: There's an issue with the selected model (claude-opus-4-8). It may not exist or you may not have access to it. at om.readMessages (file:///usr/local/lib/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs:88:20439) at process.processTicksAndRejections (node:internal/process/task_queues:104:5) [runner] spawn env: cwd=/workspace (exists+executable) | executable=/usr/local/lib/node_modules/@anthropic-ai/claude-code/bin/claude.exe (exists+executable) | HOME=/tmp/agent-home
Author
Collaborator

Status note from the #5 planning agent: this spike's last run failed for an infrastructure reason (claude-opus-4-8 model unavailable), not because of anything in the spike itself. Both soft prerequisites named above have now merged: !18 (generalised keepDiverse(samples, cap) + diversity-preserving letter retention) and !19 (versioned migrate() seam, CURRENT_FORMAT=2). Nothing blocks this spike any more. Please branch off current main (71d0788 or later) so the capture MR builds on both.

Status note from the #5 planning agent: this spike's last run failed for an infrastructure reason (`claude-opus-4-8` model unavailable), not because of anything in the spike itself. Both soft prerequisites named above have now **merged**: !18 (generalised `keepDiverse(samples, cap)` + diversity-preserving letter retention) and !19 (versioned `migrate()` seam, `CURRENT_FORMAT=2`). Nothing blocks this spike any more. Please branch off current `main` (`71d0788` or later) so the capture MR builds on both.
Author
Collaborator

🤖 Agent is working on this — turn 6

Last activity: tool: mcp__gitlab__forge_close_issue — {} — updated 18:08:11 UTC

🤖 **Agent is working on this** — turn 6 _Last activity: tool: mcp__gitlab__forge_close_issue — {} — updated 18:08:11 UTC_
Author
Collaborator

What I found

Result: no-go. Nothing ships. The capture and synthesis MRs don't earn their place, because no reliable way to harvest labelled bigrams exists. With perfect labels synthesis would help modestly, but without them it does nothing.

How it was measured. The spike is a throwaway probe on branch spike/21-bigram-probe, with run logs in .agent-tmp/spike-21/. Not for merge.

  • Owner hands: synthetic "owner" hands built from script glyphs with a consistent per-owner style (per-letter width/height scale, warp, lean, slant) plus per-instance noise.
    • J1/J2: fully joined (pen never lifts), on hershey-script and allure glyphs.
    • J3: as J1, but the reader only has the allure font, so the owner's hand is fully foreign.
    • S1/S2: semi-joined, with a consistent 50% of letter pairs lifted and gapped.
  • Corpus and runs: 4 owners per hand. 140 TRAIN words, each fed through the real learnCorrection. 37 held-out words. A lexicon of about 300 words including look-alike distractors.
  • Baseline: the production WordReader([allure, hershey-script], readability, store.words). "Synth" means owner samples first, then the cheaper trusted match out of the fonts and the synthesis.
  • Synthesis: bigram tiling cut in pen order (by arc length). An x-range crop scrambles the stroke order inside cursive letters: synthesised words then cost 0.36, against 0.13 when the owner rewrites a word.
    • Missing pair: fall back to the font's bigram, which beat skipping the candidate.
    • Several samples per pair: take the first.

Results (mean over 4 owners). Each cell is effective CER / trusted reads out of 148 / wrongly trusted. "Effective" means untrusted reads count as unread.

hand fonts-only synth, oracle bigrams, T=0.16 synth, oracle, T=0.20 synth, harvested bigrams, T=0.16 / 0.20
J1 joined 1.000 / 0 / 0 0.804 / 29 / 0 0.636 / 54 / 0 n/a: nothing to harvest
S1 semi-joined 1.000 / 0 / 0 0.784 / 32 / 0 0.622 / 56 / 0 1.000 / 0 / 0 · 0.993 / 1 / 0
S2 semi-joined 1.000 / 0 / 0 0.784 / 32 / 0 0.520 / 71 / 0 1.000 / 0 / 0 · 0.973 / 4 / 0
  • J2 and J3 with oracle bigrams (abutting tiles) land in the same band as J1: 2–9 of 37 trusted per owner, none wrong.
  • End-to-end recognize CER: oracle synthesis gives a small gain over fonts-only (S1 0.77 → 0.70; J1 0.98 → 0.81). Harvested synthesis is identical to fonts-only on every owner.

Why it's a no:

  1. Harvesting can't be made provable.
    • Fully joined ink: there is no boundary signal at all, so the only material is the oracle.
    • Semi-joined ink: clusters cut at gaps ≥ LETTER_GAP. Each cluster can be assigned 1–3 letters by a unique best fit to the expected widths. That labels bigrams only 82–96% correctly (91/100, 82/90, 106/110, 101/105, 96/118, 79/85, 108/116, 78/84). Checking single-letter clusters with the letter reader made it worse (16/24 … 47/53).
    • Every harvested label is still a guess, which is exactly the hazard learnCorrection refuses. The only provably labelled bigrams are 2-letter words written as one cluster, and they cover far too few pairs to matter.
  2. Even with perfect labels, trust is the bottleneck, not ranking.
    • Ranking is excellent: oracle top-1 CER is about 0.00–0.07, against 0.63–0.69 for fonts-only.
    • But the correct synthesised word costs about 0.21 (median). That overlaps the best wrong candidate (0.18–0.30). So a threshold between FONT_TRUST and SAMPLE_TRUST only trusts 5–48% of words.
    • Harvested material costs 0.28–0.46 for the correct word, which never reaches trust.
  3. Side finding that matters for #20/#17. On any owner hand that isn't literally a bundled font, the font pass is never trusted. The correct word costs 0.22–0.40 in the fonts, against FONT_TRUST = 0.08. So the operative WordReader on real joined hands is effectively owner word samples only (an owner rewrite costs about 0.13 and is trusted 63–98% of the time). The #20 table's fonts-only CER of 0.35–0.45 comes from the test hand being a bundled font.

Not done: I didn't measure latency, because the gate failed before it mattered. A design would reuse the 150-candidate shortlist and a trace cache, as the probe does.

Created

None. The probe lives only on branch spike/21-bigram-probe (evidence, no MR).

Follow-ups

  • To revisit the bet, the real lever is a ranking-margin trust rule: trust when the best cost is clearly below the runner-up. Synthesis ranks near-perfectly even when absolute costs are high. But it still needs labelled material that only an oracle provides today, so it doesn't stand alone.
  • Owner word samples are the only trusted whole-word path on realistic joined hands. Growing store.words coverage (more confirmed words per remark) is a cheaper win than synthesis.
  • No issue filed. This is a recommendation for whoever owns #20.
## What I found **Result: no-go. Nothing ships.** The capture and synthesis MRs don't earn their place, because no reliable way to harvest labelled bigrams exists. With perfect labels synthesis would help modestly, but without them it does nothing. **How it was measured.** The spike is a throwaway probe on branch `spike/21-bigram-probe`, with run logs in `.agent-tmp/spike-21/`. Not for merge. - **Owner hands:** synthetic "owner" hands built from script glyphs with a consistent per-owner style (per-letter width/height scale, warp, lean, slant) plus per-instance noise. - J1/J2: fully joined (pen never lifts), on hershey-script and allure glyphs. - J3: as J1, but the reader only has the allure font, so the owner's hand is fully foreign. - S1/S2: semi-joined, with a consistent 50% of letter pairs lifted and gapped. - **Corpus and runs:** 4 owners per hand. 140 TRAIN words, each fed through the real `learnCorrection`. 37 held-out words. A lexicon of about 300 words including look-alike distractors. - **Baseline:** the production `WordReader([allure, hershey-script], readability, store.words)`. "Synth" means owner samples first, then the cheaper trusted match out of the fonts and the synthesis. - **Synthesis:** bigram tiling cut in **pen order** (by arc length). An x-range crop scrambles the stroke order inside cursive letters: synthesised words then cost 0.36, against 0.13 when the owner rewrites a word. - Missing pair: fall back to the font's bigram, which beat skipping the candidate. - Several samples per pair: take the first. **Results (mean over 4 owners).** Each cell is effective CER / trusted reads out of 148 / wrongly trusted. "Effective" means untrusted reads count as unread. | hand | fonts-only | synth, **oracle** bigrams, T=0.16 | synth, oracle, T=0.20 | synth, **harvested** bigrams, T=0.16 / 0.20 | |---|---|---|---|---| | J1 joined | 1.000 / 0 / 0 | 0.804 / 29 / 0 | 0.636 / 54 / 0 | n/a: nothing to harvest | | S1 semi-joined | 1.000 / 0 / 0 | 0.784 / 32 / 0 | 0.622 / 56 / 0 | 1.000 / 0 / 0 · 0.993 / 1 / 0 | | S2 semi-joined | 1.000 / 0 / 0 | 0.784 / 32 / 0 | 0.520 / 71 / 0 | 1.000 / 0 / 0 · 0.973 / 4 / 0 | - J2 and J3 with oracle bigrams (abutting tiles) land in the same band as J1: 2–9 of 37 trusted per owner, none wrong. - End-to-end `recognize` CER: oracle synthesis gives a small gain over fonts-only (S1 0.77 → 0.70; J1 0.98 → 0.81). Harvested synthesis is identical to fonts-only on every owner. **Why it's a no:** 1. **Harvesting can't be made provable.** - *Fully joined ink:* there is no boundary signal at all, so the only material is the oracle. - *Semi-joined ink:* clusters cut at gaps ≥ `LETTER_GAP`. Each cluster can be assigned 1–3 letters by a unique best fit to the expected widths. That labels bigrams only **82–96% correctly** (91/100, 82/90, 106/110, 101/105, 96/118, 79/85, 108/116, 78/84). Checking single-letter clusters with the letter reader made it *worse* (16/24 … 47/53). - Every harvested label is still a guess, which is exactly the hazard `learnCorrection` refuses. The only provably labelled bigrams are 2-letter words written as one cluster, and they cover far too few pairs to matter. 2. **Even with perfect labels, trust is the bottleneck, not ranking.** - Ranking is excellent: oracle top-1 CER is about 0.00–0.07, against 0.63–0.69 for fonts-only. - But the correct synthesised word costs about 0.21 (median). That overlaps the best wrong candidate (0.18–0.30). So a threshold between `FONT_TRUST` and `SAMPLE_TRUST` only trusts 5–48% of words. - Harvested material costs 0.28–0.46 for the correct word, which never reaches trust. 3. **Side finding that matters for #20/#17.** On any owner hand that isn't literally a bundled font, the **font pass is never trusted.** The correct word costs 0.22–0.40 in the fonts, against `FONT_TRUST = 0.08`. So the operative `WordReader` on real joined hands is effectively *owner word samples only* (an owner rewrite costs about 0.13 and is trusted 63–98% of the time). The #20 table's fonts-only CER of 0.35–0.45 comes from the test hand *being* a bundled font. **Not done:** I didn't measure latency, because the gate failed before it mattered. A design would reuse the 150-candidate shortlist and a trace cache, as the probe does. ## Created None. The probe lives only on branch `spike/21-bigram-probe` (evidence, no MR). ## Follow-ups - To revisit the bet, the real lever is a **ranking-margin trust rule**: trust when the best cost is clearly below the runner-up. Synthesis ranks near-perfectly even when absolute costs are high. But it still needs labelled material that only an oracle provides today, so it doesn't stand alone. - Owner word samples are the only trusted whole-word path on realistic joined hands. Growing `store.words` coverage (more confirmed words per remark) is a cheaper win than synthesis. - No issue filed. This is a recommendation for whoever owns #20.
Owner

@claude all done here?

@claude all done here?
Author
Collaborator

Since my last update: yes, done here. The spike's answer is no-go, and nothing ships. No MRs were opened, and none are pending. The only artefact is the throwaway probe on branch spike/21-bigram-probe. It is evidence only and is not meant to be merged; you can delete it whenever you like. I'm closing this issue now. The two follow-ups in my report above (a trust rule based on the margin over the runner-up, and growing store.words coverage) are recommendations for #20. I haven't filed them as issues.

Since my last update: yes, done here. The spike's answer is **no-go**, and nothing ships. No MRs were opened, and none are pending. The only artefact is the throwaway probe on branch `spike/21-bigram-probe`. It is evidence only and is not meant to be merged; you can delete it whenever you like. I'm closing this issue now. The two follow-ups in my report above (a trust rule based on the margin over the runner-up, and growing `store.words` coverage) are recommendations for #20. I haven't filed them as issues.
claude 2026-10-20 20:08:11 +02:00
Sign in to join this conversation.
No milestone
No project
No assignees
2 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Reference
daniel/obsidian-remarkable-round-trip#21
No description provided.