Internet Learner Stall Fix

---
name: internet-learner-stall-fix
description: Use when internet_learner cycles all report rejected.
---

# Internet Learner stall fix
## Older root causes (15./16.09.26) — moved to references/

Per-class narratives for J–Z, AA–AG (15./16.09.26) live in
`references/root-causes-archive.md`; the rules are in the code, covered by
`tests/scripts/test_internet_learner_gate.py`. Two entries are NOT mere history:

- **Root cause T** — the Darwin autopilot rewrites `internet_learner.py`
  WHILE you edit it. Re-read the file before every patch, and verify your
  change survived after the next autopilot pass.
- **class 160 (23.09.26)** — an off-topic result PAGE is not a source for the query: root cause AG's recommended fix point, implemented (`is_off_topic_page`). Full entry in `references/root-causes-archive.md`. AG is partially fixed, NOT closed.
- **class 164 (23.09.26)** — a NON-ENGLISH distillate reaches the STORED row: `security-learn: Anwendungsmöglichkeiten ...` = a German Azure call-center paragraph as the `a` under an unrelated ENGLISH `u` (the SECONDARY `deep_learn`/smart_route door, `internet_learner.py` ~L5860 — the distill prompt does not constrain language). Measured 2/300 buffer rows; the same string was refused 15x in `buffer_junk` and appears 5x in the learn log over 8 days. NO code fix shipped: the language rule is already forbidden (Chinese Q&A-portal doctrine, `_is_qa_portal_chrome`) and an `a`-keyed near-duplicate rule is MEASURED-AND-REJECTED (`buffer_store.py` ~L3641) because the legitimately-repeating vLLM doc cycles would be deleted to save 2 rows. Full entry in `references/root-causes-archive.md`.
- **Root cause AG** — `deep_learn` ranks the WRONG page; deliberately
  unpatched. Do not 'fix' it on a rejection alone.

**This SKILL.md is at its 100 KB cap.** New root causes go into
`references/root-causes-archive.md` -- append **LF** (that file is LF-native;
a CRLF append flips ~60 lines) -- and only a ONE-LINE pointer is added here.
AW/AY (77-85), 96/97 (AZ), 98, 122 -> MEASURED-AND-REJECTED,
102/103, 109/110, 113-115, 118, 123/124 (GitHub releases-row + slide-nav
chrome; leaked into KTA competitor_gap), BF (deterministic `deep_learn`,
291/300), BC (NON-FIX) and BG/126 (a platform's own client-SDK family: stored
3x -- the sentence DRIFTS, so exact `_is_duplicate` missed it; same-`u` Jaccard
MEASURED-AND-REJECTED, 0.24-0.33 vs a legitimate 0.40) in
`references/root-causes-archive.md`. BE/BC/BF NAMED only, never written.
**134** (a newsroom INDEX page is not an article — a card's country tag welded
to the next card's headline; PAGE-level rule, text-level cannot see it) is
archived there too.
**138** (an ALL-CAPS nav lockup welded to prose AND repeated in Title Case — a
competitor's "Platform Demo" banner stored TWICE; the discriminator is the CASE
SHIFT, not a vendor literal, so the rule generalises. WELD alone = 26 prose FPs,
CASE-SHIFT alone = 2; the pair = 0 over ~4,600 real texts) is archived there too.
**165** (a site sidebar label run welded to its announce line; M1 >=2 distinct nav labels AND M2 the announce line -- each alone MEASURED-AND-REJECTED; also: concurrent writers collide on the CLASS NUMBER, build your commit in a worktree off origin/main) is archived there too.
**139** (a landing-page marketing-SLOGAN clause; the row had already been a
`duplicate` for a WEEK — the buffer rotates ~200 rows/day vs a 300-row cap so
exact `_is_duplicate` is a same-window guard, not a permanent one, and the leak
came back. Also: an EOL normaliser is NOT idempotent on an already-CRLF block —
guard `\r\r\n == 0`, and `git add` under global `core.autocrlf=true` stores an
LF blob: `git rm --cached` + `-c core.autocrlf=false add`) is archived there too.
TWO warnings stay live because they are behavioural, not history:

- run `which_rule_matches.py` BEFORE touching a rule -- the AJ/AQ/AR trap has
  fired FOUR times: your own control trips a PRE-EXISTING `_NAV_CHROME`
  marker, so add the topic-matched hostile control first. Probe the FULL stored
  string (300 chars) -- a truncated copy prints a false `INDIVIDUAL MATCHED: none`.
- never sync this LF-native archive with a text-patch tool: `patch` expanded a
  literal `\r` and corrupted the file at an UNCHANGED byte count. Append pure
  bytes, then assert byte-exact equality with the install copy.
- never wire a gate on a rejection alone (measured-and-rejected = delete the
  signature, keep the rows).

**109/110 (20.09.26)**: own-artifact echo family + 3 harness limits (probe
false-`SKIP`s mixed-case candidates; scores `a` ONLY, so no pair-rule is
measurable; `search_files` can NOT read `AppData/Local` → `grep`.
Pair-rule MEASURED-AND-REJECTED (archive).

CF/130-132 (22.09.26): source-tally CTA + date-stamp strip + credit byline; FIXED, refs/.
133 (22.09.26): doc-site product-nav weld; ALL 4 bare forms REJECTED, 3 two-token welds FIXED, refs/.
135/136 (22.09.26): arXiv submitter WELD + aggregator card header (needs a TitleCase-continuation test; 1+2 FPs without it), found by eyeballing the buffer tail -- FIXED, refs/.
149 (23.09.26): a nav-menu WELD run into a card title drawn TWICE; the discriminator is nav-run>=3@60 AND an ADJACENT exact repeat (d<=L) -- repeat-alone=88 ep FPs, nav-alone=13 prose FPs, pair=0/0; FIXED, refs/.
155 (23.09.26): a raw vLLM server LOG LINE stored as knowledge (`apiserver pid=` / `[scheduler.` / `INFO d-d h:mm:ss`); bare `\bpid=\d+` and `max model len` MEASURED-AND-REJECTED; FIXED, refs/. TRAP: `purge_buffer_rows.py` defaults to `--text-key a`, so a signature in `u` reports a false "nothing to drop".
156 (23.09.26): a HALLUCINATED LLM query (`neural duhmer: ...`) stored OFF-TOPIC tutorial prose -- no chrome gate can catch it, the defect is upstream in `_llm_novel_query`; a lexicon-free rule was MEASURED AND REJECTED (53/800 real headlines), so row purged + COUNT FIRST; refs/.
162 (23.09.26): a DECIMAL POINT is not a sentence terminator -- the extractor stored `... vulnerability (CVSS 3.` while the page continues `3.9) affecting ...`. NOT the class-85 NON-FIX: repair = pure WIDEN of the extractor boundary, never a reject gate. 21 extends / 0 shortens; FIXED, refs/.

**116/117 (20.09.26)**: no gate class at all -- step -1 found a whole
TESTED-BUT-UNCOMMITTED batch (AV again): `dry_run` never reached
`world_model.prune`, MSYS `OPENAMER_HOME` made a phantom tree, `prune()`
re-normalised 250M times, one 5 s health probe burned a slot. NEW TRAP: the
repo's `test_no_hardcoded_paths` rejects a path LITERAL in a DOCSTRING --
describe the MSYS form in prose. The mirror is TWO-WAY (live was AHEAD), so a
repo->live copy would have DELETED fixes -- union first. See archive.

**111/112 (20.09.26)**: 81 = own-artifact plan THIRD title → WIDEN the class-80
regex, not a new helper; 82 = German nav WELD + colon headline; the news ticker
has NO clean discriminator → signature delete. The 109/110 rows were still in
the buffer: a written verdict is not a cleanup. Also: `skill_manage(write_file)`
REPLACES a reference file — restore from the repo copy. See archive.

**119/120 (20.09.26)**: no learner gate in either — 119 was `self_improve.py`'s P2
rule deleting the `CYCLE_SECONDS` assignment it guards (`920131e54`, RED→GREEN
3/3); 120 was a 3-tree drift round with **9 drifts pointing BOTH ways** (4 files
live-AHEAD with a half-applied `chat_default` migration, 5 live-BEHIND incl.
`tool_server.py` which had LOST two utf-8 captures — ported up as `3a0ca2912`).
TWO live traps, both re-confirmed: (1) an autocrlf-off commit in a `git worktree`
still summarises a whole-file rewrite (423+/432- for 14+/23-) because the blobs
are LF and the worktree CRLF — **census the CR bytes in the BLOB**, and
`git diff --stat HEAD~1 HEAD` vs `--ignore-cr-at-eol` is the clean read; (2) the
mirror is two-way and the same tree can be ahead on one file and behind on
another in one run — `verify_three_copies.py` compares against the repo WORKTREE,
which sits on a foreign branch 36 commits behind, so its MISMATCH lines are
branch noise; `git cat-file blob origin/main:<f>` is the only truth. Also: a
`newline="\n"` cleanup silently flipped `online_buffer.jsonl` CRLF→LF (text-mode
`append` means CRLF is the store's contract) and 2 more `Share a lesson you
learned`-family echo rows were finally removed by signature (294→292, the 16
genuine answers asserted intact). See archive.

**121 (20.09.26)**: rotation exhaustion RE-CONFIRMED for the third round --
last 60 `duplicate` rejects 60/60 the identical `(u, a)`, 0 with a novel `u`;
57 recent `junk` candidates attribute ONLY to pre-existing helpers, zero novel
shapes -> no gate change. Same trap as 119/120 (see archive).

**128 (21.09.26)**: 121 re-confirmed (0/60 novel `u`) and the MECHANISM measured
-- `.il_seen_queries` is 800 entries but only **177 distinct**, and the avoid
window (`_recent_queries`, n=60) is **7.5% of the ledger** while **95% of the 623
real repeats are >60 entries apart** (median gap 67, mean 96). Widening `avoid`
to the full ledger is MEASURED-AND-REJECTED: only 2/8 cycle keywords still yield
a live headline vs 8/8 at n=60. Domain saturated, not broken. See archive.

## Counting the rejections — `buffer_junk.jsonl` rows have NO `ts`
`internet_learn_log.jsonl` rows carry `ts/source/result/elapsed_s`; the audit
rows in `buffer_junk.jsonl` carry ONLY `reason/u/a`. So a `ts`-prefix filter
against the audit file silently returns **zero** — live 22.09.26 that made a
busy day look like "the rejections never reached `store()`", which is wrong.
Count by **append order** (the file is append-only: the last N audit rows are
the most recent N rejections), and only then match a rate shift.
Also: `diagnose_learn_rates.py` counts a row as REJECTED for ANY non-"learned"
result, so `no insight` (shallow+deep both returned nothing) lands in the
rejected bucket. A rate drop can be **fewer candidates**, not a stricter gate --
distinguish the two before designing a rule.

## Trigger
`python internet_learner.py --once` (or the cron) reports
`cycle_x: rejected, not trained (shallow + deep read both gated)` on EVERY cycle,
and `online_buffer.jsonl` stays pinned at its cap (300 rows).

## Diagnose (fast)
-1. **BEFORE anything else: `git status --porcelain scripts/training tests/scripts`
   + `git diff --stat` in the repo.** A previous cron session can die after
   applying + testing a gate fix but BEFORE committing; the log then looks like
   "nothing new" while the working tree already carries the next class (root
   cause AV). Finish/verify/commit that work first, and re-sync ALL THREE test
   copies (the laptop one is often synced while `openamer-agent` is not).
0. Run the packaged rates table — this ONE table tells you whether it is a
   systemic regression (rate down across ALL cycles) or normal rotation noise
   (one weak source, or `duplicate` at the 300-row cap):

       python skills/software-development/training-scripts-hygiene/scripts/diagnose_learn_rates.py \
              --training-dir <live training dir>

   (lives in the sibling `training-scripts-hygiene` skill, alongside the other
   learner probes; formerly hand-written as scratch `_probe_rates.py` — bundled
   17.09.26 after the same table was re-derived yet again; see root cause U.)
   **Read the per-DAY table, not just the 7d one.** `--days 7` smooths a step
   change: on 17.09.26 the 7d row showed a healthy 70-77% while per-day showed
   the 13.09 gate-tightening (100% → ~48-68%, stable since) — a regime change
   and a fresh decline look identical in the aggregate. And the final per-day
   row is a PARTIAL day (cut at the current hour): never read it as a decline
   without saying so. `--json` for machine use.
1. `tail -5 internet_learn_log.jsonl` — confirm all cycles rejected.
2. `tail -100 buffer_junk.jsonl` — count reasons. `duplicate` = root cause A,
   `junk` on SERP-shaped text = shallow-path noise (fine), nav text = cause C.
3. `wc -l online_buffer.jsonl` + `cat .il_rotation` — cap reached?
4. Probe one query: run `deep_learn(q)` and print the result; if it returns page
   nav ("Generation RunPod SkyPilot ...") → root cause C.

## Root cause AH — ticker chrome + README changelog bullets, BOTH in one cron run (live 17.09.26)

Cron run started with the documented `cycle_e_competitors: rejected` line. The
rate check said **65% (last 20) / 57% (last 80) vs 82.6–82.9% all-time** — the
U/V signature — so U/V were verified present (`_fair_share_window` → 5 slices /
4000 chars ABCDE, `_search_urls(k=6)` → 6/6/6/6/6/6, `k2 != k6` 2/3) and the
file size was **stable** across the whole probe (no Darwin writer). No gate
change was warranted for the rejection itself: it was rotation noise.

**Both leaks below were found the cheapest way — run `--once`, then read the
tail of `online_buffer.jsonl` and eyeball the `u`/`a` pairs.** Neither showed up
in `buffer_junk.jsonl` (they were never rejected).

| cycle | u | a |
|---|---|---|
| `cycle_f_multi_domain` | Multi-domain learning (Walmart investors reject AI workplace report …) | `Walmart investors reject AI workplace report as automation expands in the US - The Economic Times Benchmarks CLOSED Nifty 23,118.` |
| `cycle_h_efficiency` | Efficiency learning (VPTQ: Extreme low-bit Quantization for real LLMs): How do agents run leaner? | `Inference: low decode overhead, best throughput, and TTFT News [2024-10-14] 🚀 Add Rocm support [2024-10-6] 🚀 Try it on Google Colab [2024-10-5] 🚀 Add free Huggingface Demo : Huggingface Demo [2024-10-4] ✏️ Updated the VPTQ tech report and fixed typos.` |

Both are 129 / 251 chars **with digits** → the `>=90` length trust AND the
technical-signal gate both fired; no existing marker matched.

**Markers added (data-only, BOTH files — the Q/R/S pitfall).** Commits
`1f5a17cbc` (ticker) and `95d4aa156` (changelog):

| marker | where | measured |
|---|---|---|
| `closed nifty` | both | 1 hit, and it IS the leak → 0 FP |
| `the economic times benchmarks` | both | 1 hit, IS the leak → 0 FP |
| `add free huggingface demo` | both | 2 hits (same row duplicated), BOTH the leak → 0 FP |

**Candidates measured and REJECTED — the topic-word trap again:**
| candidate | why rejected |
|---|---|
| `nifty` (bare) | 1 hand FP + 1 live FP: `Benchmarks from the Nifty index showed a 2% gain…`, `…encompassing Nifty 100 intraday and daily price data…` |
| `benchmarks closed` (bare) | 1 hand FP: `The agent benchmarks closed-source and open-weight models on the same harness.` |
| `add rocm support` | 1 hand FP: `Add ROCm support for AMD GPUs to the inference backend.` |
| `try it on google colab` | 1 hand FP: `You can try it on Google Colab without installing anything locally.` |
| `low decode overhead` | 1 hand FP: `The agent benchmarked low decode overhead and best throughput on TTFT.` |
| `best throughput, and ttft` | 1 hand FP (declarative on the same topic) |

A **structural alternative** measured clean and is a candidate for a future
class-wide detector: **`>=3` bracketed dates `\[\d{4}-\d{1,2}-\d{1,2}\]` → 2
hits, 0 FP both corpora** (`>=2` was rejected: 2 live FPs on the `[2024-10-18]
🌐 Open source community contributes…` row). Same for `>=2` rocket-emoji
bullets (2 hits, 0 FP). Not needed for these single leaks — prefer the tight
literal while only one row shape is live.

**Cleanup + verify (the standard shape):** both leaks removed **by signature**
(`is_junk` would drop the 12-row baseline), census 297/13 → 296/12, then
297/14 → 295/12, 0 unparsable, 53 structural-connection rows preserved.
`pytest tests/scripts/test_internet_learner_gate.py -q` → **42 passed**
(new `test_market_ticker_chrome_…` and `test_readme_changelog_bullet_list_…`,
each asserting BOTH gates plus prose counter-cases); `tests/scripts` →
**182 passed**. Two commits pushed.

### Trap that cost a cycle here: `patch` DELETED my own previous marker
Patching `_NAV_CHROME` with `old_string = '    "the economic times benchmarks",'`
**replaced that line** with the new block — the nifty marker vanished, leaving
only the changelog one. The probe caught it (`nifty marker line: []`). When
appending to a tuple with `patch`, anchor on the **line BEFORE** the insertion
point (or just use the byte-level AST-anchored script). Fix was a 3-line
re-insert, then `ast.parse`. Always re-grep every marker you believe is in the
file after any `patch`/`write_file` on these modules.
Related: after an insert, **all hardcoded line numbers shift** — the second
`_NAV_CHROME` edit asserted `lines[371] == b")"` and blew up with the previous
comment text. Re-derive the anchor with `ast` each time; never reuse a line
number from an earlier probe.

## Verify a writer-gate change like this (what "0 collateral" looks like)
1. `is_junk(bad) == True` on the exact leaked strings, `False` on 3 real prose
   samples + the engine's own baseline row.
2. Re-scan the whole buffer: flagged set must grow by **exactly** the leaked
   rows (live: 24 → 26, i.e. 2 new hits), then drop back to **24** after deleting
   them (`flagged: 26 -> 24`, the historical baseline).
3. `openamer-repo/.venv/Scripts/python.exe -m pytest tests/scripts/test_internet_learner_gate.py -q`
   → `12 passed` (added `test_writer_gate_agrees_on_the_new_chrome_and_binary_shapes`,
   which asserts BOTH gates on both shapes). Suite grew with each shape:
   **`23 passed` as of 16.09.26** (root cause Y added
   `test_german_dictionary_serp_chrome_is_gated_on_both_paths`, which asserts the
   leak is gated on BOTH paths AND that two real `…;` vLLM/quantization rows stay
   clean — the one-directional version would pass the wrong fix).
4. Sync the two modules into `openamer-repo/scripts/training/` (they must be
   byte-identical to the laptop copies — `diff` first), commit, push.
5. Run 3–4 × `--once`. Post-fix live: 1 learned / 2 rejected, where both
   rejections were `junk` (SERP-shaped deep-read fallback) and `duplicate`
   (buffer at cap) — **read `tail -6 buffer_junk.jsonl` before calling it a
   regression.**

## Root cause AI — company/Wikipedia infobox FINANCIAL label chain (live 17.09.26)

Second cron run of the day. Started on the documented `cycle_d_docs: rejected`
line. Rate: last 10 50 % / last 20 50 % / last 80 50 % vs **all-time 82 %**
(n=1711) = the U/V signature, so U/V were verified **before** inventing anything:
`_search_urls(k=6)` → `6,6,6,6,6,6`; `_fair_share_window` → 5 slices / 4000
chars; file size **stable** over 30 s (no Darwin writer). No gate change was
warranted for the rejection — rotation noise. `buffer_junk` last 40:
`21 junk / 18 duplicate / 1 no-tech-signal`, all documented shapes.

The find came from the buffer tail, twice:

**1. Two root-cause-AG rows (NOT gate leaks — deleted, no code change):**
| cycle | u | a |
|---|---|---|
| `cycle_g_security` | Security learning (Detecting prompt injection attacks …) | `Kraków – Wikipedia, wolna encyklopedia — Kraków jest położony … ; Oficjalny serwis BIP …` |
| `cycle_h_efficiency` | Efficiency learning (Pushing the Limits of LLM Quantization via the Linearity Theorem) | `November 5, 2025 Share 2 Min Read Photo by Abid Shah on Unsplash Amazon has issued a cease-and-desist letter to Perplexity …` |

Both measured `writer=False extract=False` — **topically unrelated whole
articles**, i.e. the documented root cause AG (deep_learn ranks the wrong page).
Do NOT invent a gate for these: the `Kraków` row is a Polish SERP pair and the
Amazon row is a news lede, so any "news-ness"/"encyclopedia" marker would be a
topic word. Removed by signature (`wolna encyklopedia`, `on unsplash`) →
300 → 298 rows.

**2. A REAL leak the very next `--once` produced — the infobox (this root cause).**
```
u = Competitor intelligence: JetBrains IDEs Go AI: Coding Agent, Smarter Assistance, Free Tier
a = CEO [ 1 ] Revenue 15,065,029,000 Czech koruna (2024) Operating income
    2,041,654,000 Czech koruna (2024) Net income 2,479,110,000 Czech koruna
    (2024) Total assets 17,426,568,000 Czech koruna (2024) Number of
    employees 2,800 [ 2 ] Website jetbrains .
```
248 chars **with digits** → the `>=90` long-prose trust AND the technical-signal
gate both fired; `_is_nav_list` wants ≥6 TitleCase tokens with no comma, so a
mixed label chain never matched. Commit `aaf11271e`.

### Marker selection was the whole cost — every literal is a topic-word trap
| candidate | buffer hits | HAND-prose FP | verdict |
|---|---|---|---|
| `operating income` | 1 | **3** | REJECTED |
| `czech koruna` | 1 | **3** | REJECTED |
| `revenue [\d,]{6,}` | 1 | **1** | REJECTED |
| `ceo \s*\[\s*1\s*\]` | 1 | 1 | REJECTED |
| `\(\s*20\d\d\s*\)\s*operating income` | 1 | 1 | REJECTED |
| `number of employees…website` | 1 | 0 | ok but narrower need |
| **structural: ≥2 (label, year-paren)** | **1 (the leak)** | **0/13** | **SHIPPED** |

`grouped-numbers >= 3` also scored clean on the buffer (1 hit / 0 FP) but is
**useless as a corpus scan**: on RAW JSON lines it reads 437/437 and 3056/3056
(the JSON has lots of long numbers). Scan the **text fields** — then it is 7/3056
on `longterm_episodes`, all in unrelated X-batch report texts.

### The fix — structural, in BOTH gates
`buffer_store.is_financial_infobox(text)` = `len(_FINANCIAL_LABEL_RE.findall) >= 2`
where `_FINANCIAL_LABEL_RE = (revenue|operating income|net income|total assets|
number of employees)[^()\n]{0,30}\(\s*(?:19|20)\d\d\s*\)`, cap `len <= 1200`.
An infobox row *repeats* `Label <huge grouped number> … (yyyy)`; real prose does
not. Wired into `buffer_store._is_nav_chrome` (writer gate → covers
`active_learn` / `online_learning`) AND called from `internet_learner._is_junk`
via the lazy `from buffer_store import …` sibling idiom (logic, not a page
phrase → **no `_JUNK_RE` mirror**, exactly like `is_contact_block`).

Measured: leak `writer=True extract=True`; **0 FP on 13 hostile counter-cases**
including `Llama 2 (2023) and Llama 3 (2024) improved long-context reasoning`,
`GPT-4 (2023) scored 91.2% while GPT-5 (2024) reached 95.1%`,
`Total assets ( 2023 ) were 17,426,568,000 koruna at the end of the year.`,
`Number of employees grew to 2,800 ( 2024 ) across the Czech and German offices.`
(only a deliberately infobox-shaped synthetic — `Revenue 2024 ( 2024 )` ×3 —
flags, which is correct); 0 hits over 3,056 `longterm_episodes` texts.

Cleanup by signature (`czech koruna`): **299/13 → 298/12** (baseline), 53
structural-connection rows preserved, 0 unparsable, CRLF intact.
`pytest tests/scripts/test_internet_learner_gate.py -q` → **46 passed** (new
`test_financial_infobox_label_chain_is_gated_on_both_paths` asserts BOTH gates on
the leak + 11 prose counter-cases); `pytest tests/scripts -q` → **186 passed**.

### Mechanical traps that cost the most time here
- **The `_is_nav_chrome` wire anchor must be the two-line form.** `"    if
  _is_package_index_chrome(text):\n        return True"` — a **one-line**
  anchor silently matched 0 times and the apply script aborted on the assert.
  Build the anchor as `crlf("…\n        return True")`, not as a bare line.
- **Appending a test needs a separator.** `raw.rstrip(b"\r\n") + TEST` glues the
  new `def` onto the previous line's tail → `SyntaxError: invalid syntax` at
  `assert not IL._is_junk(meta), metadef test_…`. Use
  `body + b"\r\n\r\n\r\n" + TEST.replace("\n","\r\n").encode() + b"\r\n"`.
- **`git status` in this repo is NOISY with foreign cron paths** (`tools/mcp_tool*`
  deletions, `reports/darwin-*`, `.bugbot/bugbot.log`, `scripts/auto-code-review.py`).
  Always `git add` the three explicit paths and check `git diff --cached
  --name-only` before committing — never `git add -A`.
- Live re-verify after the fix: 3 × `--once` → 2 learned / 1 rejected. The
  rejected one and the two learned rows all measured `writer=False extract=False`;
  the remaining off-topic row (`Physics … antiprotons`) is root cause AG again,
  which stays deliberately unpatched.

## Root cause AL — FOUR chrome classes in ONE cron run, and the pitfall that a NEW rule can break an OLD test (live 17.09.26)

Cron run began with the documented `cycle_c_github: rejected` line. Rate said
**50 % (last 20) / 51 % (last 80) vs 81 % all-time (n=1780)** — the U/V
signature — so U/V were verified BEFORE inventing anything (`_search_urls(k=6)`
→ 6; `deep_learn` k2/k6 on 4 diverse queries → 2/4 identical windows, and the
2 `False` cases were query-dependent content artifacts, not the dead-code bug).
`buffer_junk` last 25 = `duplicate` at the 299/300 cap + documented junk shapes
= rotation noise. **No gate change was warranted for the rejection itself.**

The whole find came from the prescribed cheapest method — run `--once`, read the
BUFFER TAIL, eyeball `u`/`a` — repeated after each fix. All four rows passed
BOTH gates and NONE ever appeared in `buffer_junk.jsonl`.

| class | helper | measured |
|---|---|---|
| 33 | `_is_news_card_stub` — card headline + glued relative-date label + truncated counter tail (`... misalignment Sep 17 7.`) | 1 hit, IS the leak / 0 FP / 0 le |
| 34 | `_is_relative_time_nav_chain` — relative-time bullet ANDed with `For You / Latest / Trending` nav labels | 1 hit, IS the leak / 0 FP / 0 le |
| 35 | `_is_date_heading_listing` — date-stamped headline listing (blog archive) | 2 hits, BOTH leaks / 0 FP / 0 le |
| 36 | `_is_repo_tab_statbar_chrome` — `Code Issues Releases` tab chain ANDED with a `\d+ MiB <Lang> \d` stat bar | 1 hit, IS the leak / 0 FP / 0 le |

Class 33 is only 70 chars, so the `>=90` long-prose trust never applied — a
reminder that the trust is not the only way chrome gets in. Its anchor is the
TAIL (`$`), because a bare `<Mon> <day>` is an ordinary date.

### THE PITFALL — a broad new structural rule can re-flag an OLD test's counter-case prose
For class 35 my first rule was `>=3 full dates` OR `>=2 dates AND slash-category
breadcrumb`. It measured **clean on the live buffer (2 hits, both leaks) and on
every hand-written control** — and then `pytest` went RED on
`test_blog_archive_listing_is_gated_on_both_paths` (class 24), whose counter-case
prose is

    `...posts under headings like Insights July 17, 2026 and News May 29, 2026,
     but the agent should parse the article body.`

Two full dates + TitleCase labels → my rule flagged real prose.

**Rule: candidate markers must be run against the EXISTING gate test suite's
counter-case prose, not only against your hand controls + the live corpus.**
Hand controls and the live buffer agreed with the broken rule; the repo's own
regression corpus caught it in 3 s. So: apply, then run
`test_internet_learner_gate.py` BEFORE the cleanup/commit, and treat a new
red as YOUR rule being wrong, not the old test being stale.

The fix that survived: discriminate on **Title-Case density** of a title
listing, not on the date count —
`len(_FULL_DATE_RE.findall(t)) >= 2 AND upper_words >= 8 AND upper/total >= 0.5`
(measured 0 buffer FPs, 0 ctrl FPs, 0/3,056 le, and the class-24 leak is still
gated by its own rule). `_TITLE_WORD_RE = r"[A-Za-z][A-Za-z'./-]*"`.

### THE OTHER PITFALL — appending a test with `rstrip("\r\n")` causes EOL churn
`txt.rstrip("\r\n") + "\r\n\r\n\r\n" + TEST` normalises the file's LAST line,
which was one of the 58 pre-existing **lone-LF** lines in
`test_internet_learner_gate.py` (that file is NOT pure CRLF — it has 58 lone LFs
at HEAD; do not "fix" them). Result: `git numstat` showed `48 added, 1 removed`
and the lone-LF census went 58 → 57. Correct approach — **pure byte append**:
`open(p,"wb").write(open(p,"rb").read() + TEST.replace("\n","\r\n").encode())`,
then assert `numstat` has **0 removed** and the lone-LF count is **unchanged**.

Note the gate modules themselves ARE pure CRLF (2597/1340 lines, 0 lone LF),
while the test file is not — check each file's census separately.

### Session shape that worked here
Fix 33+34 and 35+36 in two passes, but the loop is the same: measure → apply to
BOTH gates in all 3 copies → re-scan buffer → **run pytest** → cleanup by
signature → append test (pure bytes) → mirror to the laptop test copy → commit
with a msg FILE (backticks in a `-m` string get eaten by git-bash:
`command substitution: syntax error near unexpected token '<'`) → push.
Result: `56 passed` gate file, `212 passed` `tests/scripts`, post-fix live
cycles 2/3, 2/4 and 3/3 learned with no chrome in the tail.

The AM run (three classes, 37–39) confirmed the loop scales: one measure → apply
→ pytest → cleanup → test → commit cycle per class, `59 passed` / `215 passed`,
3 pushes, and only the alias trap above cost extra rounds.

## Root cause AM — THREE chrome classes in ONE cron run, and the `re` vs `_re` alias trap (live 17.09.26)

Cron run began on the documented `cycle_c_github: rejected` line. Rate said
**54.5 % for the partial day (12 ok / 10 rej) vs 81–83 % all-time** — inside the
documented band, so no gate change was warranted for the rejection itself. The
file size was **stable** over 20 s (`91496` both samples) → no Darwin writer;
`.il_rotation` = 1803. All three finds came from the prescribed cheapest method:
run `--once` a few times and read the BUFFER TAIL (`u`/`a`), repeated after each
fix. All three rows passed BOTH gates and NONE was ever in `buffer_junk.jsonl`.

| class | helper | measured |
|---|---|---|
| 37 | `_is_hn_feed_listing_chrome` — a repeated aggregator feed row: relative time + `\| N comments` + points + headline, **>=2 occurrences** | 1 hit, IS the leak / 0 FP / 0 le |
| 38 | `_is_marketing_hero_cta_chrome` — landing-page hero: availability line + nav CTA + tagline + `[*]` marker + brag opener `With over` / `Mit über` | 3 hits, ALL THREE the same page hero / 0 FP on 26 controls / 0 le |
| 39 | `_is_platform_selector_listing_chrome` — `macOS Apple Silicon (arm64)`-style selector within 200 chars of `r/<name> community` | 1 hit, IS the leak / 0 FP on 21 controls / 0 le |

**Class 37 — the discriminator is REPETITION, not the parts.** The single-occurrence
form `\b(?:minutes?|hours?|days?|weeks?|months?)\s+ago\s*\|\s*\d{1,5}\s*comments\b`
flagged the control `The review took 2 days ago | 4 comments per reviewer were
recorded.` → REJECTED as the shipped rule. `>=2` findall measured 1 buffer hit
(the leak), 0/12 controls, 0/3,056 episodes. `by <user> N days ago` and bare
`\d+ comments` were also rejected (real prose + 3 live episodes).

**Class 38 — one page hero stored THREE times in one buffer** (once in German via
`cycle_e_competitors`, twice in English at rows 17/87). Tell: rows 17 and 87 were
**byte-identical**; always group the flagged rows before designing a marker, or
you will write a marker for one third of the leak. The looser
`(?:Read docs|Doku lesen)[\s\S]{0,120}?\[\*\]` form was REJECTED on measurement
(3 control FPs: `Read docs to learn how the [*] wildcard expands in glob
patterns.`, `Doku lesen hilft, weil [*] die Pflichtfelder kennzeichnet.`,
`Read docs and [*] will be replaced by the matched text.`). Only the
`[*]`-adjacent brag opener survived.

**Class 39 — class 34's rule needs the `For You / Latest / Trending` labels;
this shape has none.** Platform selector + `DISABLED` + `…` + upvote count +
`r/... community` + relative time + forum title. Candidates A3/A4 (tighter
anchors) also measured clean; A2 (`r/<name> community`, the widget's own label)
shipped as the most specific. The `(arm64...)` + relative-time form was
REJECTED — 3 control FPs.

### THE PITFALL — `internet_learner.py` uses `re`, `buffer_store.py` uses `re as _re`
Copy-pasting one helper into both files raises `NameError: name 're' is not
defined` (or `_re`, in the other direction) **at import time**, which shows up as
a `pytest` collection error, not a gate failure. This cost two extra apply/fix
round-trips in one run (once for class 37 in `buffer_store`, once for class 38 in
`internet_learner`). Before writing the helper, grep the target file's import
alias:
```
grep -n "^import re" <file>     # `import re` vs `import re as _re`
```
Ship the constant with the correct alias per file — or avoid the issue entirely
by writing `import re`-free helpers. Never assume the two modules agree.

### Also: build the anchor with CRLF, and expect it to be the blank-line-separated two-line form
`"    if _is_relative_time_nav_chain(t):\r\n        return True\r\n"` is the
reliable insertion anchor (LF-only anchors match 0 times on these pure-CRLF
modules). Anchor on the PREVIOUS class's call, not on a line number — every
insert shifts the file.

Cleanup + verify (the standard shape, per class): remove leaks by signature with
the CRLF-split reader (`split("\r\n")`, never `readlines()`), assert the dropped
count, rewrite with `newline=""` + one record per CRLF. Live censuses:
300/7 → 299/7 (cls 37), 300/7 → 297/7 (cls 38), 300/7 → 299/7 (cls 39); **7 is
the baseline** writer-flagged count in this buffer (rows 5, 9, 19, 27, 29, 36, 45
= pre-existing SERP/listing shapes — do NOT "clean" those), 53
structural-connection rows preserved, 0 unparsable every time.
`pytest tests/scripts/test_internet_learner_gate.py -q` → **56 → 57 → 58 → 59
passed**; `pytest tests/scripts -q` → **212 → 213 → 214 → 215 passed**. Three
commits pushed. Post-fix live cycles: 2/3, then 1/3 where both rejects were
honest (`duplicate` at the 300 cap) — **read `buffer_junk` before calling a
rejection a regression.**

## Root cause AP — the learner's OWN deep-read prompt echoed back as a bullet chain (class 42, live 17.09.26)

Cron run began on the documented `cycle_g_security: rejected` line. Rate said
**30 % (last 10 and last 20) vs 80 % all-time (n=1828)** — the U/V signature —
so U/V were verified BEFORE inventing anything: `_search_urls(k=6)` → **6/6 on
all 5 diverse queries**; `_fair_share_window` → **5 slices**; buffer size
byte-stable (`90761` both samples) → no Darwin writer. `buffer_junk` last 25 =
`duplicate` at the 298/300 cap + documented `junk` shapes = rotation noise, so
**no gate change was warranted for the rejection itself**. Writer-gate census
**0 of 298** → the buffer was clean at entry.

**The leak was CREATED BY THIS RUN** — a reminder that "buffer was clean at
entry" does not survive six `--once` cycles. After 6 rejects the 7th cycle
(and the 8th) learned, and the 8th stored the learner's own task template:

    "\n   - Input is a list of daily paper submissions with titles, authors, and
     brief tags/counts\n   - I need to identify the single most valuable technical
     insight for an autonomous AI agent from these paper titles/descriptions\n
     - Output must be a sin"

190 chars **with digits** → the `>=90` length trust AND the technical-signal
gate both fired. **Do not read a `learned` line as success** — this one's log
line (`efficiency-learn: "\n - Input is a list of daily paper submissions …`)
was visibly suspicious, but the skill's rule stands: read the BUFFER tail
`u`/`a` pairs, because the stored form is what trains.

Why every existing marker missed it:
- `_INSTRUCTION_OPENER_RE` is **START-anchored** (`^\s*\**\s*…`) — this text
  opens with a `"` + newline, so the anchor never lands, even though `I need to`
  is literally in its alternation.
- `_is_nav_list` wants ≥6 TitleCase tokens with no comma — a mixed task-frame
  bullet chain is neither.

### The discriminator is the BULLET CHAIN, not the phrase
`_is_prompt_echo_bullet_chain(text)` = `>= 2` bullets each opening with a
task-frame word, via `_PROMPT_ECHO_BULLET_RE`:
`(?:^|[\r\n])\s*[-*•]\s+(?:Input\b|Output\b|I need to\b|I must\b|I should\b|The task\b|Identify the\b|Steps?\b|Constraints?\b|Format\b)`
Wired into BOTH gates (extraction `internet_learner._is_junk` + writer
`buffer_store._is_nav_chrome`) in all 3 copies — the AH both-files rule.

**Every single-phrase candidate was measured and REJECTED:**

| candidate | buffer | hand FP | verdict |
|---|---|---|---|
| `\bInput is a list of\b` | 1 = leak | **3** (`Input is a list of tokens…`, `The input is a list of papers…`, `In the benchmark, input is a list of 512 sequences…`) | REJECTED |
| `\bI need to identify the single\b` | 1 = leak | 1 | REJECTED |
| `\bfor an autonomous AI agent from these\b` | 1 = leak | 0 | ok but narrower than the class |
| `\bpaper submissions with titles\b` | 1 = leak | 1 | REJECTED |
| **bullet-triad (`>=2` task-frame bullets)** | **1 = leak** | **0** | **SHIPPED** |

Measured clean the strong way — **my rule ALONE**, not `_is_nav_chrome`:
1/300 buffer (= the leak), **0/3,056** `longterm_episodes`, **0/591** string
literals extracted from the gate test file, 0/13 hand controls.

### PITFALL — `_is_nav_chrome` FPs are NOT your rule; test YOUR helper in isolation
The first verify loop measured `control FPs writer=0 learner=1` and
`test-literal FPs: 35`, `episode FPs: 74/3056`. That looked like massive
collateral. It was not: the 35 and the 74 came from **pre-existing** markers
(GitHub repo-listing rows, `_NAV_CHROME` phrases like `Let Chat …`, date
headings) that those corpora legitimately trip. Only the learner control
(`I need to identify the single most valuable technical insight from the
report.`) was mine — and the diagnostic showed
`_INSTRUCTION_OPENER_RE.match(ctrl) == True` (pre-existing rule), while
`_is_prompt_echo_bullet_chain(ctrl) == False`. **Always probe the new helper
directly**; a corpus FP count through the composite gate tells you nothing
about your change. Same lesson as the AJ/AI control-corpus pitfall, third
occurrence — the skill now says: isolate first, diagnose which rule matched
second, only then conclude.

### Also — a `learned` cycle can hide the leak behind a clean-looking tail
After the cleanup, the post-fix cycles gave 1 learned of 3 (`cycle_c_github`,
real MAF content, `writer=False extract=False`) — read the buffer, not the
log, and re-run the census **after** every fix (`299` records, 0 unparsable,
53 structural rows, writer-gate 0).

Cleanup + verify (standard shape): leak removed by signature
(`Input is a list of daily paper submissions with titles`,
`I need to identify the single most valuable technical insight for an autonomous AI agent`),
**300 → 299** records, `0 unparsable`, CRLF intact, **53** structural-connection
rows preserved, writer-gate census **0**. Test appended as **pure bytes**
(lone-LF census 58 → 58 for the repo file, 0 → 0 for the laptop copy), and the
3 CODE copies + repo test verified byte-identical via `md5sum` (repo ==
laptop == openamer-agent: `230f36de…` learner, `70170f3e…` store).
`pytest tests/scripts/test_internet_learner_gate.py -q` → **61 → 62 passed**
(new `test_prompt_echo_bullet_chain_is_gated_on_both_paths` asserts BOTH gates
on the leak + 10 prose counter-cases); `pytest tests/scripts -q` →
**217 → 218 passed**. Commit `bb0d00ae2`, `numstat` **93 added / 0 removed**
(no EOL churn), pushed `HEAD:main` from the foreign branch
`fix/28-respawn-test-psutil-hermetic` (`merge-base --is-ancestor main HEAD` →
FF_SAFE), `origin/main` re-read = `bb0d00ae2…`, `git branch -r --contains`
confirms `origin/main`.

## Root cause AO — an EXISTING strip-helper whose guards were one variant too narrow (class 41, live 17.09.26)

Cron run began on the documented `cycle_h_efficiency: rejected` line. Per-day rate
37–60 % (15:00 hour partial, 0/4) vs 81 % all-time → inside the documented band, so
**no gate change was warranted for the rejection itself**; `buffer_junk` last 20 =
`12 duplicate` (buffer at 297–300 cap) + `6 junk` + `2 no-tech-signal`, all
documented shapes. Buffer tail was clean (0 of 298 writer-flagged).

**The leak came from running `--once` and reading the BUFFER TAIL — twice in a row.**
`cycle_b_papers` learned a row whose LOG LINE showed the chrome
(`Yash Thakker CoreWeave NVIDIA Sep 17, 2026 · 8 min read Databricks Deploys GPT-6 (56.2s)`)
even though the STORED text was clean — so *do not judge a cycle by its log line*.
The stored rows that *had* leaked were two `min read` blog cards:

| u | a (stored) |
|---|---|
| `Latest research insight: Breaking the 1.58-bit Barrier …` | `AI Agents 11 min read AI Agent Cost Benchmarks: Tokens, Latency, and Dollars per Task Original 2026 benchmark: …` |
| `AI model exit strategy` (fresh) | `Start the challenge Blog 18 April 2026 / 24 min read 8 best open-source AI agent frameworks on GitHub in 2026 The best …` |

### THE LESSON — check whether an EXISTING helper's GUARDS are too narrow before writing a new class
The repo already had `_strip_trailing_read_time_header` (17.09.26, class-40 era) for
exactly this family. Both live rows still got through because of TWO guards:
1. `body[:1].isupper()` — row 2's body starts with a **digit** (`8 best open-source …`).
2. `_BLOG_HEAD_DATE_RE.search(head)` required a dateline — row 1's head is a bare
   category label (`AI Agents`) with **no date at all**.

So the fix was to **relax two guards**, not to add a 4th chrome class. Guard 2's
replacement keeps a structural discriminator: without a dateline the head must be a
short (≤4 words) **pure-TitleCase label chain with no lowercase words**. Real prose
that merely mentions a read time sits inside a sentence and carries lowercase words,
so it stays untouched. New constant `_BLOG_HEAD_LOWER_RE = re.compile(r"\b[a-z]{2,}\b")`.

Measured (0-collateral proof): 2/2 leaks stripped with a **byte-identical body**;
**0 of 3,056** `longterm_episodes`; **0** hand-written prose controls; and — the
strongest form — a **pre/post module diff of `_clean_insight` output on all 8 control
strings = 0 diffs** (load the backup module with `importlib` and compare, instead of
only asserting the new behaviour).

**Do not treat a `min read` control that `_clean_insight` returns `""` for as YOUR
regression** — two of the 8 controls already returned `""` pre-edit (short non-tech
signal). Always diff old-vs-new module output before hunting a regression you did not
cause. The 2 hand-written "hostile" controls (`Machine Learning 5 min read The study
found that quantization helps.`) ARE correctly stripped — they are chrome-shaped by
construction, so a harness that lists them as `ctrlFP` is reporting the intended
behaviour, not a bug.

### PITFALL — the strip helper was applied to the LAPTOP copy only, so the REPO test went red
The first apply pass edited only `AppData/Local/openamer-laptop/scripts/training/internet_learner.py`;
`pytest` in `openamer-repo` then failed the new test because the repo copy still had
the old guards. **After any apply, `md5sum` all THREE copies before running pytest** —
one red suite here was purely a missing sync, not a wrong rule. (Standard: Repo=SoT,
laptop=LÄUFT, openamer-agent=older copy; all three must be byte-identical.)
The repo file is pure CRLF and the laptop copy too, so the same
`norm(s) = s.replace("\n", eol)` script applies to all three unchanged.

Cleanup + verify (standard shape): 2 chrome rows **plus the documented root-cause-AG
off-topic row** (`Databricks Deploys GPT-6 …`) removed by signature → **300 → 297**,
`0 unparsable`, CRLF intact, **53** structural-connection rows preserved, writer-gate
census **0 of 297**. The cleanup script's `assert len(dropped) == 2` fired on the
third row — **keep that guard and widen it deliberately** after identifying the extra
row, rather than deleting the assert.
`pytest tests/scripts/test_internet_learner_gate.py -q` → **60 → 61 passed** (new
`test_midtext_read_time_header_without_dateline_is_stripped`, appended as pure bytes:
42 added / 0 removed, lone-LF census 58 → 58); `pytest tests/scripts -q` →
**216 → 217 passed**. Commit `0cc459b21`, pushed `HEAD:main` (branch was again
`fix/28-respawn-test-psutil-hermetic`; `merge-base --is-ancestor main HEAD` → FF_SAFE,
`git branch -r --contains` confirms `origin/main`).
Post-fix live: 3 × `--once` → all rejected; `buffer_junk` shows honest reasons
(`duplicate` at the cap + already-gated shapes) and the buffer tail is 0-of-297
writer-flagged. **Read `buffer_junk` before calling a rejection a regression** — again.

## Root cause AN — mid-text byline + `Published <dd Mon yy>` header (class 40) + the foreign-branch trap (live 17.09.26)

Cron run began on the documented `cycle_d_docs: rejected` line. Rate check:
per-day 47 % for the partial hour vs 81 % all-time — inside the documented
50–80 % band, so **no gate change was warranted for the rejection itself**.
`buffer_junk` last 25: `13 duplicate` (buffer at the 300 cap) / `10 junk` /
`1 no-tech-signal` / `1 offtopic-drop` — all documented shapes = rotation noise.
The find came from the buffer tail, the prescribed cheapest method.

**Two leak rows, both passing BOTH gates, neither ever in `buffer_junk.jsonl`:**

| cycle | u | a |
|---|---|---|
| (row 23) | physical security CIO | `Pro Why CIOs are paying closer attention to physical security By Mark Coates Published 14 September 26 Connected physical security is reshaping how CIOs approach risk, data and resilience.` |
| (row 124) | AI model exit strategy | `Pro Why every enterprise needs an AI model exit strategy By Ganesh Padmanabhan Published 15 September 26 Model flexibility helps enterprises protect workflows, institutional knowledge and control as AI evolves.` |

188 / 210 chars **with digits** → the `>=90` length trust AND the
technical-signal gate (`14 September 26`) both fired.

### The insight that was already in the repo and still did not help
`_strip_byline_prefix` (class 29, 16.09.26) exists precisely for bylines — and
the test file **already contained the exact leak string** as
`assert IL._strip_byline_prefix("By Mark Coates Published 14 September 26") == ""`.
It did not catch the live row, because the helper only removes a **LEADING**
byline segment. Here the byline sits **AFTER the headline, mid-text**:
`<chip> <headline> By <Author> Published <dd Mon yy> <lede>`.
**Before concluding a shape is new, check whether an existing helper covers the
same vocabulary but not the same POSITION** — that is a new class, not a
duplicate.

### Marker (the tight pair, in BOTH gates — the AH both-files rule)
`_is_byline_published_article_header` →
`\bBy\s+[A-Z][a-z]+\s+[A-Z][a-z]+\s+Published\s+\d{1,2}\s+[A-Z][a-z]{2,9}\s+\d{2}\b`
The discriminator is the page's own furniture **pair** (byline welded to
`Published`, unlike the class-29 `Written by … · Published …` form).

| candidate | buffer hits | conclusion |
|---|---|---|
| `published <dd> <Mon> <yy>` alone | 2, both leaks | identical on this corpus, but less specific → the pair shipped |
| `pro why` (chip) | 2, both leaks | topic word, rejected as the marker |
| `By <First> <Last> Published` | 2, both leaks | **SHIPPED** |

Measured: **0 real-prose FPs** on a 12-sentence hostile control corpus (incl.
`By Mark Coates Published research shows …`, `The paper was published in
September 2026 by the ACM …`, `By contrast, the 2024 study found …`,
`Published 2026 benchmarks show vLLM …`); **0/3,056** `longterm_episodes`.

### PITFALL — your control corpus must not contain KNOWN leaks (AJ, recurred)
The first verify run reported `prose_FPs=1` on the class-29 string
`Written by Christian Gleitze · Published June 11, 2026 · … AI Consciousness …`.
That string IS a known leak from class 29's test, not a clean control.
Proof it was not my rule: `BS._is_byline_published_article_header(t) == False`
while **pre-edit** `_is_nav_chrome(t) == True` (reconstructed the pre-edit
module by deleting my own block and importing it). Rule as before: when a
harness reports an FP, **print which rule matched**; keep control corpora clean
and assert known leaks in their own `is True` assertion.

### PITFALL — the commit landed on a FOREIGN BRANCH (new, cost the push)
`git commit` succeeded, but the repo was checked out on
`fix/28-respawn-test-psutil-hermetic` — left there by an earlier cron. The
skill's "repo is the source of truth" step silently pushed nothing toward
`main`. Then `git checkout main` **aborted** because foreign crons had left
**65 dirty files** in the working tree.

Working recovery (do this, don't fight the dirty tree):
```
git branch --show-current                        # surprise: not main
git merge-base --is-ancestor main HEAD && echo FF_SAFE
git log --oneline main..HEAD                     # main is a clean ancestor -> FF
git push origin HEAD:main                        # no checkout needed
git fetch origin main && git rev-parse origin/main   # verify the SHA landed
```
Verify with `git branch -r --contains <sha>` — if it prints nothing, the commit
is on no remote at all and the work is not backed up.
The branch here was **13 commits ahead of `main`** (earlier class 37/38/39
fixes plus foreign cron auto-commits) and `origin/main` matched local `main`,
so the push fast-forwarded all of it cleanly. **Always check the branch and the
remote SHA before and after committing**, not just the commit's exit code.

Cleanup + verify (standard shape): both rows removed by signature
(`Published 14 September 26` / `Published 15 September 26`),
**300 → 298** records, 0 unparsable, CRLF intact, **53** structural-connection
rows preserved, writer-gate census **0 of 298** (no over-gating).
`pytest tests/scripts/test_internet_learner_gate.py -q` → **59 → 60 passed**
(new `test_byline_published_article_header_is_gated_on_both_paths` asserts BOTH
gates on both leaks + 7 prose counter-cases); `pytest tests/scripts -q` →
**216 passed**. Test file appended as **pure bytes** (lone-LF census 58 → 58,
`0 removed` in the diffstat).
Post-fix live: 3 × `--once` → all 3 rejected, and `buffer_junk` shows the
rejections were honest (`6 duplicate` at the cap + documented junk shapes).
**Read `buffer_junk` before calling a rejection a regression** — again.

### Also — the appended test needs its own `import buffer_store`
The gate test file imports `buffer_store` **lazily inside each test**, not at
module level. An appended test that references it fails with
`NameError: name 'buffer_store' is not defined` while every pre-existing test
stays green. Add `import buffer_store` inside the new test function.

## Root cause AQ — TWO chrome classes in ONE cron run + the import-time trap that `ast.parse` misses (live 18.09.26)

Cron run began on the documented `cycle_g_security: rejected` line. Rate check:
per-day **71.4 %** for the partial day (5 ok / 2 rej) vs the documented 50–80 %
band → **no gate change was warranted for the rejection itself**; `buffer_junk`
last 25 = `duplicate` at the cap + documented junk shapes = rotation noise.
The finds came from the prescribed cheapest method: run `--once`, read the
BUFFER TAIL `u`/`a`, repeat after each fix. Both rows passed BOTH gates and
NEITHER was ever in `buffer_junk.jsonl`.

| class | helper | measured |
|---|---|---|
| 50 | `_is_nav_widget_run_chrome` — a document-hosting page's nav-widget run (skip carousel / go to prev·next items / footer menu / back to top / about scribd), **>=4 labels** | 1 hit, IS the leak / 0 FP / 0 le |
| 51 | `_is_news_byline_share_header` — `By <First> <Last>` + full weekday dateline + the site's own `Share` within 40 chars | 1 hit, IS the leak / 0 FP / 0 le |

**Class 50 — the threshold IS the fix, and `>=2` is a topic-word trap.** A single
label is ordinary prose (`Skip the carousel and go to the previous items`), so the
discriminator is REPETITION. `>=2` measured **4 control FPs**
(`Back to top of the article, the footer menu lists the licence.`), `>=3` still
**2** (`The UI has a skip carousel button, …`), **`>=4` measured 0** on an
18-sentence corpus, 0/511 test literals, 0/3,058 episodes. The leak holds **6**
labels, so there is headroom. Do not stop at the first clean-enough threshold —
sweep `2,3,4,5` and ship the lowest one with 0 FPs on ALL corpora.
Also: adding a SITE-IDENTITY label (`about scribd`) to rescue a threshold does
NOT help — `about scribd` is itself ordinary prose (`About Scribd, Inc. is the
footer copyright line…`) and still left 1 FP.

**Class 51 — check whether an existing helper covers the vocabulary but not the POSITION.** `_strip_byline_prefix` (class 29) already exists for bylines and
still returned the leak **unchanged**, because it only removes a LEADING byline
segment — this byline sits after a brand chip. `_is_byline_published_article_header`
(class 40) keys on `Published`, not on a weekday dateline + `Share`.

### THE TRAP THAT COST THE MOST: a closing paren glued INSIDE the regex literal
My apply template emitted

    _NAV_WIDGET_RE = re.compile(
        r"skip carousel|…|back to top"
        r"|about scribd)",        <-- the ) is INSIDE the string
        re.IGNORECASE)

`ast.parse` **passed** (it is valid Python — just a string containing a paren), so
the syntax gate said OK, and the failure only appeared at **import**:
`re.error: unbalanced parenthesis`. Two fix attempts were wasted because the
first "fix" replaced the string with itself (I anchored on the already-broken
text). **After ANY apply, `exec_module` the file — never trust `ast.parse` alone.**
`ast.parse` proves it parses; only an import proves the module-level `re.compile`
and every other constant actually evaluate. Same rule catches the `re` vs `_re`
alias trap (root cause AM) in the same step.

### Also — my `{arg}` template assumed a parameter name; the store used `t`
The class-50/51 helpers were wired with `_is_nav_widget_run_chrome(text)` in
`buffer_store` but the file's own convention there is `t` (`_is_hn_item_chrome`
takes `text`, its neighbours do not). The apply script's anchor matched 0 times
and the learner copy got patched while the store copy silently did not — the
3-copy `md5sum` is what caught it. **Read the neighbouring helper's actual
signature before templating the call**, and re-run the 3-copy md5 after every
apply pass.

### Also — pre-existing gate FPs: attribute through the PRE-EDIT module
`The newsletter is published every Thursday, and the April 30, 2026 issue covered agents.`
tripped `_is_junk` through the composite gate. My rule returned `False`, and the
pre-edit module (still on disk from the backup) returned `True` **and did not
contain my helper at all** → pre-existing, not my regression. Always load the
pre-edit module and compare; a composite-gate FP count tells you nothing about
your change (third+ occurrence of this lesson).

### Also — a class-N rule landed MID-DAY, so a stale buffer row is not a new class
The buffer held a Hacker-News item row while `_is_hn_item_chrome` (class 49,
same day) already gated it → the rule was NEWER than the row. Before designing a
helper for a gated row, `grep` the file for a rule added today; if it exists, the
row is just a pre-rule leftover → delete it by signature, no code change.

Cleanup + verify (standard shape): class-50 leak removed by signature
(`community's uploads`) **300 → 298**, then class-51 (`By Mason Leib Thursday,
April 30, 2026 Share`) **299 → 298**; every time `0 unparsable`, **55**
structural-connection rows preserved, CRLF intact (loneLF 0), writer-gate census
**2 → 0** then **1 → 0**. Note the historical "**7 is the baseline** writer-flagged
count" (root cause AM) has since decayed to **0** — re-census, don't quote the
old number.
`pytest tests/scripts/test_internet_learner_gate.py -q` → **68 → 69 → 70 passed**
(new `test_nav_widget_run_chrome_is_gated_on_both_paths` and
`test_news_byline_share_header_is_gated_on_both_paths`, each asserting the helper
AND both gates on the leak + a prose counter-case corpus); `pytest tests/scripts
-q` → **225 → 226 passed**. Tests appended as **pure bytes** (31–32 added / **0
removed**, lone-LF census 58 → 58 both times).

### Remote-divergence recovery (new — cost one push)
`git push` was rejected `non-fast-forward`: `origin/main` had gained 2 foreign
chore commits (darwin refresh + daily release) while the branch was checked out on
`fix/28-respawn-test-psutil-hermetic`. Neither touched the training scripts
(`git diff --name-only HEAD...origin/main -- <my files>` → empty). Recovery that
worked:
```
git fetch origin main
git merge-base --is-ancestor origin/main HEAD   # NO_DIVERGED
git diff --name-only HEAD...origin/main -- scripts/training tests/...   # no overlap
git stash push -m "<tag>" -- pyproject.toml     # foreign cron dirt blocked the merge
git merge origin/main --no-edit                 # clean (ort)
git -c credential.helper= -c credential.helper=store push origin HEAD:main
git stash pop                                    # restore the foreign edit untouched
```
Merge instead of fighting the dirty tree — but **`git merge` aborts on ANY dirty
file it must touch**, so stash exactly the blocking path (never `stash -A`) and
pop it afterwards so the other cron keeps its change.
Two more traps in this repo:
- **`git commit -F` needs the WINDOWS path.** `/c/Users/.../msg.txt` gave
  `fatal: could not read log file` while `C:/Users/.../msg.txt` worked — the
  MSYS→Windows conversion does not apply to `-F`.
- **`core.autocrlf=true`**, so `git show origin/main:<file> | md5sum` will NEVER
  equal the working copy's md5 (blob is LF, the file is CRLF). Verify with
  `git cat-file blob origin/main:<file> | tr -d '\r' | md5sum` vs
  `tr -d '\r' < <local>` — both matched for both modules.
Confirm the push landed with `git branch -r --contains <sha>` printing
`origin/main`, then `git cat-file blob origin/main:<file> | grep` for the new
marker — do not trust the push exit code alone.

## Root cause AR — THREE chrome classes in ONE cron run, and the `_re` alias trap catching an apply that `ast.parse` passed (live 18.09.26)

Cron run began on the documented `cycle_b_papers: rejected` line. Rate said **41 %
(last 80) / 40 % (last 20) vs 78.5 % all-time (n=1900)** — the U/V signature — so U/V
were verified BEFORE inventing anything: `_search_urls(q, k=6)` → **6,6,6,6,6 on five
diverse queries**; `_fair_share_window` → **4000 chars / 1 slice… 5 slices**. No gate
change was warranted for the rejection itself; `buffer_junk` last 20 = `duplicate` at
the 296–299 cap + documented `junk` shapes = rotation noise. All three finds came from
the prescribed cheapest method: run `--once`, read the BUFFER TAIL `u`/`a`, repeat after
each fix. All three rows passed BOTH gates and NONE was ever in `buffer_junk.jsonl`.

| class | helper | measured |
|---|---|---|
| 55 | `_is_news_aggregator_listing_run` — a press-roundup pipe run `\| <Site> <Mon DD, YYYY> <Headline>` repeated, **>=2** | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |
| 56 | `_is_devto_card_tail` — a dev.to cross-post card counter bar `<N> projects \| dev.` at the **TAIL** (`$`) | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |
| 57 | `_is_services_menu_chain` — an ALL-CAPS `X & Y` nav label **ANDED** with >=2 service titles | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |

**Class 55 — again the discriminator is REPETITION, not the parts.** One
`| Techzine Oct 08, 2025` segment is ordinary prose (`Coverage appeared | Techzine
Oct 08, 2025 and again in the roundup.`); `>=2` measured 1 buffer hit (the leak), 0 on
a 14-sentence control corpus, 0 test literals (801 extracted), 0/3,058 episodes. The
first draft required `\|\s*[A-Z][A-Za-z0-9]*\s+DATE` (site name optional-word run) and
flagged the control `We compare | Vercel Feb 3, 2026 and | Linear Mar 4, 2026 and |
Stripe Apr 5, 2026 in the study.` → REJECTED; tightening to a single site token plus a
**Capitalized headline word after the date** (`…\d{4}\s+[A-Z]`) kept the leak at
`>=3` and stayed clean at `>=2`. **Sweep the threshold, then re-sweep the token shape —
a control FP at >=2 and a miss at >=3 means the PATTERN is wrong, not the number.**

**Class 56 — only 66 chars, so the `>=90` length trust never applied.** A reminder that
the trust is not the only way chrome gets in (class 33 precedent). The anchor must be
the TAIL: `We shipped 2 projects | dev.to published the writeups afterwards.` and
`The team closed 5 projects | dev. then moved on.` are both ordinary prose and are NOT
flagged by `$`.

**Class 57 — the bare ALL-CAPS-token count was the trap.** `\b[A-Z]{2,}\b` at `>=4`
measured **36 buffer hits / 384 episodes / 1 control FP** (`vLLM … 24 GB VRAM (USA).`),
`>=5` still 23 hits and 270 episodes. Adding `Data Engineering`/`DevOps Engineering` to
the service-label set **re-introduced** the FP
`We combine AI & ML research with DevOps Engineering and Data Engineering practice.`
Keep the label set to the four titles the live page actually ships
(`RPA Development|Computer Vision|AI Integration|AI Product Engineering`) and AND it
with the ALL-CAPS `&`-label — then the corpus is 1/1 and every control, including that
same sentence, stays clean.

### THE PITFALL — `internet_learner.py` uses `re`, `buffer_store.py` uses `re as _re` (again)
The learner copies took the shared block verbatim; `exec_module` on `buffer_store.py`
raised `NameError: name 're' is not defined. Did you mean: '_re'?` **at module level**,
`ast.parse` having been perfectly happy. This is root cause AM/AQ recurring a third
time — **the apply script must import every copy it writes**, and the store block must
be emitted separately with `_re.compile`. Build ONE block per file (they differ ONLY in
the alias), never one shared string.

### Also — the leak-row cleanup guard must be widened deliberately, not deleted
`assert len(drop) == 3` fired correctly; the dropped set was exactly the three intended
rows and 56 structural-connection rows survived (the historical 53 has drifted upward —
re-count, don't quote the old number). Every step: `0 unparsable`, lone-LF 0, CRLF
intact, writer-gate census **3 → 0**.

### Verify (the standard shape, all met)
3-copy `md5sum` identical for BOTH modules after every apply
(`4c1451c0…` learner, `40c2eb8a…` store, then `217ba253…` post-push verify);
`pytest tests/scripts/test_internet_learner_gate.py -q` → **73 → 76 passed**
(3 new tests, each asserting the helper AND `_is_junk` AND `_is_nav_chrome` AND
`is_junk` on the leak plus 4–6 prose counter-cases); `pytest tests/scripts -q` →
**232 passed**. Tests appended as **pure bytes** (58 → 58 lone LF, diffstat
**237 added / 0 removed** — no EOL churn). Commit `e5a6479a9`; branch was again
`fix/28-respawn-test-psutil-hermetic` → `merge-base --is-ancestor main HEAD` = FF_SAFE,
pushed `HEAD:main`; `git branch -r --contains e5a6479a9` → `origin/main`;
**remote blob verify**: `git cat-file blob origin/main:<file> | tr -d '\r' | md5sum`
== local `tr -d '\r' | md5sum`, and the remote blob greps 3 of 3 new markers.
Post-fix live cycles: 1 reject / 2 learned, all new rows `writer=False extract=False`,
buffer 296 → 299, writer-gate census **0**.

## Root cause AU — FIVE chrome classes in ONE cron run (67–71), and the "check the test suite's own REJECTED rules" lesson (live 18.09.26)

Cron run began on the documented `cycle_a_technews: rejected` line. Per-day rate
**56.1 %** (32 ok / 25 rej) vs the documented 50–80 % band → **no gate change was
warranted for the rejection itself**; `buffer_junk` last 12 = `duplicate` at the
289 cap + documented `junk` shapes (SERP `… — <date>`, `Self-critique:` echo) =
rotation noise. Writer-gate census at entry: **0 of 289**. All five finds came
from the prescribed cheapest method: run `--once`, read the BUFFER TAIL `u`/`a`,
repeat after each fix. **Four were created by POST-FIX cycles** (the AS lesson
again: "clean at entry" does not survive the next cycle — budget one cleanup
pass per class and re-census after every fix).

| class | helper | measured |
|---|---|---|
| 67 | `_is_journal_issue_index_chrome` — `NAME NN(NN) - Month YYYY :` issue token | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |
| 68 | `_is_truncated_serp_tail` — site-suffix title + em-dash snippet + SPACE-glued trailing `…` at TAIL | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |
| 69 | `_is_docs_feature_label_weld` — two docs feature labels separated by whitespace/colon ONLY | 5 hits, ALL the docs-listing family / 0 FP / 0 le / 0 lit |
| 70 | `_is_label_bullet_chain` — >=2 `<TitleCase Label> : <value>` bullets | 2 hits, BOTH the leak family / 0 FP / 0 le / 0 lit |
| 71 | `_is_repeat_badge_glyph_run` — the page's own `U+1F195` badge on >=2 entries | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |

### THE MOST IMPORTANT LESSON — grep the test suite for ALREADY-REJECTED rules before designing one
My first candidate for the 8-row `…;` SERP-run family (rows 88/147/182/199/213/
235/278) measured **7/7 buffer hits + 0 control FPs** and looked like a clean
class-67-shaped win. It was **already tried and rejected in a previous session**,
and the gate test file says so in the docstrings it uses as counter-case prose:

    A structural "\u2026;" gate was REJECTED because 7 of the 16 such buffer rows
    (vLLM, quantization) carry genuine technical prose; the marker is the
    dictionary's own call to action instead.

`_SERP_ELL_DASH`/`_SERP_PIPE_DASH`/`_is_docs_cta_serp_run` (class 53) exist
*because* that generic rule ate real prose. **A high buffer hit-count with 0 FPs
on YOUR hand controls is not proof** — those 8 rows are exactly the rows a
previously-rejected rule would eat, so they stay un-gated by design. Before
shipping any structural candidate, `grep` the gate test file for the marker
shape; if the suite documents it as rejected, stop. (Cheapest tell: the counter-
case literals inside `assert not is_junk(prose)` lists ARE the leak rows of a
rejected rule.)

### The trailing-ellipsis family has NO clean discriminator — remove by signature only
Rows 290 (`… scalable …`) and 221 both END in `…`. Bare `\u2026\s*$` measured
**2 buffer hits but 2–3 control FPs** at every tightening
(`He was unsure …`, `So the agent kept the trailing ellipsis…`,
`The report — titled Optimization — covers tuning …`). Class 68 only became
shippable once the anchor was the **site-suffix title shape**
(`[\w\)]\s-\s[A-Z]…em-dash`) ANDed with the space-glued tail — the
`S1 site-suffix+emdash+ell-tails` form: 1 buffer hit, 0/12 controls. **Do not
gate "text ends in an ellipsis"** — that is what a truncated model output looks
like too.

### Also — "check whether an existing helper covers the vocabulary but not the POSITION" (class 68)
`_SERP_TAIL = r"—\s*(?:…|\.\.\.)\s*$"` already existed and still returned the
Haystack row **unchanged**, because it requires the ellipsis DIRECTLY after the
em-dash; here a whole snippet body sits between them and the ellipsis is
space-glued. Same shape of gap as the class-29/40/51 byline family — a new
class, not a duplicate.

### Also — measure the WELD, not the vocabulary (class 69)
`OpenAI-compatible API server` alone = 6 buffer hits but **1 control FP**
(a prose sentence that names the same feature) → topic word, REJECTED. `>=2
labels` alone = 6 hits / 3 ctrl FP / 2 episode hits. `>=3 labels` = 1 ctrl FP.
Only the **welded pair** (two labels, whitespace/colon between them, no verb, no
punctuation) reached 5 hits / 0 FP / 0 le. The docs page lost its line
separators, so its own labels are glued together — that is the discriminator.

### Cleanup + verify (standard shape, all met)
Signature cleanups: **292 → 283 → 283** records, every step `0 unparsable`, CRLF
intact, **49** structural-connection rows preserved (the historical 55 has
drifted to 49 — **re-count, never quote an old number**), learner-gate census
**0** and writer-gate census **0**. 3-copy `md5sum` identical after BOTH apply
passes (`2a418f53…`/`84e9b631…`, then `43497fa3…`/`596bf1a3…`); every module
`exec_module`-verified (the `re` vs `_re` alias trap — `ast.parse` passes).
`pytest tests/scripts/test_internet_learner_gate.py -q` → **85 → 89 → 90 passed**
(5 new tests, each asserting the helper on BOTH gates plus 4–6 prose
counter-cases); `pytest tests/scripts -q` → **245 passed**.
Tests appended as **pure bytes** (`numstat` 88 added / **0 removed**, 24 added /
0 removed; lone-LF census 58 → 58 both times).
Commits `08cce810a`, `43a297707`; branch again
`fix/28-respawn-test-psutil-hermetic`, `merge-base --is-ancestor origin/main HEAD`
→ **FF_SAFE** both rounds → `git push origin HEAD:main`
(`dc18ae902..08cce810a`, `..43a297707`). Verified with `git branch -r --contains
<sha>` → `origin/main` AND `git cat-file blob origin/main:<file> | grep -c
<marker>` → 3/3 each AND the LF-normalized md5 comparison (local == remote blob
after `tr -d '\r'`) — the push exit code alone is not proof.
Post-fix live: 3 learned / 3 rejected across two runs; the last 3 rejections are
honest (`duplicate` at the cap + a documented `GitHub - <owner>/<repo>: …` SERP
shape) with both censuses at **0 of 283**.

## Not every rejection is a regression — check the reason first
On 15.09.26 09:35–09:41 five `--once` cycles gave 1 learned / 5 rejected, after a
6/6 learned run at 09:02–09:27. Do NOT assume the latest gate change broke it:
read `tail -12 buffer_junk.jsonl` for the *reason* on those cycles. `duplicate`
= the buffer is at its 300 cap and the same (query, answer) pair came round
again — normal rotation noise, not a gate bug. Only a `junk` reason on a NEW
text shape indicates a leak worth a new root cause entry.

## Root cause AI — rate drift with rejects rotating = NO fix needed; the leak is elsewhere (live 17.09.26)

Cron run began on the documented `cycle_e_competitors: rejected` line. The skill's
order of operations was followed exactly and **no code change was warranted for
the rejection itself**:

1. **Rate first** (`internet_learn_log.jsonl`, reject-prefix rule): last 10 30 %,
   last 20 45 %, last 80 51 %, **all-time 82.6 % (n=1688)**. That is the U/V
   signature, so U/V were verified before inventing anything:
   `_search_urls(k=6)` → `6,6,6,6,6,6`; `_fair_share_window` → 5 slices / 4000
   chars ABCDE; and for `deep_learn` k2/k6 on 8 diverse queries → **5 of 8 True**.
   The 3 `False` cases were **not** a V regression: all 6 URLs fetched at 6000
   chars in each, so the fair-share windows were identical *by content* — a
   query-dependent artifact, not the dead-code bug. Do not re-patch on
   `k2 == k6` alone; fetch the pages and compare first.
2. `buffer_junk.jsonl` last 40: `16 junk / 23 duplicate / 1 no-tech-signal`. The
   junk rows were the documented shapes (2B `Self-critique:` echo, SERP
   `… — <German date> · …`) and the rest is `duplicate` at a 295/300 cap =
   **rotation noise**. No new chrome shape → correct verdict: gates untouched.
3. `.il_rotation` 1693, file mtime 17 min old, size stable → no concurrent Darwin
   writer.

What WOULD have looked like a reason to patch, and was not: a flat 30 % last-10.
Two consecutive honest rejections are the correct stopping state for gate work.

**The real find was in the buffer, not the rate**: run `--once` a few times and
read the tail of `online_buffer.jsonl` (`u` vs `a`). That produced class 23
(blog archive listing) and, after its verification cycles, class 24 (GitHub issue
page) — both of which had passed BOTH gates and were **never** in
`buffer_junk.jsonl`. Rate analysis and leak-hunting are different jobs; a healthy
rate does not mean a clean buffer.

## Bare phrase vs. anchored instruction opener (live 16.09.26)
The "structural connection" cycles buffer their OWN task instructions. The naive
fix — adding `shared underlying pattern` to `_JUNK_RE` — is WRONG: it also
swallows the genuine declarative answers (`The shared underlying pattern is a
closed-loop feedback system …`) that must stay learnable. The instruction voice
is the only reliable discriminator, so use a separate **start-anchored,
imperative** rule instead of a `_JUNK_RE` phrase:
```python
_INSTRUCTION_OPENER_RE = re.compile(r"^\s*\**\s*(?:need\b|task\s*:|goal\s*:|"
    r"find\s+(?:the\s+)?(?:structural\s+)?connection|identify\s+(?:the\s+)?(?:shared\s+)?pattern|…)", re.IGNORECASE)
```
Verify BOTH directions: 4 instruction strings must CATCH, and 2 declarative
answers (`The shared underlying pattern is …`, `Both systems use a feedback
loop …`) must stay clean. A one-directional test passes the broken version.

## Buffer record shape
`online_buffer.jsonl` rows are `{"u": <question/query>, "a": <answer text>}` —
NOT `{"text": ...}`. To inspect fresh learnings:
```python
import json
recs=[json.loads(l) for l in open('scripts/training/online_buffer.jsonl',encoding='utf-8') if l.strip()]
print(recs[-1]['u'], '|', recs[-1]['a'][:200])
```
A `tail -1 | json → r.get('text')` prints empty and looks like a silent failure
while the write actually succeeded — always read `u`/`a`.

## Apply
File: `scripts/training/internet_learner.py` (`buffer_store.py` read-only).
Wire each cycle: `q = _novel_query("<domain keywords>", queries)`.
After editing, sync the copy into `C:\Users\damir\openamer-repo/scripts/training/`
and commit + push (repo is the source of truth).

## Verify
```
python internet_learner.py --once   # run 4x; expect >=1 "learned:"/"-learn:"
```
Success rate went 0/~20 → ~2/4. Confirm `online_buffer.jsonl` tail shows fresh,
substantive prose (real sentences with numbers/verbs), not nav lists.

**`npm run test` is NOT a verifier in this repo — do not reach for it.** There
is a root `package.json` (workspaces: web, ui-tui, apps/desktop) but its
`scripts` block has no `test` entry at all; the training scripts are pure
Python. If a post-edit check tells you to run `npm run test`, the correct
substitute is:
```
openamer-repo/.venv/Scripts/python.exe -m pytest tests/scripts/test_internet_learner_gate.py -q   # 56 passed (17.09.26)
openamer-repo/.venv/Scripts/python.exe -m pytest tests/scripts -q                                 # 212 passed
```
Only `test_internet_learner_gate.py` references `buffer_store`/`internet_learner`
(`grep -rln` to confirm there is no `test_buffer_store.py` — there is not), so
the gate file is the focused check and `tests/scripts` is the no-collateral one.

Two Windows traps when running them from the agent's bash:
- **Do not prefix with `timeout`** — git-bash resolves it to Windows
  `timeout.exe`, which fails with `Ungültige Syntax. Die Standardoption darf
  nicht mehr als 1 Mal verwendet werden.` Pass `timeout=` to the terminal tool
  instead, or just run pytest directly (the suite is ~20 s).
- Quote absolute training paths (`cd "C:/Users/damir/AppData/Local/openamer-laptop/scripts/training"`).
  A bare `cd C:/Users/damir/openamer-laptop/...` (the `AppData/Local` segment
  dropped by a typo) **silently creates** that directory tree via the
  write_file path resolution, leaving a stray `openamer-laptop/` beside
  `openamer-repo/`. Found and removed once; verify with
  `ls -d C:/Users/damir/openamer-laptop` → must not exist.

## Both gates now share the structural detectors (live 15.09.26)
`internet_learner._is_junk` calls `buffer_store.is_glued_motif` (the detector was
renamed from `_is_glued_motif` to its public name for exactly this reason, commit
`85c305a18`), using the same `sys.path.insert(0, dirname(__file__))` sibling-
import idiom as `store()`. Why it matters: a candidate the WRITER gate would drop
must be rejected at EXTRACTION time, or the cycle burns 30–160 s producing a value
that never lands. The `_JUNK_RE` markers stay duplicated on purpose — they are
concrete page phrases, not logic. Do NOT hand `internet_learner._is_junk` the
whole `buffer_store.is_junk`: its SERP gate would then fire on every
`Title — snippet` the shallow path builds, forcing every cycle onto the slow deep
read.

## Verify a specific cycle WITHOUT waiting for the rotation
`--once` advances `.il_rotation`, so a targeted repro means running one cycle
function directly:
```python
import importlib.util, sys
T = "C:/Users/damir/AppData/Local/openamer-laptop/scripts/training"
spec = importlib.util.spec_from_file_location("il", T + "/internet_learner.py")
m = importlib.util.module_from_spec(spec); sys.path.insert(0, T); spec.loader.exec_module(m)
print(m.cycle_h_efficiency())     # or cycle_b_papers, ... real write, real gate
```
With `OPENAMER_HOME` poisoned this still works (see `_training_dir()` above).

## Removing a row that landed before its gate existed
Back up `online_buffer.jsonl`, filter the bad lines out on the `a` field, write
back with `newline=""` and `"\r\n".join(...) + "\r\n"` (the file is CRLF), then
re-check `sum(is_junk(r["a"]))` — it must drop by exactly the number you removed.
Live 15.09.26 this was 27 → 26 (baseline) for the salad and 27 → 26 for the
GitHub org row.

## Pitfalls
- **Truncated SERP titles + GitHub result-list titles pass `_is_serp_snippet`
  (found live 15.09.26).** `_SERP_TAIL` only fires when the em-dash+ellipsis sits
  at the very END of the text, so these two shapes were stored as learnings:
  (1) `<Title> … — <next title/snippet>` (ellipsis mid-string), e.g.
  `Jailbreaking Large Language Models: Techniques, … — This article explores …`;
  (2) `GitHub - <owner>/<repo>: <description>` incl. its SERP form
  `GitHub - amd/gaia: … — GAIA is AMD's open-source framework …`.
  Measured on the live 300-row buffer: **14 rows matched, all search-result
  chrome, 0 real-prose rows affected** (`is_junk` had flagged 0 of 300 before).
  Fix (commit `64cd94335`): two new constants `_SERP_ELL_DASH` (`…\s*[—–]\s`) and
  `_SERP_REPO_TITLE` (`GitHub\s*-\s*[\w.\-]+/[\w.\-]+\s*:`) wired as extra
  `return True` branches in `_is_serp_snippet` — a *tightening*, never a loosening.
  Verify: `8 passed` in `tests/scripts/test_internet_learner_gate.py` **and**
  re-run `is_junk` over the whole buffer (expect exactly the 14, 0 elsewhere).
  Do NOT try the generic `^<title> — <rest>` rule: it flags 115/300 rows.
  Run the gate tests with `openamer-repo/.venv/Scripts/python.exe -m pytest`
  (the live venv has no pytest).
- **Glued JSON records in `online_buffer.jsonl` (live 15.09.2026).** A writer
  appended a record WITHOUT a separator, producing `...}"}{"u": ...` on one
  line. `json.loads` then raises `Extra data`, and every loader that skips bad
  lines silently drops BOTH records — a real learning is lost with no log entry.
  Detect/fix: `python scripts/training/repair_buffer.py` (report) then `--fix`
  (backs up + rewrites). Records the buffer at 300 lines; a glued line means
  `unparsable=1` and `records` is one short.
- **`patch`/`write_file` tools mangle indentation in this file** (they re-wrapped
  a nested `for` body into an `IndentationError` twice on 15.09.26). Edit with a
  Python heredoc instead: read with `newline=''`, match anchors with
  `'\r\n'.join(...)` / `.replace('\n','\r\n')`, write back `newline=''`, then
  `ast.parse` to verify. The file is single `\r\n` (no `\r\r\n` any more).
- **`patch` silently flips CRLF→LF across the WHOLE file** (repo `tests/` and
  `scripts/` files are CRLF). Editing `tests/scripts/test_internet_learner_gate.py`
  on 15.09.26 turned a 10-line insertion into a 183/172 full-file churn commit
  (and the pushed commit can't be cleanly force-rewritten on shared `main`).
  ALWAYS edit CRLF repo files with a Python script that reads the blob
  (`git show HEAD:path`), splits on `b'\r\n'`, inserts, rejoins with `b'\r\n'`,
  writes `'wb'` — then confirm `git diff --stat <base>` shows only your added
  lines and the EOL census is unchanged. Fix-forward with a new commit (restore
  the original blob + minimal insert), never force-push `main`.
- **Doubled CR line endings**: (historic) `internet_learner.py` had `\r\r\n`; the
  `patch` tool's fuzzy matcher SILENTLY no-ops on it. Normalise to single `\r\n`
  with a small Python script BEFORE editing.
- Cron blocks `powershell -Command/-File`; use script files, not one-liners.
- **Shallow path stored GitHub repo-page chrome (found live 15.09.26).** A
  `cycle_c_github` row read `ANUS Public Notifications You must be signed in to
  change notification settings Fork 925 Star 6.` — the shallow path accepted it
  while `deep_learn`'s nav gate would have dropped it. Measured rate: 1 in ~60
  buffer rows, not systemic, but it poisons training.
  Fix (applied, commit `0fc4cbfca`): add `"signed in to change notification"`
  to `_NAV_CHROME` in `buffer_store.py` — DATA-ONLY tightening of the marker
  tuple, no logic change. Verify with `is_junk()` on the bad string (True) AND
  on 3 real prose samples (False) plus `test_internet_learner_gate.py` (8 pass).
  If more GitHub chrome appears (repo sidebar, "Watch"/"Fork" counts), extend
  the tuple the same way; never touch `_is_junk` logic.
- **Multi-line CRLF insert trap**: when inserting via a Python heredoc, the
  COMMENT lines are the ones that silently get `\n` while your code line gets
  `\r\n` → 3 lone LFs in an otherwise-CRLF file. Always end every inserted line
  (comments included) with `\r\n` and re-check `lone_lf == 0` against the
  pre-edit census before committing. `git diff --cached --stat` must show only
  `+N`.
- `buffer_store.is_junk` also rejects SERP snippets (`title … — snippet`) — that
  is correct; the deep fallback in `store_or_deep` is what recovers the cycle.
- Never loosen `_is_junk`/gates to force a pass — fix the extraction instead.

## Root cause AI — blog-sidebar post-listing widget (live 17.09.26)

Symptom: the documented `cycle_x: rejected` line, rotating across cycles. Rate
check said **60% for the day** — inside the normal 50–80% band, so NOT a
regression. U/V verified intact (`_fair_share_window` → 5 slices / 4000 chars
ABCDE; `_search_urls(k=6)` → 6/6) and the buffer byte-size stable across the
probe (no foreign writer). The rejects were genuine: 19/40 `junk` + 20/40
`duplicate`. Two independent findings from that run:

1. **The gate was right; the deep read was off-topic.** The >2/8 test
   (8 realistic queries) returned 5/8 off-topic pages — Lufthansa/SAP landing
   pages, dictionary corpora, a Berlin security firm, 2018 Wikipedia history,
   pagination chrome. `_search_urls` takes URLs in **DOM order** and
   `_usable_urls` only drops stubs: there is NO relevance check on the URL
   itself. That is a real class-level weakness, but it is NOT a stall — the
   gate correctly rejected every one of them. **Do not loosen a gate to raise
   the rate.** The fix point is deep-read URL selection.
2. **A learning that DID pass was a leak.** `cycle_a_technews` stored
   `September 2, 2026 5 Views How to Spot AI Generated Images in 2026 (The Old
   Tricks Stopped Working) September 3, 2026 3 Views Our Picks Apple Added TV
   and 200 Games to Its Cheapest iCloud Plan.` — a two-entry "recent posts"
   sidebar (date + view-counter + headline, twice). 189 chars and it carries
   digits, so the `>=90` length trust AND the technical-signal gate both fired
   and no existing marker matched.

Marker: `_is_sidebar_listing_chrome` → literal `"views our picks"`, in BOTH
gates (extraction `internet_learner._is_junk` + writer
`buffer_store._is_nav_chrome`, the AH both-files rule). Measured before touching
anything: **1 buffer hit and it IS the leak → 0 real-prose FPs** on an
8-sentence control corpus. Candidates rejected — the counter/topic trap:

| candidate | why rejected |
|---|---|
| bare `\d+ views` | 2 hand FPs: `The survey gathered 500 views…`, `In my view, prefix caching matters…` |
| `>=2 'N Views'` | ctrlFP 0 but wider than needed while one shape is live |
| `>=2 Month D, YYYY` | 4 live buffer hits — would drop real rows |

Verified: **51/51** `tests/scripts/test_internet_learner_gate.py`, census
**0 of 300 rows** flagged by the writer gate afterwards (no over-gating), and a
post-fix cycle learned real content (vLLM `Optimization and Tuning`).

### PITFALL that cost time - NEVER hand-rewrite `online_buffer.jsonl`
Removing the leak row with a plain `open(..., "w")` write **corrupted the
file**: all 299 records survived but each gained a blank line after it
(a CRLF-split yields 301 parts / 150 parsable / 151 blank). The file is CRLF,
so `.readlines()` still reports 300 while a CRLF-split reader sees 150 -
**the two readers disagree, which is the tell.** Recovery: restore the newest
intact `online_buffer.jsonl.bak.*` (check record count AND byte size, not just
mtime) and merge newer rows back by JSON signature
(`json.dumps(rec, sort_keys=True)`), then write with `newline=""` and one
record plus a CRLF per record. Prefer the buffer's own helpers
(`clean_buffer.py` / `buffer_store`) over hand-editing, and after any cleanup
re-read with a CRLF split - never `readlines()` - then assert `unparsable == 0`
and that the structural-connection rows are still there (53 in this buffer).

## Root cause AK - GitHub repo-LISTING row: counters + `Updated <date>` + label (live 17.09.26)

**Symptom**: `cycle_c_github` reports `rejected` and — the real tell — the
BUFFER contains a search-result listing row that trained as an insight:

    Python 0 MIT 3,612 0 0 Updated Jun 13, 2025 ComfyUI Public Forked from
    Comfy-Org/ComfyUI The most powerful and modular stable diffusion GUI,
    api and backend with a graph/nodes interface.

Language + counters + license + relative `Updated <date>` + the repo's own
one-line description. 186 chars cleared the `>=90` long-prose trust and the
counters/license digits fed the technical-signal gate -> BOTH gates passed it.
A second shape sat in `buffer_junk.jsonl` (`no-tech-signal`):
`Updated Oct 29, 2024 QuIP Public Code for paper: "QuIP: 2-Bit Quantization ..."`.

**This is a BUFFER leak, not a rate problem.** The rate was healthy (all-time
81 %, last-20 65 %); the rejects in the same window were honest (`duplicate` at
the 297/300 cap + documented junk shapes). Rate analysis and leak-hunting are
different jobs — a healthy rate does NOT mean a clean buffer. Scan the buffer
tail (`u`/`a`) on every run, not just the log.

**Fix**: `_is_gh_listing_row` in BOTH files (learner `_is_junk` + store
`_is_nav_chrome`), anchored PAIR:

    _GH_LISTING_ROW_RE = re.compile(
        r"\bUpdated\s+[A-Z][a-z]{2}\s+\d{1,2},\s+\d{4}\b[\s\S]{0,40}?"
        r"\bPublic\s+(?:Forked|Code|Archive|Mirror)\b")

Never key on the parts: `Updated <Mon DD, YYYY>` alone is ordinary dates and
`Public` alone is ordinary English ("Public health agencies ..."). A bare
`Forked from` was measured and REJECTED — it matches a REAL episode
("openclaw (386k GitHub stars) ... forked from ...").

**Measured** (the 0-collateral proof): 2 buffer hits, both ARE the leak; 0 of
3,056 `longterm_episodes`; 0 of 323 test-asserted clean control literals; 5
hand-built counter-cases (prose mentioning a public code repo, an updated date,
a MIT licence) all stay learnable.

**Sync pitfall found the same run**: the repo (SoT) had the class-31 test
update staged while the LAPTOP copy still carried the OLD assertion, so
`pytest tests/scripts/test_internet_learner_gate.py` was RED for a reason that
had nothing to do with the live code (the two `.py` files were
functional-AST-identical — comments only). On a red suite, FIRST diff the
laptop test file against the repo's; do not go hunting for a code regression.
Sync via `cp repo/tests/... laptop/tests/...`, then re-run.

## Root cause AJ - byline + timestamp + `| N` counter chrome (live 17.09.26)

Found the cheapest way, same cron run as AI: run `--once`, then read the tail
of the buffer and eyeball the `u`/`a` pair. `cycle_e_competitors` stored

    Kyle Orland and Benj Edwards - Dec 19, 2025 12:29 pm | 192 Which mines are
    mine, and which are AI?

an Ars Technica **article-header chrome run**: two-author byline, dateline,
comment-counter, glued to a headline whose prose tail ends in a `?`. It carries
digits and a question mark, so the length trust, the technical-signal gate and
every existing marker let it through.

Marker `_is_byline_counter_chrome` = `time + "| N"`
(`\d{1,2}:\d{2}\s*(?:am|pm)\s*\|\s*\d{1,4}\b`), wired into **both** gates
(extraction `internet_learner._is_junk` + writer
`buffer_store._is_nav_chrome`) in all 3 code copies.
Measured: 1 buffer hit and it IS the leak -> 0 real-prose FPs.
**The broad `\|\s*\d{1,4}` was REJECTED** - 1 hand FP
(`We compared | 192 | and | 256 | batch sizes in the benchmark.`) plus 3 live
buffer hits. Only the time-anchored form is safe. Verified 51/51 gate tests,
leak row dropped CRLF-safely (300 -> 299 records, 0 unparsable).

### PITFALL - your control corpus must not contain KNOWN leaks
The byline probe's control list still carried the class-29 sidebar string, so
`_is_junk` correctly flagged it and the harness reported `prose_FPs=1` for all
6 copies - a **harness bug, not a code bug**. Before calling a marker broken,
print *which* rule matched (`re.search(marker, c)`) instead of assuming the new
one did. Keep control corpora to genuinely clean prose, and put every known-leak
string in its OWN assertion (`_is_junk(known_leak) is True`), never in the
false-positive set.

### PITFALL - do not chain a ternary for keep-vs-drop
A one-line `(dropped if ... else keep).append(s)` list-selection silently
dropped 0 rows and tripped the `assert len(dropped) == 1` guard (which is
exactly why the guard belongs there). Write the plain `if/else` - KISS beats
clever when the cost of a wrong branch is silent data loss.

## Root cause AS — SIX chrome classes in ONE cron run (58–63), and the "post-fix cycles create the next leak" loop (live 18.09.26)

Cron run began on the documented `cycle_a_technews: rejected` line. Per-day rate
**54.5 %** vs the documented 50–80 % band → **no gate change was warranted for
the rejection itself**; `buffer_junk` last 20 = `duplicate` at the 296–300 cap +
documented `junk` shapes = rotation noise. All six finds came from the prescribed
cheapest method: run `--once`, read the BUFFER TAIL `u`/`a`, repeat after each
fix. **Every single leak was created by a POST-FIX live cycle** — i.e. the buffer
was clean at entry every time and the next two-or-three cycles produced the next
class. Budget accordingly: six classes needed ~20 `--once` runs in one session.

| class | helper | measured |
|---|---|---|
| 58 | `_is_pagination_newsletter_widget` — `Previous Page N of M Next` within 200 chars of `New articles by email` | 1 hit, IS the leak / 0 FP / 0 le |
| 59 | `_is_fullscreen_toggle_chrome` — `Enter fullscreen mode` + `Exit fullscreen mode` space-glued | 1 hit, IS the leak / 0 FP / 0 le |
| 60 | `_is_hashtag_run_after_headline` — >=3 whitespace-adjacent hashtags AND a TitleCase headline (>=4 caps words) before them | 1 hit, IS the leak / 0 FP / 0 le |
| 61 | `_is_dated_tag_strip_chrome` — `\u00b7 #` AND a strip of >=5 tokens with >=3 mixed-case/digit tokens | 2 hits, BOTH the leak / 0 FP / 0 le |
| 62 | `_is_model_listing_run_chrome` — >=2 `Updated <Mon DD, YYYY>` AND a `size \u00b7 Updated` separator | 1 hit, IS the leak / 0 FP / 0 le |
| 63 | `_is_trending_repo_row_chrome` — star counter `\u2605 <N>k +<M>` AND owner/slug AND a language-% stat | 2 hits, BOTH the family / 0 FP / 0 le |

### The single most useful rule from this run: measure the CONJUNCTION, not the phrase
Every class above first failed as a single-literal or single-count candidate.
The repeated shape of the failure:

| class | single-part candidate | why REJECTED |
|---|---|---|
| 58 | `Previous Page N of M Next` OR `New articles by email` alone | bounded AND flagged my own control at whole-text scope; 200-char window fixed it |
| 59 | `Enter fullscreen mode` / `Enter…Exit…mode` generic | 1–3 control FPs |
| 60 | bare hashtag count >=3 / >=4 | **71 then 42 episodes**, 2 then 1 control FPs |
| 61 | `\u00b7 #` separator; then token-count 5/6/7 | 2–3 control FPs at EVERY threshold |
| 62 | repeated `Updated <date>` alone | 2 control FPs |
| 63 | `\u2605 <N>k +<M>` star counter alone | 2 control FPs; `>=2` occurrences still 1 FP |

**So: when a count threshold is 2-FP-clean but you cannot lower it without FPs,
the PATTERN is wrong, not the number.** Add a second structural co-occurrence
(window, adjacency, density, three-way pair) and re-measure. Classes 61 and 63
both went 0-FP only after the *density* / *three-way* form.

### Also — "the buffer is clean" does NOT survive the next cycle
The AP lesson repeats: after every cleanup the census read **0**, and the next
two cycles produced the next class. Re-census after every fix; never conclude the
run is done from an entry-time census.

### Cleanup guards — widen deliberately, and re-derive the drop set
`assert len(drop) == 4` fired correctly on the class-58 pass (1 leak + 2 stubs +
1 root-cause-AG off-topic row). Class 60 needed its own separate pass because I
had applied the gate but not yet deleted the row it caught — **after applying a
gate, immediately delete the matching rows in the same step**, or the next
census reads non-zero and looks like a regression. Class 58/59/60/61/62/63
censuses: 300→296, 298→297, 300→296, 300→296, 297→296, 298→295; every time
`0 unparsable`, lone LF 0, **55** structural-connection rows (the historical 53
has drifted to 55 — re-count, never quote the old number).

### Tests — the pure-byte append again, now the standing routine
Six appends, each `git diff --cached --numstat` showing **0 removed** and the
repo file's lone-LF census **58 → 58** (the laptop copy 0 → 0). Gate-file suite
**76 → 82 passed**; `tests/scripts` **233 → 238 passed**. The test file imports
`buffer_store` lazily inside each test — an appended test MUST `import
buffer_store` itself (root cause AN pitfall, recurred). One class (63) asserts a
list of TWO leaks in a loop plus 8 prose counter-cases, because the leak family
had two shapes.

### Push — six commits, all landed on the same foreign branch
Branch was `fix/28-respawn-test-psutil-hermetic` every time;
`merge-base --is-ancestor origin/main HEAD` → `NO_DIVERGED` each round, so
`git push origin HEAD:main` fast-forwarded cleanly six times
(`e5a6479a9..995fa727e`, `..1c3907827`, `..1f1466297`, `..36709d638`,
`..f44a1c568`). Verify with `git branch -r --contains <sha>` AND
`git cat-file blob origin/main:<file> | grep -c <marker>` — the push exit code
alone is not proof.

### One leak deliberately left un-gated — the model-hallucination repetition
Row 297 (`zero-copy, zero-copy-free, and zero-copy-free`) is a 2B-model
degradation artifact. A repetition detector was measured and **REJECTED**:
`immediate repetition of a long token` flagged 8 buffer rows and **1 real
episode**, and the matches included `announcement Announcement` and
`Communications , Communications` — ordinary editorial prose. **No clean
discriminator exists for "the model broke down mid-generation", so do not gate
it**: remove by signature only. Same call as root cause AG.

## Root cause AT — THREE chrome classes in ONE cron run (64–66), and "the rejection was NOT the regression" again (live 18.09.26)

Cron run began on the documented `cycle_b_papers: rejected` line. Per-day rate
**56.0 %** (28 ok / 22 rej) vs the documented 50–80 % band → **no gate change was
warranted for the rejection itself**; `buffer_junk` last 12 = `duplicate` at the
296–300 cap + documented `junk` shapes (`Self-critique:` echo, SERP `… — <date>`,
`Nuxt HN | News …`) = rotation noise. All three finds came from the prescribed
cheapest method: run `--once`, read the BUFFER TAIL `u`/`a` pairs, repeat after
each fix. All three rows passed BOTH gates and NONE was ever in
`buffer_junk.jsonl`. Buffer was clean at entry in the sense that only 4 stale
pre-gate SERP rows were flagged — re-census after every fix anyway (the AP/AS
lesson: "clean at entry" does not survive the next cycle).

| class | helper | measured |
|---|---|---|
| 64 | `_is_de_portal_fact_box_chrome` — a German portal's own byline label + summary label pair (`\bAutor(?:in)?\s*:\s*[A-Z][A-Za-z]+\b[\s\S]{0,140}?K[üu]rze\s*:`) | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |
| 65 | `_is_prompt_echo_fragment` — the learner's own task template stored as the answer, whole-segment anchored | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |
| 66 | `_is_generated_plan_echo_fragment` — own-artifact title + `+`-list + DANGLING list marker | 5 hits, ALL the leak family / 0 FP / 0 le / 0 lit |

**Class 64 — "check whether the existing helper covers the vocabulary but not the
LANGUAGE".** Three byline helpers already exist (29 `_strip_byline_prefix`, 40
`_is_byline_published_article_header`, 51 `_is_news_byline_share_header`) and all
three are English-keyed (`By <First> <Last>`, `Published`, `Share`). A German
portal's `Autor: <Name> … in Kürze:` pair matches none of them. The discriminator
is the welded PAIR of the portal's OWN two labels; `in Kürze:` alone AND
`Autor: <Name>` alone are both ordinary German prose. Sweep note: the
order-reversed form (`in Kürze: … Autor:`) measured **0 buffer hits** — keep the
orientation that the live page ships, and prefer the tighter variant
(`Autor` + name + `Kürze:` = 0/11 controls) over the looser one
(`in Kürze:` + any of `[Autor|Banff|Alberta]` = 1 control FP, because the control
`Banff Nationalpark in Kurze: ein Park in Alberta.` contains two of the three
alternatives).

**Class 65 — a 41-char fragment: the length trust is NOT the only way chrome gets
in (class-33 precedent, third occurrence).** `Shared underlying pattern one
sentence.` is the instruction the cycle was given, stored as its answer. Why every
existing marker missed it: `_INSTRUCTION_OPENER_RE` is **START-anchored on
imperative verbs** and this is a bare noun-phrase fragment;
`_is_prompt_echo_bullet_chain` (class 42) needs **>=2 bullets**. The surviving
form is the **whole-segment anchor** (`^…pattern…one sentence.?$` with `re.M`).
All non-anchored candidates were REJECTED after measuring: any-context
`shared underlying pattern` + `one sentence` → 1 control FP; bare
`shared underlying pattern one sentence` substring → 1 control FP; `Have you
ever …?` teaser → **2–3 control FPs** (`Have you ever wished you could predict
the future, especially when it comes to your investments?` IS the leak and IS the
shape, so no discriminator exists — removed by signature only, like root cause AG
and the model-hallucination row).

**Class 66 — the leak is the AGENT'S OWN prior output, and it had FIVE copies.**
The `Structural connection between energy efficiency and …` cycles stored their
own deliverable list `KI-Performance-Optimierung: Python-Skript für
RAM/Disk/Cron-Monitoring + Optimierungsvorschläge + Skill + Cron-Job alle 12h` +
newline + `2.` (four German variants, one English). Tell: title-with-colon +
`+`-joined feature list + a **DANGLING** list marker, ending abruptly — the model
enumerated a plan and the extractor kept item 1 plus the marker. **Always group
the flagged rows before designing the marker** (root-cause-AM class-38 rule):
here the group was 5 rows of 2 languages, so the title alternation had to include
both. Threshold/shape sweep that mattered: the bare title alone hit **1 real
`longterm_episodes` row**, the bare dangling marker alone flagged the control
`Our toolchain: script + docs + tests + CI.` + newline + `2.`, and a *generic*
`^<title>: … + …` + dangling-marker form also flagged that same control. Only
adding the own-artifact title **AND** the `+`-join kept it at 0. The leak being
the agent's own prior generation is what makes the site-identity anchor
legitimate here — unlike the "`about scribd` is itself prose" rejection from
class 50.

### Also — the class-66 family was NOT the rejection's cause, and one variant slipped the first cleanup
The German signature removed 4 of the 5 copies; the **English** variant
(`Python script for RAM/Disk/Cron-Monitoring + optimization suggestions …`) had
to be deleted in a second pass. A signature-based cleanup that only lists the
language you just looked at is incomplete — after any cleanup, re-run the writer
census AND look for the same family in the other language.

### Also — always sweep the buffer for stale PRE-GATE leftovers in the same pass
The entry census read 4 flagged rows (idx 4/6/10/19) that were
`GitHub - <owner>/<repo>: …` and `<Title> | <Site> — <desc>` SERP shapes. Those
are gated by `_is_serp_snippet` (class 15, landed **15.09.26**) — the rows
**predate the rule**, which is exactly the AS precedent ("a stale buffer row is
not a new class: grep for a rule added that day; if it exists, delete by
signature, no code change"). The same pass removed them.

Cleanup + verify (standard shape): 297 → 290 → 285 records, every step
`0 unparsable`, lone LF 0, **structural-connection rows 55 → 49** (the historical
count keeps drifting — re-count, never quote an old number), writer-gate census
**4 → 5 → 0** and learner-gate census **0**.
`pytest tests/scripts/test_internet_learner_gate.py -q` → **82 → 85 passed**
(3 new tests, each asserting the helper AND `_is_junk` AND `is_junk` on the leak
plus 5–7 prose counter-cases); `pytest tests/scripts -q` → **241 passed**.
Tests appended as **pure bytes** (75 added / **0 removed**, repo lone-LF census
58 → 58), and the repo test file mirrored to the laptop + openamer-agent test
copies.
Commit `dc18ae902` on the same foreign branch `fix/28-respawn-test-psutil-hermetic`
(`merge-base --is-ancestor origin/main HEAD` → FF_SAFE), pushed `HEAD:main`;
verified with `git branch -r --contains dc18ae902` → `origin/main` **and**
`git cat-file blob origin/main:<file> | grep -c <marker>` → 3/3/3 + 1 for the new
test (the push exit code alone is not proof).
Post-fix live: 3 × `--once` → **3 learned**, all new rows writer-gate clean,
census **0 of 288**.

### Pitfall — the `-c` options must precede the SUBCOMMAND
`git push -c credential.helper= -c credential.helper=store origin HEAD:main`
prints the push `--help` and pushes **nothing** (the `-c` after the subcommand is
parsed as a push option). Correct: `git -c credential.helper= -c
credential.helper=store push origin HEAD:main`. Same reason `git commit -F`
needs the **Windows** path (`C:/Users/.../msg.txt`) while `/c/Users/...` gives
`fatal: could not read log file`.
## Root cause AT — moved to references/
AT (three chrome classes 64-66 in ONE cron run, and "the rejection was NOT
the regression" again) plus the `-c` options-before-subcommand pitfall and
the always-sweep-for-stale-PRE-GATE-leftovers rule are in
`references/root-causes-archive.md`.

## Root cause AV — TWO classes (75, 76) + the "a previous cron left gate work UNCOMMITTED" trap (live 19.09.26)

Cron run began with the documented `cycle_c_github: rejected` line. Per-day rate
**50 % (12 ok / 12 rej)** vs the documented 50–80 % band → **no gate change was
warranted for the rejection itself**; `buffer_junk` last 12 = `duplicate` at the
288/300 cap + documented `junk` shapes = rotation noise.

**THE NEW TRAP — check the repo working tree FIRST.** `git status` showed
`M scripts/training/internet_learner.py`, `M buffer_store.py`,
`M tests/scripts/test_internet_learner_gate.py`, and `git diff` revealed a
**finished class-74 + class-75 fix** (`_is_decorative_alt_text_chrome`,
`_is_bio_page_furniture_pair`) that the PREVIOUS cron run had applied to all
three copies and tested, but **never committed** — the session died after
cleanup. Head said `1508f630b fix(training): gate welded decorative alt-text
chrome (class 74)` while the working tree already carried 75. Consequences:
- The 75 leak row (`Read Full Bio Mary Cunningham …`) was **already deleted from
  the buffer** by that run (it survives only in `online_buffer.jsonl.bak75b`,
  which is how it was recovered for the commit message).
- Only the **laptop** test copy had been synced; the `openamer-agent` test copy
  still carried the old md5 → sync it before pytest.
**So the first step of every run is now `git -C <repo> status --porcelain
scripts/training tests/scripts` + `git diff --stat`** — an unfinished previous
run looks exactly like "nothing to do" from the log, and re-designing a class
that is already in the tree wastes the whole session.

| class | helper | measured |
|---|---|---|
| 75 | `_is_bio_page_furniture_pair` — publisher byline card welded to the lede (`Read Full Bio <Name>` + `Updated on: <date> / <time>` dateline) | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |
| 76 | `_is_tag_counter_run_chrome` — a tag-cloud counter strip, `>=8` `word (n)` pairs with **single-digit** counts, `len <= 400` | 1 hit, IS the leak / 0 FP / 0 le / 0 lit |

**Class 75 — the PAIR is the marker.** `Read Full Bio` alone flagged 2 hostile
controls, a bare `Mon DD, YYYY / H:MM AM` dateline 3. Only the welded pair of the
page's OWN furniture reached 0.

**Class 76 — single-digit counts are the discriminator against real prose.**
Real prose carries 4-digit counts (dates, scores) or `(12)/(8)`-style counts for
list items; the widget prints `tag (2)`, `tag (1)`. Sweep that mattered:
`>=6` pairs → **3 control FPs** (an ablation sentence naming 6 methods with
counts, a score series, a sidebar sentence), `>=8` → 0 of 7 hostile controls,
`>=10` → 0 too but the leak holds **15** so 8 keeps headroom. `len <= 400` and
`len <= 260` were equivalent here; keep the 400 cap.
Note a deliberate harness distinction: a control sentence that **is** the widget
shape (`Tag counts were AI (2), mcp (2), … across the sidebar.`) is asserted as a
**leak** (its own `assert IL._is_tag_counter_run_chrome(...) is True`), never
listed in the false-positive set — the AJ/AN/AQ/AU control-corpus rule again.

**Verify (standard shape, all met):** 3-copy `md5sum` identical for both modules
after the apply (`35c5ba0f…` learner, `a711e236…` store) and after the class-75
commit; every module `exec_module`-verified (the `re` vs `_re` alias trap —
`ast.parse` was already green); `pytest tests/scripts/test_internet_learner_gate.py
-q` → **94 → 95 passed**; `pytest tests/scripts -q` → **251 passed**; test file
appended as **pure bytes** (41 added / **0 removed**, lone-LF census 58 → 58);
buffer census **0 / 0** (learner / writer) at 290 records, **49** structural rows
preserved. Commits `929b4f919` (75) and `d50ec4231` (76) on the foreign branch
`fix/28-respawn-test-psutil-hermetic` (`merge-base --is-ancestor origin/main
HEAD` → FF_SAFE), pushed `HEAD:main`; verified with `git branch -r --contains`
→ `origin/main`, `git cat-file blob origin/main:<file> | grep -c <marker>` →
3/3/1, and the LF-normalized md5 (remote blob == local after `tr -d '\r'`).
Post-fix live: 3 × `--once` → 1 learned (real paper prose) / 2 rejected, both
rejections honest (`duplicate` at the cap + a documented SERP shape), new row
`writer=False extract=False`.

137 (22.09.26): a docs-site breadcrumb welded to a REPEATED title prefix, AND
`_FULL_DATE_RE` (class 35) accepting ABBREVIATED months -- it was wired but had
a blind spot for `Sep 24, 2025`. Also: the per-FILE merge resolution (HEAD vs
origin/main measured, not assumed), and `clean_buffer.py` has NO `--help`
(it just runs). refs/.
**140** (a paper/arXiv AUTHOR LIST with affiliation superscripts -- `cycle_g_security` stored an author block twice; discriminator is the affiliation segment repeated, with a STRUCT-word guard so "Section 3, Figure 2, Table 1, ..." stays learnable; the `_re`/`re` alias fired via `_recompile`, and the guard was red from pre-existing scratch litter) is archived there too.
**141** (a year-welded SERP TITLE restated by its own SNIPPET -- 4 rows of one family in the buffer tail, incl. `Grok Pricing 2026:` and `Claude Opus 5 Review 2026:`. Neither conjunct separates: the year-colon weld alone hits 6 prose controls, a bare repeat hits 201 real episodes + 35 asserted gate literals; the PAIR is 0 FP everywhere. The restatement is an identical price token, an identical `<verb> <n> %` pair, or an identical 4-token run of PLURAL-STEMMED tokens -- a backreference cannot see the NER row's `LLMs`->`LLM` drift. The China-chip row (real article, bare `417%` across different verbs) survives by construction and is the control that decides the rule. The `_re`/`re` alias returned a THIRD time on a new face: alias `re.IGNORECASE` too, not just `re.compile`; and `open(p,'wb',newline='')` is a TypeError that half-applies a patch BEFORE the census assert) is archived there too.
**142** (the SILENT-DROP family: `internet_learner._is_junk()` accepted what `buffer_store.is_junk()` refused -- 368 of 600 audited junk rows; missing detectors `_is_serp_snippet` 222 / `self-critique` marker 109 / `_is_nav_chrome` 88. Fix = `_writer_gate_refuses()` consulted at the write decision in `store()`, audited under the new reason `writer-gate`; plus `active_learn.store_if_trainable()` + `_strip_reasoning_trace()`. PITFALL: never fold the writer into `_is_junk` -- `_clean_insight` depends on the extractor's looser rule, 4 tests regress) is in refs/.
**143/144** (22.09.26: 143 = the silent drops were NOT the rejection rate -- fixing 142 moved the loss from invisible to visible without raising yield; 144 = class 142 shipped as a pure REJECT predicate and over-rejected, 24 of 60 refused rows carry real prose behind the header stack. Fix = `_strip_article_byline_header(region=100)`, applied where `store()` judges the RAW text -- a strip inside `_clean_insight` is UNREACHABLE because `_is_junk(raw)` fires first. `region=200` broke 36/6,128 episodes, `region=100` breaks 0. PITFALL: `write_file` TRUNCATES -- append to this archive with a BINARY `'ab'` write only) is in refs/.
**145** (22.09.26: the spelled-out read-time WELD (`Reading time 5 min`) and the
ORDINAL dateline (`March 6th, 2025`) -- the class-142 vocabulary had neither, so two
rows were STORED; the bare weld is a topic-word trap and was MEASURED-AND-REJECTED,
the ANCHORED form is +2 leaks / 0 FP) is in refs/.

**146** (22.09.26: a SINGLE aggregator feed row -- handle + relative time +
`| N comments` + points + a capitalized second handle + headline. class 37
wants the unit REPEATED, 49 the aggregator's name, 83 an arXiv year tail, so a
one-item row passed both gates; fix = the trailing points/handle pair. Also:
`(?-i:[A-Z])` scoped case-sensitivity -- under IGNORECASE a bare `[A-Z]` token
re-admits lowercase prose. Also: regex NEVER via shell heredoc, and a whole-file
`cp` across diverged trees pulls unrelated work in) is in refs/.
**147** (22.09.26: German consultation/contact chrome -- `Wir beraten Sie
persönlich unter 0681 5866-4466 (Mo-Do 9-18 Uhr)` welded to a nav lockup. The
conjunction of a consultation term and a contact marker within 90 chars on ONE
line; scan forward from EACH match and cut at the newline) is in refs/.
**148** = the learner's OWN bare `Need ...` generation PLAN, stored 12x -- class 142 MIRRORED (here the WRITER was looser than the learner). LESSON: a predicate on only ONE of the two gates is a hole, either direction. Archived in refs/.
**149/150/151** (23.09.26: 149 = the cycle was FINE -- the LIVE tree is a second stale copy, diff it against ~/openamer-repo before any gate fix; traces ONE rejection via a buffer_store._audit spy, 60/70 writer-gate hits are _is_serp_snippet, which the learner has no counterpart for. 150 = a 0-BYTE marker file proves an "install root" in 12 consumers -> _vaultfinal phantom swarm, 781 runs "ok" on 0 tasks; rule: file marker NON-EMPTY, dir marker >=1 NON-EMPTY file. 151 = git push HANGS while ls-remote is fast -> the GCM credential helper, NOT the network:  -> 124; fix , then ls-remote sha == HEAD) in refs/.
**152** (23.09.26: "the live tree is AHEAD of the repo" is NOT "work is unlanded" -- a pairwise diff against ONE checkout is BRANCH NOISE; measure the content UNION over ALL refs: 0 live-only lines, the 143/144 gaps already published on open PR #47, 0 refs shipping the class-143 gate without the `(?-i:)` scope, and the unscoped `[A-Z]` hazard measured at 0 corpus cost) in refs/.
**157** (23.09.26: a docs/SECTION-HEADING STACK welded to an interrogative heading -- TWO rows passed BOTH gates; fix = `is_docs_heading_qweld` (question-weld + len>=80 + cap-ratio>=0.50 + <=1 terminator) in both gates; REJECTED: bare question-weld (2 real episode hits), TitleCase-run rule (215 episodes), cap>=0.55; PLUS two live git traps -- a non-FF push on a strict-superset file content needs a fresh worktree off origin/main, never a rebase of the shared live tree, and `git worktree add` under MSYS mangles `/c/...` to `C:/c/...`, so pass the NATIVE path) in refs/.
**158** (23.09.26: a BibTeX CITATION RECORD welded to a license footer -- fix = the CONJUNCTION of a prose-valued `field = {value}` pair AND a license footer, in both gates; every part ALONE was measured-and-rejected, as was the BibTeX field VOCABULARY (5 hostile FPs); the `re` vs `_re` alias trap fired a THIRD time -- `ast.parse` stays green, only `exec_module` catches it) in refs/.
**159** (23.09.26: a SECURITY-ADVISORY LISTING CARD -- GHSA-id + the list's own BARE numeric pager `Previous 1 2 3 Next`, in both gates; the near-miss matters MORE than the class: the date-free form PASSES `_is_nav_list` and the advisory date's ONE COMMA disarms it, so measure `_is_nav_list` on a nav-shaped leak BEFORE designing a rule; every part ALONE measured-and-rejected, incl. GHSA+severity (2/3 citing prose) and pager+date (3/4 both-part controls); also: a REGEX scan of test literals under-counts by splitting implicit concatenation -- use `ast.Constant`) in refs/.
**161** (23.09.26: the `writer-gate` census ATTRIBUTED for the first time -- on the last 300 writer-gate rows, `_is_serp_snippet` refuses 140/152 (92 %) while `internet_learner._is_junk()` returns False on 152/152, so the 142 disagreement is quantified AND singly-sourced; still NON-FIX, because the reject streak is 8 vs a whole-log max of 14 and the last 60 `duplicate` rows carry 36 distinct `u` (not the 121/128 saturation signature). Folding the writer into `_is_junk` is the 142 MEASURED-AND-REJECTED fix -- attribute first, re-open only if the streak exceeds 14) in refs/.
**166** (23.09.26: a GitHub-trending listing row with the relative-age badge WELDED to `release` (`2yrs agorelease`); the MISSING SPACE is the discriminator, the loose spaced form measured-and-rejected on 2 real-prose controls; gate the PAIR in BOTH gates. Same run: the entry buffer still carried a class-165 row whose gate already existed -- applying a gate is NOT a cleanup, delete the rows in the same step; and the whole 166 fix was left UNCOMMITTED by the previous cron (class-AV trap, 2nd time) -- `git status --porcelain scripts/training tests/scripts` FIRST. New pitfall: `io.open(p,'wb').write(expr)` TRUNCATES p BEFORE evaluating expr, so a NameError leaves a 0-byte module -- write `<p>.tmp` then `os.replace`) in refs/.