docs: describe v0.7.1

Claude-Session: https://claude.ai/code/session_014prTNuJnKuwcAd28vUZAnN
feat(observe): record real tool failures from PostToolUseFailure
2026-10-13 04:59:16 +00:00 · 2026-09-25 03:16:02 +01:00 · 2026-09-25 03:16:01 +01:00 · 2026-09-25 03:07:34 +01:00 · 2026-09-25 02:45:22 +01:00 · 2026-09-25 02:38:39 +01:00
27 changed files with 5979 additions and 282 deletions
@@ -1,157 +1,305 @@
+<div align="center">
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="./assets/logo-dark.svg">
+  <img src="./assets/logo-light.svg" alt="claude-adam logo" width="128" height="128" />
+</picture>
+
 # claude-adam

-Self-improvement layer for [Claude Code](https://claude.com/claude-code) that observes friction signals during your sessions and proposes targeted improvements (new skills, memory entries, agent edits) which you can review and apply.
+**A self-improvement layer for [Claude Code](https://claude.com/claude-code).**

-## What's new
+Watches the friction in your coding sessions, clusters the signals via an LLM analyst, and proposes targeted improvements — new skills, memory entries, agent edits — that you review and apply.

- **v0.3.1** — code review pass: bug fixes (`errorFingerprint` no longer false-positives on `is_error: false`, archive script handles same-millisecond duplicates correctly, `tool_window` now clears on session change, nudge filters proposal filenames by pattern), prose conciseness cuts, hardened `install.sh` with curl one-liner + settings.json merge, `adam-uninstall.sh`, isolated test harness (no longer pollutes live `~/.claude/adam/` state).
- **v0.3.0** — causal diagnosis: every proposal carries a `# Diagnosis` block (Trigger/Action/Mismatch/Outcome with verbatim transcript quote) before drafting, plus optional `contradiction_flag` heuristic that vetoes auto-apply on obviously-conflicting `skill_edit` additions.
- **v0.2.1** — win signals (`correction_free_streak`, `clean_recovery`) feed `skill_edit` auto-apply under a strict gate (≤30 LOC, ≤2× byte cap, 7d cooldown, 30d blacklist on rejection).
- **v0.2.0** — actioned-entry archival via `adam-archive.mjs`; `cursor` field deprecated.
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Version](https://img.shields.io/github/v/release/lukaszraczylo/claude-adam?label=version&color=blue)](https://github.com/lukaszraczylo/claude-adam/releases)
+[![Tests](https://img.shields.io/badge/tests-150%20passing-brightgreen.svg)](./adam/tests/run-tests.sh)
+[![Node](https://img.shields.io/badge/node-22%2B-339933.svg)](https://nodejs.org)
+[![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Linux-lightgrey.svg)]()

-## What it does
+</div>

-A lightweight Node.js hook (`adam-observe.mjs`) runs on `UserPromptSubmit`, `PreToolUse`, and `PostToolUse` events. It detects:
+---

-| Signal | Trigger |
-|---|---|
-| `correction` | User prompt contains "no", "stop", "wrong", "actually", etc. after a tool call |
-| `retry_loop` | Same tool + same args called 3× in a 10-event window |
-| `weak_agent` | Same subagent dispatched 2× in last 5 tool calls |
-| `tool_error_loop` | Same error fingerprint appears 3× in a 5-event ring |
-| `dead_end` | 8 PostToolUse events without a UserPromptSubmit between them |
-| `edit_churn` | Same file edited 4× in a window |
-| `build_loop` | 2× build/test/compile commands fail in same session |
-| `subagent_dispatch_pattern` | Same subagent dispatched ≥3× cumulatively |
-| `correction_free_streak` | 5 clean UserPromptSubmits in a row (no correction phrase) — feeds `skill_edit` reinforcement |
-| `clean_recovery` | 3 clean PostToolUse events after a struggle signal — feeds `skill_edit` reinforcement |
+## The story behind Adam
+
+Adam is my newborn son.
+
+Watching him over the last few months — the way he observes the world, tries something, watches what happens, adjusts, and tries again — I realised that the most powerful learning loop in nature is also one of the simplest. No grand theory. No instruction manual. Just relentless feedback and pattern recognition, applied to every waking moment.
+
+LLMs can learn the same way. Give them a hook into the real friction of your work — the corrections, the dead-ends, the moments you say *"no, try again"* — and let them propose improvements grounded in **what actually happened**. Not what they assume might help. What you actually struggled with.
+
+**claude-adam** is that loop, wired into Claude Code. It's named after Adam because the methodology is his.
+
+---
+
+## Highlights
+
+- 🔍 **Zero LLM cost at observation time.** Deterministic regex + counter detection in a Node hook. The analyst only runs when you invoke `/reflect`.
+- 📡 **11 signal types.** Friction (`correction`, `tool_error_loop`, `dead_end`, `edit_churn`, …) + reinforcement (`task_completed`, `correction_free_streak`, `clean_recovery`) + meta.
+- 🛡️ **Tight auto-apply gates.** Confidence ≥ 4, cross-session evidence, contradiction veto, per-(skill, fingerprint) cooldown. Most things queue for your manual review.
+- 📊 **A/B effectiveness measurement.** Every auto-applied edit gets a 7-day pre/post signal-count delta. If a proposed fix made things worse, the next `/reflect` says so.
+- ⏳ **Per-signal sliding windows.** Stale friction doesn't accumulate forever. `dead_end` 7d, `correction` 30d, reinforcement signals 60d.
+- 🔬 **Observable.** Every clustering decision (passed / threshold-blocked / window-filtered / contradiction-vetoed) emits a trace. `/reflect --explain` shows it.
+- 📦 **Pure Node.** Zero npm dependencies. Runs on macOS and Linux (Alpine smoke-tested).
+
+## Quick start
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/lukaszraczylo/claude-adam/main/install.sh | bash
+```
+
+The installer copies files into `~/.claude/`, offers to merge ADAM's hook entries into `~/.claude/settings.json` (with a diff preview and `[y/N]` confirm), and preserves any local edits via `.adam-new` sidecar files. Pass `--yes` to skip prompts, `--dry-run` to preview.
+
+Then:
+
+```sh
+bash ~/.claude/adam/tests/run-tests.sh   # expect: 150 passed, 0 failed
+# … start a fresh Claude Code session …
+/reflect                                  # walks the proposal queue
+/reflect --explain                        # also shows the analyst's clustering trace
+```
+
+Pin a release for reproducibility:
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/lukaszraczylo/claude-adam/v0.6.3/install.sh \
+  | VERSION=v0.6.3 bash
+```
+
+### Staying up to date
+
+`install.sh` records the installed release in `~/.claude/adam/.version`. The
+SessionStart hook (`adam-nudge.mjs`) then checks the latest GitHub release **at
+most once a day** (cached in `~/.claude/adam/.update-check.json`, network call
+hard-capped at 1.5 s, fully best-effort — it never blocks or slows session
+start). When a newer release exists it prints a one-line, **notify-only** prompt:
+
+```
+[adam] update available: v0.6.3 → v0.6.4. Apply: curl -fsSL …/install.sh | bash
+       (re-runs install.sh — resets ADAM's own /reflect-applied skill edits; apply when you're ready)
+```
+
+It is deliberately **not** auto-applied: re-running `install.sh` overwrites
+ADAM's own `/reflect`-applied skill edits, so you decide when to take an update.
+Disable the check entirely with `ADAM_NO_UPDATE_CHECK=1` in your environment.
+
+## How it works
+
+```mermaid
+flowchart TB
+    subgraph OBS["Observation (deterministic, in-hook, zero LLM cost)"]
+        direction LR
+        EV["Tool event /<br/>user prompt"] --> OBSERVE["adam-observe.mjs<br/><sub>regex · counters · ring buffers</sub>"]
+        OBSERVE --> JOURNAL[("journal.jsonl<br/><sub>append-only signal log</sub>")]
+    end
+
+    JOURNAL -. user runs <code>/reflect</code> .-> ANALYSIS
+
+    subgraph ANALYSIS["Analysis (LLM, only on demand)"]
+        direction TB
+        subgraph PRE["Pre-processors (deterministic)"]
+            direction LR
+            W["adam-window.mjs<br/><sub>per-signal sliding window</sub>"]
+            S["adam-score.mjs<br/><sub>task_completed dampener<br/>+ reinforcement candidates</sub>"]
+            AB["adam-ab-measure.mjs<br/><sub>7d pre/post deltas<br/>on prior auto-applies</sub>"]
+        end
+        AGENT["adam subagent<br/><sub>cluster · score · diagnose</sub>"]
+        PRE --> AGENT
+        AGENT --> PROPOSALS[("proposals/")]
+        AGENT --> TRACE[["clustering trace<br/><sub>adam-explain.mjs renders</sub>"]]
+    end
+
+    PROPOSALS --> REVIEW
+
+    subgraph REVIEW["Review + apply"]
+        direction TB
+        GATE{"auto-apply<br/>gates pass?<br/><sub>conf≥4 · low blast<br/>· cooldown cool</sub>"}
+        GATE -->|yes| APPLIED[("applied/<br/>+ ab-tracking.jsonl")]
+        GATE -->|no| QUEUE["walk-the-queue<br/><sub>approve · reject · edit</sub>"]
+        QUEUE -->|approve| APPLIED
+        QUEUE -->|reject| REJECTED[("rejected/")]
+    end
+
+    APPLIED -. measures back into .-> AB
+
+    classDef store fill:#e8f4fd,stroke:#5b9bd5,stroke-width:2px,color:#1f3a5f
+    classDef proc fill:#fff4e6,stroke:#e8a33d,stroke-width:1px,color:#5a3d0f
+    classDef trace fill:#f0e8fd,stroke:#7e5dc0,stroke-width:1px,color:#2f1e60
+    class JOURNAL,PROPOSALS,APPLIED,REJECTED store
+    class EV,OBSERVE,W,S,AB,AGENT,QUEUE proc
+    class TRACE trace
+```
+
+The observation layer is a ~600-line Node hook. Pure regex, counters, ring buffers — no LLM in the hot path. Signals append one JSONL line per detection to `~/.claude/adam/journal.jsonl`.
+
+The analysis layer is an LLM subagent invoked by `/reflect`. Before the analyst runs, three deterministic pre-processors filter and enrich the journal: `adam-window.mjs` drops stale entries per per-signal age, `adam-score.mjs` computes per-session urgency dampeners + reinforcement candidates, and `adam-ab-measure.mjs` checks whether previously auto-applied edits actually reduced their originating signal.
+
+The analyst clusters signals, scores them against a deterministic rubric (see below), and emits proposal markdown files to `~/.claude/adam/proposals/`. Each proposal carries a `# Diagnosis` block (Trigger / Action / Mismatch / Outcome with a verbatim transcript quote), a `# Success criterion`, and the source journal-entry timestamps it clustered.
+
+Auto-apply runs only for low-blast types (memory entries, new skills, ephemeral nudges, reinforcement logs) backed by cross-session evidence. Everything else queues for your manual approve / reject / edit walk.
+
+## Signals
+
+| Signal | Trigger | Window* |
+|---|---|---|
+| `correction` | Strong tokens (`stop`, `wrong`, `undo`, …) OR weak tokens (`no`, `actually`, `wait`) with negation/contrast nearby | 30d |
+| `retry_loop` | Same tool + same args called 3× in a 10-event window | 14d |
+| `weak_agent` | Same subagent dispatched 2× in last 5 tool calls | 30d |
+| `tool_error_loop` | Same error fingerprint 3× in a 5-event ring (fingerprints normalised — `ECONNREFUSED` and `"Connection refused"` cluster) | 30d |
+| `dead_end` | 8 PostToolUse events without a UserPromptSubmit between them | 7d |
+| `edit_churn` | Same file edited 4× in a window | 14d |
+| `file_reread` | Same file Read ≥3× in the 10-event window, ignoring offset/limit (catches re-reads that escape `retry_loop`'s arg-hash dedup) | 14d |
+| `build_loop` | 2× build/test/compile commands fail in same session | 30d |
+| `subagent_dispatch_pattern` | Same subagent dispatched ≥ 3× cumulatively | 30d |
+| `correction_free_streak` | 5 clean UserPromptSubmits in a row — reinforcement input | 60d |
+| `clean_recovery` | 3 clean PostToolUse events after a struggle signal — reinforcement input | 60d |
+| `task_completed` | 5 tools / 3 kinds / 0 corrections — fed into the urgency dampener + reinforcement candidates | 60d |
+
+\* Per-signal sliding window for `/reflect` analysis. See `SIGNAL_WINDOWS_DAYS` in `adam/scripts/adam-window.mjs`.

 Detection is local, regex-based, zero LLM cost. Signals append to `~/.claude/adam/journal.jsonl`.

-When you run `/reflect`, the `adam` subagent reads the journal, clusters signals, scores them against a deterministic rubric, and emits proposal files to `~/.claude/adam/proposals/`. Auto-applied proposals only ship for low-blast types (memory, new skills) backed by cross-session evidence; everything else queues for your manual approve/reject/edit walk.
+## Auto-apply rubric

-## Why
+```
+Sum:
+2  Signal repeated ≥ 3× across ≥ 2 sessions (within signal's window)
+2  Struggle signal appearing ≥ 1× within a single session (does not stack)
+2  Transcript contains positive endorsement near related action
+1  Multi-axis cluster (≥ 2 distinct struggle types in same session)
+-1  Type-bias penalty (≥ 3 rejections, applied:rejected < 1:2)
+1  Blast radius low (memory or new isolated skill)
+ 0  Blast radius medium (new agent, new hook, edit existing skill)
+-1  Blast radius high (CLAUDE.md, settings hooks, edit agent, deletion)
+1  Surgical (one file, ≤ 50 LOC for non-skill_new; ≤ 80 LOC for skill_new)
+-3  Touches deny-list (settings.json hooks/permissions, CLAUDE.md, deletions)
+```

-LLM coding sessions reveal repeated friction the moment you stop and look. ADAM looks so you don't have to.
+Modifiers applied at scoring time:
+
+- × `dampener` from `adam-score.mjs` (0.5 / 0.75 / 1.0 based on session's `task_completed` count) — sessions that net-succeeded score lower urgency.
+
+`auto_apply_eligible` requires **all** of:
+
+- `confidence ≥ 4`
+- `blast_radius == low`
+- `type ∈ {memory, skill_new, nudge, reinforcement}` (or `skill_edit` via the win-driven gate)
+- `cross_session_evidence == true` (except `nudge`, which is single-session by design)
+- `adam-cooldown.mjs` returns `cool` for `(target_skill, proposal_fingerprint)`
+- `contradiction_flag` unset
+
+`skill_edit` additionally requires:
+
+- Win-signal evidence (`correction_free_streak` / `clean_recovery` cites target skill)
+- Diff is append-only, ≤ 30 LOC, resulting size ≤ 2× original
+- No auto-edit to same target in past 7 days (per-fingerprint cooldown)
+- No rejection-blacklist on target in past 30 days
+- `# Diagnosis` section present + structurally valid
+
+Everything else queues.
+
+## Lifecycle: from signal to permanent improvement
+
+Every proposal records the journal entry timestamps that fed its cluster (`source_entries` in frontmatter). When you apply or reject a proposal, the skill calls `adam-archive.mjs` which moves matching entries from `journal.jsonl` to `journal/actioned-<id>.jsonl`. The result:
+
+- `journal.jsonl` stays bounded by **active** observations only.
+- The next `/reflect` reads `applied/` + `rejected/` frontmatter, builds an excluded-timestamps set, and skips any leftover journal entries that were already actioned.
+- Rule changes (e.g. lowering a threshold) immediately re-evaluate the remaining active observations — no manual cursor rewind needed.
+
+Auto-applied proposals additionally append to `~/.claude/adam/ab-tracking.jsonl`. The next time `/reflect` runs (and 7+ days have passed), `adam-ab-measure.mjs` computes a pre/post delta of the originating signal count. Status: `improved` / `neutral` / `regressed` / `no_baseline` / `pending`. Regressions surface at the top of the analyst's output so a bad fix doesn't quietly persist.
+
+## Inspecting the analyst's reasoning
+
+Every `/reflect` run also writes the analyst's clustering trace to `~/.claude/adam/last-trace.txt`. The trace records, per cluster: signal type, occurrence count, sessions, which gates passed or failed, and whether the cluster produced a proposal or was skipped (with reason: `threshold` / `cross_session` / `window` / `contradiction` / `other`).
+
+```sh
+node ~/.claude/adam/scripts/adam-explain.mjs --mode summary   # SUMMARY + per-decision counts
+node ~/.claude/adam/scripts/adam-explain.mjs --mode full      # verbatim trace + rejection histogram
+node ~/.claude/adam/scripts/adam-explain.mjs --mode json      # machine-readable
+```
+
+Or pass `--explain` to `/reflect` to render the full trace inline.
+
+## What it will not do
+
+- 🚫 No background LLM spend. The analyst runs only when you invoke `/reflect`.
+- 🚫 No retroactive transcript mining beyond the journal.
+- 🚫 No hard `rm` of any artifact. Deletions are soft (`mv` to `trash/<ts>/`).
+- 🚫 No autonomous edits to `CLAUDE.md`, agents, hooks, or `settings.json` — these always queue for review regardless of confidence.
+- 🚫 No proposal that matches a previously-rejected idea (≥ 2 token overlap with rejection's `# Why`).
+- 🚫 No invented trigger phrases for new skills — every trigger comes from observed user input.

 ## Layout

 ```
 ~/.claude/
 ├── hooks/
-│   ├── adam-observe.mjs      # signal collector
-│   └── adam-nudge.mjs        # SessionStart reminder when ≥3 proposals queued
-├── agents/adam.md            # analyst subagent (system prompt + rubric)
-├── skills/adam-self-improvement/SKILL.md  # /reflect protocol
-├── commands/reflect.md       # /reflect slash command
+│   ├── adam-observe.mjs              # signal collector (UserPromptSubmit / PreToolUse / PostToolUse / PostToolUseFailure)
+│   └── adam-nudge.mjs                # SessionStart reminder + pending-upgrade warning
+├── agents/adam.md                    # analyst subagent (system prompt + rubric)
+├── skills/adam-self-improvement/
+│   ├── SKILL.md                      # /reflect protocol
+│   └── apply-by-type.md              # per-type apply steps, read before any apply
+├── commands/reflect.md               # /reflect slash command
 └── adam/
-    ├── journal.jsonl         # append-only signal log (active observations)
-    ├── journal/              # rotated daily logs + actioned-<id>.jsonl per applied/rejected proposal
-    ├── state.json            # per-session counters
-    ├── usage.json            # skill/agent invocation tallies + payload visibility counters
-    ├── proposals/            # queued, awaiting review
-    ├── applied/              # approved + auto-applied archive
-    ├── rejected/             # rejected (with reason)
-    ├── trash/                # soft-deleted artifacts (recoverable)
-    ├── scripts/              # adam-archive.mjs (called by skill on apply/reject)
-    └── tests/run-tests.sh    # 27 verification tests (isolated tmpdir; never touches live state)
+    ├── journal.jsonl                 # active observations
+    ├── journal/                      # rotated weekly (YYYY-Www.jsonl) + actioned-<id>.jsonl
+    ├── state.json                    # per-session counters
+    ├── usage.json                    # invocation tallies + visibility metrics
+    ├── active-nudges.json            # ephemeral SessionStart reminders (auto-expire)
+    ├── ab-tracking.jsonl             # one entry per auto-apply, drives effectiveness measurement
+    ├── reinforcements.jsonl          # appended on reinforcement proposal apply
+    ├── last-trace.txt                # most recent analyst clustering trace
+    ├── proposals/                    # queued, awaiting review
+    ├── applied/                      # approved + auto-applied archive
+    ├── rejected/                     # rejected with reason
+    ├── trash/                        # soft-deleted artifacts (recoverable)
+    ├── scripts/
+    │   ├── adam-utils.mjs                  # shared journal-reading + frontmatter parsing
+    │   ├── adam-window.mjs                 # per-signal sliding-window filter
+    │   ├── adam-score.mjs                  # urgency dampener + reinforcement candidates
+    │   ├── adam-ab-measure.mjs             # 7d pre/post delta per auto-applied edit
+    │   ├── adam-cooldown.mjs               # per-(skill, fingerprint) cooldown gate
+    │   ├── adam-nudge-eligibility.mjs      # dead_end session-count check
+    │   ├── adam-explain.mjs                # clustering trace parser/renderer
+    │   ├── adam-batch.mjs                  # evidence batching (optional output cap)
+    │   ├── adam-rollback.mjs               # auto-rollback of regressed proposals
+    │   ├── adam-skill-utility.mjs          # per-skill good:bad utility report
+    │   ├── adam-apply-reinforcement.mjs    # reinforcement proposal apply
+    │   ├── adam-apply-nudge.mjs            # nudge proposal apply (message + cue)
+    │   ├── adam-upgrade.mjs                # .adam-new file UX (list/diff/accept)
+    │   └── adam-archive.mjs                # post-apply journal cleanup
+    └── tests/run-tests.sh            # 150 isolated tests of the tree it sits in; never touches live state
 ```

-## Install
+## What's new

-### One-liner (recommended)
-
-```sh
-curl -fsSL https://raw.githubusercontent.com/lukaszraczylo/claude-adam/main/install.sh | bash
-```
-
-Pin a release for reproducibility:
-
-```sh
-curl -fsSL https://raw.githubusercontent.com/lukaszraczylo/claude-adam/v0.3.1/install.sh \
-  | VERSION=v0.3.1 bash
-```
-
-The installer clones the repo to `/tmp`, copies files into `~/.claude/`, and offers to merge ADAM's hook entries into your `~/.claude/settings.json` (with a diff preview and `[y/N]` confirmation — your existing hooks are preserved). Pass `--yes` to skip the prompt; `--dry-run` to preview without writing.
-
-Requires `git`, `curl`, `jq`, and `node` 18+.
-
-### From a clone
-
-```sh
-git clone https://github.com/lukaszraczylo/claude-adam
-cd claude-adam
-./install.sh
-```
-
-### Upgrade-safe
-
-These files are **never overwritten** if they already exist:
-
- `~/.claude/adam/journal.jsonl` — your observation log
- `~/.claude/adam/state.json` — session counters
- `~/.claude/adam/usage.json` — invocation tallies
-
-If you've locally edited any installed file (e.g. `agents/adam.md`), the installer writes the new version to `<file>.adam-new` and warns you instead of clobbering.
-
-After install: run `bash ~/.claude/adam/tests/run-tests.sh` to verify (expect `27 passed, 0 failed`), start a fresh Claude Code session, then run `/reflect`.
+- **v0.7.1** — ADAM now sees real tool failures. Claude Code sends failed tool calls to the `PostToolUseFailure` hook event, which ADAM never registered, so every `tool_error_loop` came from `ERROR_RE` matching successful output. `adam-observe.mjs` now handles `PostToolUseFailure` through the same detectors as `PostToolUse` (interrupts excluded), and `settings.json.example` registers it; re-run `install.sh` or add the entry by hand. Successful Read, Edit and Write responses are no longer fingerprinted: source files containing words such as `error` produced 151 false `tool_error_loop` entries across 9 sessions. Found by ADAM's own `/reflect`. 150 tests (up from 145).
+- **v0.7.0** — query-conditioned nudges and a lighter `/reflect` skill. A nudge can carry `cue.cwd`: `adam-nudge.mjs` replays it at SessionStart only in that codebase, and `adam-observe.mjs` now also surfaces it once mid-session on a matching `UserPromptSubmit` (opt out with `ADAM_NO_MIDSESSION_NUDGE=1`). New `adam-apply-nudge.mjs` builds the nudge message and cue from proposal frontmatter, so the analyst no longer hand-writes JSON. New `adam-skill-utility.mjs` ranks skills by good:bad outcome co-occurrence (Wilson lower bound, lift against baseline) and feeds a utility-lift rubric penalty; the analyst re-diagnoses unclear or top-severity clusters once per run. `adam-batch.mjs` gains an optional `--max-batches` / `--top-fraction` cap (off by default) and reports `capped`. The per-type apply steps move from `SKILL.md` to `apply-by-type.md`, so `/reflect` loads less context until it applies a proposal. The test harness now tests the tree it sits in, not `~/.claude`, so a repo checkout no longer tests an older install. 145 tests (up from 140).
+- **v0.6.4** — rollback now keeps its promise. `adam-rollback.mjs`'s docstring always claimed it "removes the ab-tracking entry (so it doesn't re-trigger)," but `executeRollback()` never did — so a rolled-back proposal kept flagging as `regressed` on every subsequent `/reflect`, triggering endless `not_found` rollback attempts. It now deletes the matching `ab-tracking.jsonl` row by `proposal_id` (preserving unrelated rows). Surfaced by running ADAM's own loop twice. 140 tests (up from 138).
+- **v0.6.3** — release-update notifier. `install.sh` now writes a `~/.claude/adam/.version` marker; `adam-nudge.mjs` (SessionStart) compares it against the latest GitHub release at most once/day (cached, 1.5 s network cap, best-effort — never blocks) and prints a **notify-only** one-line update prompt. Deliberately not auto-applied: re-running the installer resets ADAM's own `/reflect`-applied skill edits, so you choose when to update. Opt out with `ADAM_NO_UPDATE_CHECK=1`. See "Staying up to date". 138 tests (up from 134).
+- **v0.6.2** — two fixes surfaced by running ADAM's loop on a large real journal. **(1) A/B volume normalization** (`adam-ab-measure.mjs`): regressions are now measured on the signal's *share* of total activity (rate = count / window-total), not raw count — so a generally busier journal after an apply no longer masquerades as a regression. Falls back to raw delta when the signal is the only activity in the window (preserves prior behavior + tests); output adds `raw_delta_pct`, `pre_total`, `post_total`, `normalized` for transparency. **(2) Memory frontmatter schema** (`agents/adam.md`, `SKILL.md`): the drafting protocol now emits the live auto-memory shape — `name` = slug + a `metadata: {node_type, type, originSessionId}` block — instead of flat `type:`/`originSessionId:`, so auto-applied memories load and categorize correctly. 134 tests (up from 132).
+- **v0.6.1** — new `file_reread` signal (MOSS §1 harness self-modification, proposed and approved through ADAM's own `/reflect` loop). Consecutive Reads of the same file at different `offset`/`limit` escaped `retry_loop`'s arg-hash dedup and leaked into `tool_error_loop`; `file_reread` now catches them (same file ≥3× in the 10-event window, offset-agnostic, guarded against double-counting byte-identical reads). Fully wired: detection (`adam-observe.mjs`), 14-day window (`adam-window.mjs`), severity divisor 3 (`adam-score.mjs`), file-basename clustering (`adam-batch.mjs`), and the analyst rubric/spec. 132 tests (up from 126).
+- **v0.6.0** — review hardening. Struggle signals now emit `active_skills`, so `silent_drift`'s primary cluster key and the §5b skill-attribution sub-clustering (+1 rubric bonus) actually fire (both were silently dead). `proposal_fingerprint` is now deterministically computable via `adam-cooldown.mjs --compute` instead of asking the LLM analyst to hand-compute a djb2 hash; spec now mandates a *stable* cluster id so fingerprints reproduce across runs. `reinforcement` proposals are correctly excluded from A/B tracking (the spec previously contradicted itself). `adam-nudge.mjs` pending-upgrade check now mirrors the full install set (`adam-utils`/`adam-batch`/`adam-rollback` were missing). Doc/test-count drift corrected. 126 tests (up from 114).
+- **v0.5.0** — MOSS-grounded self-evolution (arXiv 2605.22794). Transcript capture: `context_window` field on struggle signals captures 8 surrounding events for evidence-based diagnosis. Two-stage analysis pipeline: diagnose+plan → inter-stage validation → implement (§3.3). Evidence batching via `adam-batch.mjs`: pre-clusters journal into coherent failure batches (§3.1). Pre-apply verification: 4-check deterministic gate before auto-apply (§3.4). Auto-rollback via `adam-rollback.mjs`: reverts regressed proposals detected by A/B measurement, creates regression nudges (§3.5). Harness self-modification: new `harness_edit` proposal type lets ADAM propose edits to its own scripts with test-suite-gated apply (§1 Table 1). Keypoint matrix: 5 capability dimensions scored per batch for structured evaluation (§4.2). 114 tests (up from 94).
+- **v0.4.0** — expanded struggle detection: `silent_drift` (5 consecutive read-only tools), `error_after_recovery` (same error fingerprint returns after clean recovery); severity-sum scoring with per-type divisors; extended `STRUGGLE_TYPES` set. 94 tests (up from 87).
+- **v0.3.3** — analyst observability, A/B measurement, journal hygiene. ISO-week journal rotation replaces 5MB size-based (fixes silent cluster-straddling under-count); per-signal sliding windows via `adam-window.mjs`; error fingerprint normalisation; correction corpus expanded + weak-token co-occurrence requirement (kills the `"actually, I think..."` false positive); mandatory clustering trace + `adam-explain.mjs`; new `nudge` and `reinforcement` proposal types; per-(skill, fingerprint) cooldown via `adam-cooldown.mjs`; `task_completed` scoring (dampener + reinforcement); A/B effectiveness measurement; upgrade UX overhaul (`adam-upgrade.mjs --list/--diff/--accept`); shared `adam-utils.mjs`. 87 tests (up from 30).
+- **v0.3.2** — `task_completed` signal: post-task skill capture for downstream reinforcement scoring (consumed in v0.3.3).
+- **v0.3.1** — code review pass: bug fixes (`errorFingerprint` no longer false-positives on `is_error: false`, archive script handles same-millisecond duplicates correctly, `tool_window` clears on session change, nudge filters proposal filenames by pattern), prose conciseness cuts, hardened `install.sh` with curl one-liner + settings.json merge, `adam-uninstall.sh`, isolated test harness.
+- **v0.3.0** — causal diagnosis: every proposal carries a `# Diagnosis` block (Trigger/Action/Mismatch/Outcome with verbatim transcript quote), plus `contradiction_flag` heuristic that vetoes auto-apply on obviously-conflicting `skill_edit` additions.
+- **v0.2.1** — win signals (`correction_free_streak`, `clean_recovery`) feed `skill_edit` auto-apply under a strict gate (≤ 30 LOC, ≤ 2× byte cap, 7d cooldown, 30d blacklist).
+- **v0.2.0** — actioned-entry archival via `adam-archive.mjs`; `cursor` field deprecated.

 ## Requirements

- Claude Code v2.1.0+ (for auto skill hot-reload; older versions need session restart after `skill_new` proposals are applied)
- Node.js 18+ (for the hook; tested on v22)
- Bash 4+, `git`, `curl`, `jq` (for installer + test harness)
+- **Claude Code v2.1.0+** — for auto skill hot-reload (older versions need a session restart after `skill_new` proposals).
+- **Node.js 18+** — tested on v22, used by the hook + helper scripts. Zero npm dependencies.
+- **Bash 4+**, `git`, `curl`, `jq` — for the installer + test harness.

 ### Platform support

-Tested on **macOS** (Darwin / BSD coreutils) and **Linux** (Alpine, glibc + musl). The install / uninstall / test scripts are written to be portable: `stat` uses BSD `-f` with GNU `-c` fallback, `mktemp -d -t prefix.XXXXXX` works on both, no GNU-only flags. CI smoke verified `27 passed, 0 failed` under `alpine:latest`.
-
-## Confidence rubric
-
-```
-Sum:
-+2  Signal repeated ≥3× across ≥2 sessions
-+2  Struggle signal appearing ≥1× within a single session (does not stack)
-+2  Transcript contains positive endorsement near related action
-+1  Multi-axis cluster (≥2 distinct struggle types in same session)
-1  Type-bias penalty (≥3 rejections, applied:rejected <1:2)
-+1  Blast radius low (memory or new isolated skill)
- 0  Blast radius medium (new agent, new hook, edit existing skill)
-1  Blast radius high (CLAUDE.md, settings hooks, edit agent, deletion)
-+1  Surgical (one file, ≤50 LOC for non-skill_new; ≤80 LOC for skill_new)
-3  Touches deny-list (settings.json hooks/permissions, CLAUDE.md, deletions)
-
-auto_apply_eligible requires ALL:
-  confidence ≥ 4
-  blast_radius == low
-  type ∈ {memory, skill_new, skill_edit}     # skill_edit also passes the win-driven gate
-  cross_session_evidence == true (single-session-only proposals always queue)
-
-skill_edit additionally requires (v0.2.1+):
-  win-signal evidence (correction_free_streak / clean_recovery cites target skill)
-  diff is append-only, ≤30 LOC, resulting size ≤2× original
-  no auto-edit to same target in past 7 days (cooldown)
-  no rejection-blacklist on target in past 30 days
-  contradiction heuristic does not flag (v0.3.0+)
-  # Diagnosis section present + structurally valid (v0.3.0+)
-```
-
-## Lifecycle: how proposals become permanent
-
-Every proposal records the journal entry timestamps that fed its cluster (`source_entries` in frontmatter). When you apply or reject a proposal, the skill calls `adam/scripts/adam-archive.mjs` which moves matching entries from `journal.jsonl` to `journal/actioned-<id>.jsonl`. Effects:
-
- The `journal.jsonl` stays bounded by **active** observations only.
- The next `/reflect` reads applied/ + rejected/ frontmatter, builds an excluded-timestamps set, and skips any leftover journal entries that were already actioned.
- Rule changes (e.g. lowering a threshold) immediately re-evaluate the remaining active observations — no manual cursor rewind needed.
-
-## What it will not do
-
- No background LLM spend. The analyst runs only when you invoke `/reflect`.
- No retroactive transcript mining beyond the journal cursor.
- No hard `rm` of any artifact. Deletions are soft (`mv` to `trash/<ts>/`).
- No autonomous edits to `CLAUDE.md`, agents, hooks, or `settings.json` — these always queue for review regardless of confidence.
- No proposal that matches a previously-rejected idea (≥2 token overlap with rejection's `# Why`).
- No invented trigger phrases for new skills — every trigger comes from observed user input.
+Tested on **macOS** (Darwin / BSD coreutils) and **Linux** (Alpine, glibc + musl). The install / uninstall / test scripts are written to be portable: `stat` uses BSD `-f` with GNU `-c` fallback, `mktemp -d -t prefix.XXXXXX` works on both, no GNU-only flags. CI smoke verified under `alpine:latest`.

 ## Uninstall

@@ -173,6 +321,20 @@ rm -rf ~/.claude/skills/adam-self-improvement

 Then remove the four `adam-*` hook entries from `~/.claude/settings.json`.

+## Contributing
+
+Issues and PRs welcome — especially additional signal types, transcript-aware diagnosis improvements, and platform fixes. Run the test suite before opening a PR:
+
+```sh
+bash ~/.claude/adam/tests/run-tests.sh
+```
+
 ## License

 [MIT](LICENSE) — © 2026 Lukasz Raczylo
+
+---
+
+<div align="center">
+<sub>Named after my son Adam, who taught me that observation is the start of every interesting thing.</sub>
+</div>
@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+// adam-ab-measure.mjs — A/B effectiveness measurement on auto-applied edits.
+//
+// Reads ~/.claude/adam/ab-tracking.jsonl (one line per auto-apply event,
+// written by adam-self-improvement/SKILL.md), then for each entry old enough
+// (>= --min-age-days; default 7) compares the originating signal in the 7-day
+// window BEFORE applied_at against the 7-day window AFTER applied_at across the
+// full journal corpus (active + rotated). Surfaces regressions so /reflect
+// can flag proposals that made things worse.
+//
+// Volume normalization: when the windows contain other (non-originating)
+// activity, the delta is computed on the signal's SHARE of total activity
+// (rate = count / total), not its raw count — so a generally busier journal
+// after apply does not masquerade as a regression. When the signal is the only
+// activity in the windows, it falls back to the raw-count delta. Output carries
+// both `delta_pct` (drives status) and `raw_delta_pct` + `normalized` for
+// transparency.
+//
+// CLI:
+//   adam-ab-measure.mjs [--home <path>] [--format json|table] [--min-age-days N]
+//
+// Output (default `table`): aligned columns sorted regressed-first.
+// Output (`json`): array of deltas.
+// Empty / missing tracking file → empty output, exit 0.
+// Exit 1 only on I/O failure.
+
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readJsonlSafe, listJsonlFiles } from "./adam-utils.mjs";
+
+const DAY_MS = 86400000;
+export const DEFAULT_PRE_WINDOW_DAYS = 7;
+export const DEFAULT_MIN_AGE_DAYS = 7;
+
+const REGRESSED_PCT = 25;
+const IMPROVED_PCT = -25;
+
+function parseArgs(argv) {
+  const args = { home: null, format: "table", minAgeDays: DEFAULT_MIN_AGE_DAYS, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--format" && i + 1 < argv.length) args.format = argv[++i];
+    else if (a === "--min-age-days" && i + 1 < argv.length) {
+      const n = Number(argv[++i]);
+      if (!Number.isNaN(n) && n >= 0) args.minAgeDays = n;
+    }
+    else if (a === "--help" || a === "-h") args.help = true;
+  }
+  return args;
+}
+
+function loadJournalAll(claudeHome) {
+  const adamRoot = join(claudeHome, "adam");
+  const sources = [join(adamRoot, "journal.jsonl"), ...listJsonlFiles(join(adamRoot, "journal"))];
+  const all = [];
+  for (const p of sources) for (const e of readJsonlSafe(p)) all.push(e);
+  return all;
+}
+
+function tsMs(e) {
+  if (!e || typeof e.ts !== "string") return NaN;
+  return Date.parse(e.ts);
+}
+
+// computeDeltas: pure function — entries = ab-tracking objects, journal = list
+// of journal entries (any source). opts.now is unix ms; opts.minAgeDays is the
+// floor for non-pending.
+export function computeDeltas(entries, journal, opts = {}) {
+  const now = typeof opts.now === "number" ? opts.now : Date.now();
+  const minAgeDays = typeof opts.minAgeDays === "number" ? opts.minAgeDays : DEFAULT_MIN_AGE_DAYS;
+  const out = [];
+  for (const e of entries || []) {
+    if (!e || typeof e !== "object") continue;
+    const appliedAt = Number(e.applied_at);
+    if (!appliedAt || Number.isNaN(appliedAt)) continue;
+    const ageDays = (now - appliedAt) / DAY_MS;
+    // Symmetric window: same span applied to pre AND post sides. JSONL schema
+    // field stays `pre_window_days` for backward compat with existing
+    // ab-tracking.jsonl entries — local name reflects symmetry.
+    const windowDays = typeof e.pre_window_days === "number" ? e.pre_window_days : DEFAULT_PRE_WINDOW_DAYS;
+    const signals = Array.isArray(e.originating_signals)
+      ? e.originating_signals.map((s) => (s && typeof s === "object" ? s.type : null)).filter(Boolean)
+      : [];
+    const sigSet = new Set(signals);
+
+    const base = {
+      proposal_id: e.proposal_id || "",
+      proposal_type: e.proposal_type || "",
+      target_skill: e.target_skill || "",
+      applied_at: appliedAt,
+      applied_at_iso: new Date(appliedAt).toISOString(),
+      signal_types: [...sigSet],
+    };
+
+    if (ageDays < minAgeDays) {
+      out.push({ ...base, pre_count: null, post_count: null, delta_pct: null, status: "pending" });
+      continue;
+    }
+
+    const preStart = appliedAt - windowDays * DAY_MS;
+    const postEnd = appliedAt + windowDays * DAY_MS;
+    // preCount/postCount = originating-signal occurrences; preTotal/postTotal =
+    // ALL journal entries in the window (the activity denominator).
+    let preCount = 0;
+    let postCount = 0;
+    let preTotal = 0;
+    let postTotal = 0;
+    for (const je of journal || []) {
+      if (!je || typeof je !== "object") continue;
+      const t = tsMs(je);
+      if (Number.isNaN(t)) continue;
+      const inPre = t >= preStart && t < appliedAt;
+      const inPost = t >= appliedAt && t < postEnd;
+      if (!inPre && !inPost) continue;
+      if (inPre) preTotal++; else postTotal++;
+      if (!sigSet.has(je.type)) continue;
+      if (inPre) preCount++; else postCount++;
+    }
+
+    let status;
+    let deltaPct;
+    let rawDeltaPct = null;
+    let normalized = false;
+    if (preCount === 0) {
+      status = "no_baseline";
+      deltaPct = null;
+    } else {
+      rawDeltaPct = Math.round(((postCount - preCount) / preCount) * 10000) / 100;
+      // Volume normalization: when the windows contain non-originating activity,
+      // compare the signal's SHARE of activity (rate), not its absolute count —
+      // otherwise a generally busier post-window masquerades as a regression.
+      // No background (signal IS the only activity) → fall back to raw delta,
+      // preserving prior behavior.
+      const hasBackground = (preTotal - preCount) + (postTotal - postCount) > 0;
+      if (hasBackground && postTotal > 0) {
+        const preRate = preCount / preTotal;   // preTotal >= preCount > 0
+        const postRate = postCount / postTotal;
+        deltaPct = ((postRate - preRate) / preRate) * 100;
+        normalized = true;
+      } else {
+        deltaPct = ((postCount - preCount) / preCount) * 100;
+      }
+      // Round to 2 dp for stable comparison + presentation.
+      deltaPct = Math.round(deltaPct * 100) / 100;
+      if (deltaPct <= IMPROVED_PCT) status = "improved";
+      else if (deltaPct >= REGRESSED_PCT) status = "regressed";
+      else status = "neutral";
+    }
+    out.push({
+      ...base,
+      pre_count: preCount, post_count: postCount,
+      pre_total: preTotal, post_total: postTotal,
+      raw_delta_pct: rawDeltaPct, normalized,
+      delta_pct: deltaPct, status,
+    });
+  }
+  return out;
+}
+
+const STATUS_ORDER = { regressed: 0, neutral: 1, no_baseline: 2, improved: 3, pending: 4 };
+
+function sortForTable(deltas) {
+  return [...deltas].sort((a, b) => {
+    const sa = STATUS_ORDER[a.status] ?? 99;
+    const sb = STATUS_ORDER[b.status] ?? 99;
+    if (sa !== sb) return sa - sb;
+    return a.applied_at - b.applied_at;
+  });
+}
+
+function padRight(s, n) { s = String(s); return s.length >= n ? s : s + " ".repeat(n - s.length); }
+
+export function formatTable(deltas) {
+  if (!deltas || !deltas.length) return "";
+  const rows = sortForTable(deltas);
+  const headers = ["proposal_id", "target", "type", "applied_at(iso)", "pre/post", "delta%", "status"];
+  const data = rows.map((d) => [
+    d.proposal_id || "-",
+    d.target_skill || "-",
+    d.proposal_type || "-",
+    d.applied_at_iso || "-",
+    d.pre_count == null ? "-" : `${d.pre_count}/${d.post_count}`,
+    d.delta_pct == null ? "-" : `${d.delta_pct.toFixed(2)}`,
+    d.status || "-",
+  ]);
+  const widths = headers.map((h, i) => Math.max(h.length, ...data.map((r) => String(r[i]).length)));
+  const lines = [];
+  lines.push(headers.map((h, i) => padRight(h, widths[i])).join(" | "));
+  lines.push(widths.map((w) => "-".repeat(w)).join("-+-"));
+  for (const r of data) lines.push(r.map((c, i) => padRight(c, widths[i])).join(" | "));
+  return lines.join("\n");
+}
+
+export function formatJson(deltas) {
+  return JSON.stringify(deltas || []);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write("usage: adam-ab-measure.mjs [--home <path>] [--format json|table] [--min-age-days N]\n");
+    process.exit(0);
+  }
+  const claudeHome = args.home || join(homedir(), ".claude");
+  const trackingPath = join(claudeHome, "adam", "ab-tracking.jsonl");
+  try {
+    const entries = readJsonlSafe(trackingPath);
+    if (!entries.length) {
+      if (args.format === "json") process.stdout.write("[]\n");
+      // table mode prints nothing on empty input — exit 0.
+      process.exit(0);
+    }
+    const journal = loadJournalAll(claudeHome);
+    const deltas = computeDeltas(entries, journal, { minAgeDays: args.minAgeDays });
+    const out = args.format === "json" ? formatJson(deltas) : formatTable(deltas);
+    if (out) process.stdout.write(out + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-ab-measure error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// adam-apply-nudge.mjs — apply-path for `nudge` proposals.
+//
+// Reads a nudge proposal markdown file, validates the apply gate
+// (type == "nudge" AND source_session present), and on success appends one
+// entry to ~/.claude/adam/active-nudges.json. The message and the `cue` are
+// built DETERMINISTICALLY in code from the proposal frontmatter — the analyst
+// does not hand-author the JSON, so the cue (ReContext-style query-conditioning)
+// is always populated when a cwd is known, not left to chance.
+//
+// Frontmatter consumed: type, source_session, cwd (optional — becomes cue.cwd),
+// dead_end_count (optional — shapes the message), max_displays (optional, ≥1).
+//
+// CLI: adam-apply-nudge.mjs <proposal-path> [--home <path>]
+// Output: JSON one-liner on stdout: {"status":"applied"|"gated", "reason"|"path"}
+// Exit: 0 on apply, 0 on gated, 1 on I/O or parse error.
+//
+// SKILL.md invokes this in the nudge auto-apply path. No code/memory/skill edits.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { parseFrontmatter } from "./adam-utils.mjs";
+
+export { parseFrontmatter };
+
+const SEVEN_DAYS_MS = 7 * 86400000;
+const DEFAULT_MAX_DISPLAYS = 3;
+
+function parseArgs(argv) {
+  const args = { home: null, path: null, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--help" || a === "-h") args.help = true;
+    else if (!args.path && !a.startsWith("--")) args.path = a;
+  }
+  return args;
+}
+
+export function checkGate(fm) {
+  if ((fm.type || "") !== "nudge") {
+    return { ok: false, reason: `type != nudge (got: ${fm.type || "<none>"})` };
+  }
+  if (!fm.source_session) {
+    return { ok: false, reason: "source_session missing in frontmatter" };
+  }
+  return { ok: true };
+}
+
+export function buildEntry(fm, now = Date.now()) {
+  const cwd = fm.cwd ? String(fm.cwd) : "";
+  const base = cwd ? cwd.split("/").filter(Boolean).pop() : "";
+  const count = Number(fm.dead_end_count) > 0 ? Number(fm.dead_end_count) : 3;
+  const maxDisplays = Number(fm.max_displays) > 0 ? Number(fm.max_displays) : DEFAULT_MAX_DISPLAYS;
+  const message = `adam: a previous session hit ${count} dead-ends${base ? ` in ${base}` : ""} — consider a checkpoint before continuing.`;
+  const entry = {
+    kind: "dead_end_reminder",
+    message,
+    created_at: now,
+    expires_at_ts: now + SEVEN_DAYS_MS,
+    max_displays: maxDisplays,
+    displays_used: 0,
+    source_session: String(fm.source_session || ""),
+  };
+  // The cue is what makes replay query-conditioned: bind the reminder to the
+  // project it came from so it only surfaces there (SessionStart + mid-session).
+  if (cwd) entry.cue = { cwd };
+  return entry;
+}
+
+export function appendNudge(nudgesPath, entry) {
+  let arr = [];
+  if (existsSync(nudgesPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(nudgesPath, "utf8"));
+      if (Array.isArray(parsed)) arr = parsed;
+    } catch { arr = []; }
+  }
+  arr.push(entry);
+  const dir = dirname(nudgesPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(nudgesPath, JSON.stringify(arr, null, 2));
+  return arr.length;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help || !args.path) {
+    process.stdout.write("usage: adam-apply-nudge.mjs <proposal-path> [--home <path>]\n");
+    process.exit(args.help ? 0 : 1);
+  }
+  const claudeHome = args.home || join(homedir(), ".claude");
+  const nudgesPath = join(claudeHome, "adam", "active-nudges.json");
+  try {
+    const content = readFileSync(args.path, "utf8");
+    const fm = parseFrontmatter(content);
+    const gate = checkGate(fm);
+    if (!gate.ok) {
+      process.stdout.write(JSON.stringify({ status: "gated", reason: gate.reason }) + "\n");
+      process.exit(0);
+    }
+    const entry = buildEntry(fm);
+    const count = appendNudge(nudgesPath, entry);
+    process.stdout.write(JSON.stringify({ status: "applied", path: nudgesPath, total: count, cue: entry.cue || null }) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-apply-nudge error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// adam-apply-reinforcement.mjs — apply-path for `reinforcement` proposals.
+//
+// Reads a proposal markdown file, validates the apply gate
+// (confidence >= 4 AND blast_radius == "low" AND type == "reinforcement"),
+// and on success appends one JSON line to ~/.claude/adam/reinforcements.jsonl
+// of shape `{ts, skill_slug, count, source_session}`.
+//
+// CLI: adam-apply-reinforcement.mjs <proposal-path> [--home <path>]
+// Output: JSON one-liner on stdout: {"status":"applied"|"gated", "reason":"..."}
+// Exit: 0 on apply, 0 on gated, 1 on I/O or parse error.
+//
+// SKILL.md invokes this in the auto-apply path when the proposal type is
+// `reinforcement`. No code/memory/skill modifications.
+
+import { readFileSync, appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { parseFrontmatter } from "./adam-utils.mjs";
+
+// Re-exported for backward compat — callers historically imported it from here.
+export { parseFrontmatter };
+
+function parseArgs(argv) {
+  const args = { home: null, path: null, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--help" || a === "-h") args.help = true;
+    else if (!args.path && !a.startsWith("--")) args.path = a;
+  }
+  return args;
+}
+
+export function checkGate(fm) {
+  if ((fm.type || "") !== "reinforcement") {
+    return { ok: false, reason: `type != reinforcement (got: ${fm.type || "<none>"})` };
+  }
+  const conf = Number(fm.confidence);
+  if (Number.isNaN(conf) || conf < 4) {
+    return { ok: false, reason: `confidence < 4 (got: ${fm.confidence ?? "<none>"})` };
+  }
+  if ((fm.blast_radius || "").toLowerCase() !== "low") {
+    return { ok: false, reason: `blast_radius != low (got: ${fm.blast_radius || "<none>"})` };
+  }
+  if (!fm.skill_slug) {
+    return { ok: false, reason: "skill_slug missing in frontmatter" };
+  }
+  return { ok: true };
+}
+
+export function buildEntry(fm, now = Date.now()) {
+  return {
+    ts: now,
+    skill_slug: String(fm.skill_slug),
+    count: Number(fm.count) || 0,
+    source_session: fm.source_session || "",
+  };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help || !args.path) {
+    process.stdout.write("usage: adam-apply-reinforcement.mjs <proposal-path> [--home <path>]\n");
+    process.exit(args.help ? 0 : 1);
+  }
+  const claudeHome = args.home || join(homedir(), ".claude");
+  const outPath = join(claudeHome, "adam", "reinforcements.jsonl");
+  try {
+    const content = readFileSync(args.path, "utf8");
+    const fm = parseFrontmatter(content);
+    const gate = checkGate(fm);
+    if (!gate.ok) {
+      process.stdout.write(JSON.stringify({ status: "gated", reason: gate.reason }) + "\n");
+      process.exit(0);
+    }
+    const entry = buildEntry(fm);
+    const dir = dirname(outPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    appendFileSync(outPath, JSON.stringify(entry) + "\n");
+    process.stdout.write(JSON.stringify({ status: "applied", path: outPath }) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-apply-reinforcement error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -8,49 +8,12 @@
 import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { parseFrontmatter } from "./adam-utils.mjs";

 const ROOT = join(homedir(), ".claude", "adam");
 const JOURNAL = join(ROOT, "journal.jsonl");
 const JOURNAL_DIR = join(ROOT, "journal");

-function parseFrontmatter(content) {
-  const m = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!m) return {};
-  const fm = {};
-  const lines = m[1].split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    const idx = line.indexOf(":");
-    if (idx === -1) { i++; continue; }
-    const key = line.slice(0, idx).trim();
-    const value = line.slice(idx + 1).trim();
-    if (key === "source_entries") {
-      const arr = [];
-      if (value.startsWith("[") && value.endsWith("]")) {
-        const inner = value.slice(1, -1)
-          .split(",")
-          .map(s => s.trim().replace(/^['"]|['"]$/g, ""));
-        arr.push(...inner.filter(Boolean));
-        fm[key] = arr;
-        i++;
-        continue;
-      }
-      i++;
-      while (i < lines.length && /^\s*-\s+/.test(lines[i])) {
-        const item = lines[i].replace(/^\s*-\s+/, "").trim().replace(/^['"]|['"]$/g, "");
-        if (item) arr.push(item);
-        i++;
-      }
-      fm[key] = arr;
-      continue;
-    }
-    fm[key] = value;
-    i++;
-  }
-  return fm;
-}
-
 function main() {
  const proposalPath = process.argv[2];
  if (!proposalPath) {
@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+// adam-batch.mjs — pre-clusters windowed journal entries into coherent failure
+// batches before analyst dispatch. Implements MOSS §3.1: "anchored to an
+// automatically curated batch of production-failure evidence."
+//
+// Each batch groups entries by (signal_type, cluster_key) where cluster_key
+// follows the same clustering rules as agents/adam.md ## Signal types / ## Process step 4:
+//   correction     → tokenized phrase (cross-cwd)
+//   retry_loop     → tool
+//   weak_agent     → subagent_type
+//   tool_error_loop→ fp
+//   dead_end       → session
+//   edit_churn     → file basename
+//   file_reread    → file basename
+//   build_loop     → session
+//   subagent_dispatch_pattern → subagent_type
+//   silent_drift   → active_skills[0]
+//   error_after_recovery → (recovered_from, original_fp)
+//   correction_free_streak → active_skills[0]
+//   clean_recovery → (recovered_from, active_skills[0])
+//   task_completed → sorted tool_kinds tuple
+//
+// CLI:
+//   adam-batch.mjs [--input <jsonl-path>] [--min-entries N] [--min-sessions N]
+//
+// Output: JSON object with `batches` array and `unbatched` count.
+
+import { readFileSync } from "node:fs";
+import { readJsonlSafe } from "./adam-utils.mjs";
+
+const DEFAULT_MIN_ENTRIES = 1;
+const DEFAULT_MIN_SESSIONS = 1;
+
+const CORRECTION_STOPWORDS = new Set([
+  "the", "a", "an", "and", "or", "but", "of", "to", "for", "in", "on",
+  "with", "use", "when", "where", "what", "why", "how", "this", "that",
+  "these", "those", "is", "are", "was", "were", "be", "been", "being",
+  "do", "does", "did", "doing", "has", "have", "had", "your", "you",
+  "i", "it", "as", "at", "by", "from", "not", "no",
+]);
+
+function tokenizePhrase(phrase) {
+  if (!phrase || typeof phrase !== "string") return "";
+  return phrase.toLowerCase()
+    .split(/\s+/)
+    .map(t => t.replace(/^[^\w']+|[^\w']+$/g, ""))
+    .filter(t => t && !CORRECTION_STOPWORDS.has(t))
+    .sort()
+    .join("|");
+}
+
+function clusterKey(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const t = entry.type;
+  switch (t) {
+    case "correction":
+      return tokenizePhrase(entry.phrase) || "unknown";
+    case "retry_loop":
+      return entry.tool || "unknown";
+    case "weak_agent":
+    case "subagent_dispatch_pattern":
+      return entry.subagent_type || "unknown";
+    case "tool_error_loop":
+      return entry.fp || "unknown";
+    case "dead_end":
+    case "build_loop":
+      return entry.session || "unknown";
+    case "edit_churn":
+    case "file_reread":
+      return entry.file ? entry.file.split("/").pop() : "unknown";
+    case "silent_drift":
+    case "correction_free_streak":
+      return Array.isArray(entry.active_skills) ? (entry.active_skills[0] || "") : "";
+    case "error_after_recovery":
+      return `${entry.recovered_from || "?"}:${entry.original_fp || "?"}`;
+    case "clean_recovery":
+      return `${entry.recovered_from || "?"}:${Array.isArray(entry.active_skills) ? (entry.active_skills[0] || "") : ""}`;
+    case "task_completed":
+      return Array.isArray(entry.tool_kinds) ? entry.tool_kinds.slice().sort().join(",") : "unknown";
+    default:
+      return entry.session || "unknown";
+  }
+}
+
+function parseArgs(argv) {
+  const args = { input: null, minEntries: DEFAULT_MIN_ENTRIES, minSessions: DEFAULT_MIN_SESSIONS, maxBatches: null, topFraction: null, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--input" && i + 1 < argv.length) args.input = argv[++i];
+    else if (a === "--min-entries" && i + 1 < argv.length) {
+      const n = Number(argv[++i]);
+      if (!Number.isNaN(n) && n > 0) args.minEntries = n;
+    }
+    else if (a === "--min-sessions" && i + 1 < argv.length) {
+      const n = Number(argv[++i]);
+      if (!Number.isNaN(n) && n > 0) args.minSessions = n;
+    }
+    else if (a === "--max-batches" && i + 1 < argv.length) {
+      const n = Number(argv[++i]);
+      if (!Number.isNaN(n) && n > 0) args.maxBatches = n;
+    }
+    else if (a === "--top-fraction" && i + 1 < argv.length) {
+      const n = Number(argv[++i]);
+      if (!Number.isNaN(n) && n > 0 && n < 1) args.topFraction = n;
+    }
+    else if (a === "--help" || a === "-h") args.help = true;
+  }
+  return args;
+}
+
+export function buildBatches(entries, opts = {}) {
+  const minEntries = opts.minEntries || DEFAULT_MIN_ENTRIES;
+  const minSessions = opts.minSessions || DEFAULT_MIN_SESSIONS;
+  const map = new Map();
+
+  for (const e of entries || []) {
+    if (!e || typeof e !== "object" || !e.type) continue;
+    const key = `${e.type}::${clusterKey(e)}`;
+    if (!map.has(key)) {
+      map.set(key, {
+        batch_id: null,
+        signal_type: e.type,
+        cluster_key: clusterKey(e),
+        entries: [],
+        sessions: new Set(),
+        cwds: new Set(),
+      });
+    }
+    const batch = map.get(key);
+    batch.entries.push(e);
+    if (e.session) batch.sessions.add(e.session);
+    if (e.cwd) batch.cwds.add(e.cwd);
+  }
+
+  const batches = [];
+  let unbatched = 0;
+  let id = 1;
+  for (const [, batch] of map) {
+    if (batch.entries.length < minEntries || batch.sessions.size < minSessions) {
+      unbatched += batch.entries.length;
+      continue;
+    }
+    batch.batch_id = `b${id++}`;
+    batches.push({
+      batch_id: batch.batch_id,
+      signal_type: batch.signal_type,
+      cluster_key: batch.cluster_key,
+      entry_count: batch.entries.length,
+      session_count: batch.sessions.size,
+      cwd_count: batch.cwds.size,
+      has_context_window: batch.entries.some(e => Array.isArray(e.context_window) && e.context_window.length > 0),
+      entries: batch.entries,
+    });
+  }
+
+  batches.sort((a, b) => b.entry_count - a.entry_count);
+
+  // Optional output cap (default: no cap — the full ranked list is returned).
+  // ReContext P2: relevance is concentrated, so surfacing only the top head keeps
+  // reviewer attention on the highest-value clusters. `topFraction` keeps the top
+  // ceil(f * N) after ranking (so the survivor count tracks corpus volume);
+  // `maxBatches` is a hard ceiling. The more restrictive of the two applies.
+  // Never silent: `capped` reports how many ranked batches were dropped by the cap.
+  let keepN = batches.length;
+  const frac = Number(opts.topFraction);
+  if (frac > 0 && frac < 1) keepN = Math.min(keepN, Math.max(1, Math.ceil(frac * batches.length)));
+  const maxB = Number(opts.maxBatches);
+  if (Number.isFinite(maxB) && maxB > 0) keepN = Math.min(keepN, maxB);
+  const capped = batches.length - keepN;
+  const kept = capped > 0 ? batches.slice(0, keepN) : batches;
+
+  return { batches: kept, unbatched, capped, total: (entries || []).length };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write("usage: adam-batch.mjs [--input <jsonl-path>] [--min-entries N] [--min-sessions N] [--max-batches N] [--top-fraction F]\n");
+    process.exit(0);
+  }
+  try {
+    let entries;
+    if (args.input) {
+      entries = readJsonlSafe(args.input);
+    } else if (!process.stdin.isTTY) {
+      const buf = readFileSync(0, "utf8");
+      entries = [];
+      for (const line of buf.split("\n")) {
+        if (!line) continue;
+        try { entries.push(JSON.parse(line)); } catch { /* skip */ }
+      }
+    } else {
+      process.stderr.write("adam-batch: no input (use --input or pipe)\n");
+      process.exit(1);
+    }
+    const result = buildBatches(entries, { minEntries: args.minEntries, minSessions: args.minSessions, maxBatches: args.maxBatches, topFraction: args.topFraction });
+    process.stdout.write(JSON.stringify(result) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-batch error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export { clusterKey, tokenizePhrase };
@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+// adam-cooldown.mjs — per-(skill, proposal_fingerprint) cooldown / blacklist
+// gate. Replaces the previous coarse per-skill cooldown.
+//
+// CLI:
+//   adam-cooldown.mjs --skill <slug> --fingerprint <hash> [--home <path>]
+//   adam-cooldown.mjs --compute --skill <slug> --cluster <id> [--diff-file <path>]
+//     → prints {"fingerprint":"<djb2_base36>"}; diff body read from --diff-file
+//       or stdin. This is how proposal_fingerprint is populated (the analyst
+//       runs it via Bash after drafting a proposal).
+//
+// Output (gate mode): JSON one-liner with shape
+//   { "status": "cool"|"cooldown"|"blacklisted",
+//     "reason": "<human-readable reason>",
+//     "blocked_by": { "file": "<basename>", "days_remaining": <int> } | null }
+//
+// Rules:
+//   - applied/*.md with target_skill == <skill> AND
+//     (proposal_fingerprint == <fingerprint> OR missing/legacy)
+//     within 7 days of `applied_at` → "cooldown"
+//   - rejected/*.md with same skill match AND
+//     auto_apply_blacklist: true within 30 days of applied_at → "blacklisted"
+//   - else "cool"
+//
+// Backward compat: proposals without `proposal_fingerprint` field are treated
+// as fingerprint == "legacy" so historical applied/rejected records still
+// produce coarse-grained gating until they age out of their windows.
+
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { parseFrontmatter } from "./adam-utils.mjs";
+
+export const COOLDOWN_DAYS = 7;
+export const BLACKLIST_DAYS = 30;
+const DAY_MS = 86400000;
+export const LEGACY_FINGERPRINT = "legacy";
+
+function parseArgs(argv) {
+  const args = { home: null, skill: null, fingerprint: null, compute: false, cluster: null, diffFile: null, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--skill" && i + 1 < argv.length) args.skill = argv[++i];
+    else if (a === "--fingerprint" && i + 1 < argv.length) args.fingerprint = argv[++i];
+    else if (a === "--cluster" && i + 1 < argv.length) args.cluster = argv[++i];
+    else if (a === "--diff-file" && i + 1 < argv.length) args.diffFile = argv[++i];
+    else if (a === "--compute") args.compute = true;
+    else if (a === "--help" || a === "-h") args.help = true;
+  }
+  return args;
+}
+
+// Pull applied_at as epoch ms. Accept ms-number, ISO string, or fall back to
+// the file's mtime so we never crash on legacy records.
+function frontmatterTimestampMs(fm, filePath) {
+  const raw = fm.applied_at;
+  if (raw) {
+    const asNum = Number(raw);
+    if (!Number.isNaN(asNum) && asNum > 0) return asNum;
+    const asIso = Date.parse(raw);
+    if (!Number.isNaN(asIso)) return asIso;
+  }
+  try { return statSync(filePath).mtimeMs; } catch { return 0; }
+}
+
+function fingerprintMatches(recordFp, queryFp) {
+  // Missing / empty field on legacy records → coarse fallback: any fingerprint
+  // query matches (so the historical applied/rejected record still gates).
+  if (!recordFp || recordFp === LEGACY_FINGERPRINT) return true;
+  return recordFp === queryFp;
+}
+// Resolve a frontmatter record to its skill slug. Modern records use
+// `target_skill`; legacy v0.2.x records used `target` with a full path
+// (e.g. `skills/foo/SKILL.md`). Falls back through both before giving up.
+function resolveSkill(fm) {
+  if (fm.target_skill) return fm.target_skill;
+  if (fm.skill) return fm.skill;
+  if (fm.target) {
+    const base = fm.target.split("/").filter(Boolean);
+    // skills/<slug>/SKILL.md → <slug>; <slug>.md → <slug>; else last segment
+    if (base.length >= 2 && base[base.length - 1] === "SKILL.md") {
+      return base[base.length - 2];
+    }
+    return base[base.length - 1].replace(/\.md$/, "");
+  }
+  return "";
+}
+
+function scanDir(dir, predicate) {
+  if (!existsSync(dir)) return [];
+  let names;
+  try { names = readdirSync(dir); } catch { return []; }
+  const out = [];
+  for (const name of names) {
+    if (!name.endsWith(".md")) continue;
+    const p = join(dir, name);
+    let content;
+    try { content = readFileSync(p, "utf8"); } catch { continue; }
+    const fm = parseFrontmatter(content);
+    const hit = predicate(fm, p, name);
+    if (hit) out.push(hit);
+  }
+  return out;
+}
+
+export function checkCooldown(home, skill, fingerprint, now = Date.now()) {
+  const adamRoot = join(home, "adam");
+  const appliedDir = join(adamRoot, "applied");
+  const rejectedDir = join(adamRoot, "rejected");
+
+  // Applied → cooldown
+  const appliedHits = scanDir(appliedDir, (fm, p, name) => {
+    if (resolveSkill(fm) !== skill) return null;
+    if (!fingerprintMatches(fm.proposal_fingerprint, fingerprint)) return null;
+    const tsMs = frontmatterTimestampMs(fm, p);
+    if (!tsMs) return null;
+    const ageDays = (now - tsMs) / DAY_MS;
+    if (ageDays > COOLDOWN_DAYS) return null;
+    return { name, daysRemaining: Math.max(0, Math.ceil(COOLDOWN_DAYS - ageDays)) };
+  });
+
+  // Rejected → blacklisted (requires auto_apply_blacklist: true)
+  const blacklistHits = scanDir(rejectedDir, (fm, p, name) => {
+    if (resolveSkill(fm) !== skill) return null;
+    if (!fingerprintMatches(fm.proposal_fingerprint, fingerprint)) return null;
+    const flag = (fm.auto_apply_blacklist || "").toLowerCase();
+    if (flag !== "true") return null;
+    const tsMs = frontmatterTimestampMs(fm, p);
+    if (!tsMs) return null;
+    const ageDays = (now - tsMs) / DAY_MS;
+    if (ageDays > BLACKLIST_DAYS) return null;
+    return { name, daysRemaining: Math.max(0, Math.ceil(BLACKLIST_DAYS - ageDays)) };
+  });
+
+  if (blacklistHits.length) {
+    const h = blacklistHits[0];
+    return {
+      status: "blacklisted",
+      reason: `auto_apply_blacklist active on rejected/${h.name}`,
+      blocked_by: { file: h.name, days_remaining: h.daysRemaining },
+    };
+  }
+  if (appliedHits.length) {
+    const h = appliedHits[0];
+    return {
+      status: "cooldown",
+      reason: `applied within ${COOLDOWN_DAYS}d (applied/${h.name})`,
+      blocked_by: { file: h.name, days_remaining: h.daysRemaining },
+    };
+  }
+  return { status: "cool", reason: "no recent applied/rejected match", blocked_by: null };
+}
+
+// djb2 hash returned as base36 — deterministic, no deps.
+function djb2(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) {
+    h = (((h << 5) + h) ^ s.charCodeAt(i)) >>> 0; // xor variant, force u32
+  }
+  return h.toString(36);
+}
+
+export function computeProposalFingerprint(proposal) {
+  if (!proposal || typeof proposal !== "object") return LEGACY_FINGERPRINT;
+  const skill = proposal.skill_slug || proposal.target_skill || proposal.skill || "";
+  const cluster = proposal.signal_cluster_id || proposal.cluster_id || "";
+  // normalized_diff_body: whitespace (incl. newlines) collapsed to single
+  // spaces, then trimmed. Matches agents/adam.md §"Per-(skill, fingerprint)
+  // cooldown". (No trailing-newline strip needed — \s+ already absorbed them.)
+  const diff = String(proposal.diff_body || proposal.proposed_change || "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return djb2(`${skill}\n${cluster}\n${diff}`);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(
+      "usage: adam-cooldown.mjs --skill <slug> --fingerprint <hash> [--home <path>]\n" +
+      "       adam-cooldown.mjs --compute --skill <slug> --cluster <id> [--diff-file <path>]\n"
+    );
+    process.exit(0);
+  }
+  // --compute: deterministically derive a proposal_fingerprint. The analyst
+  // invokes this (it has Bash) after drafting a proposal, then writes the
+  // result into proposal frontmatter so the cooldown gate keys on it.
+  if (args.compute) {
+    let diff = "";
+    if (args.diffFile) {
+      try { diff = readFileSync(args.diffFile, "utf8"); } catch { /* empty → still deterministic */ }
+    } else {
+      try { diff = readFileSync(0, "utf8"); } catch { /* no stdin */ }
+    }
+    const fp = computeProposalFingerprint({
+      skill_slug: args.skill || "",
+      signal_cluster_id: args.cluster || "",
+      diff_body: diff,
+    });
+    process.stdout.write(JSON.stringify({ fingerprint: fp }) + "\n");
+    process.exit(0);
+  }
+  if (!args.skill || !args.fingerprint) {
+    process.stderr.write("adam-cooldown: --skill and --fingerprint required\n");
+    process.exit(1);
+  }
+  const home = args.home || join(homedir(), ".claude");
+  try {
+    const result = checkCooldown(home, args.skill, args.fingerprint);
+    process.stdout.write(JSON.stringify(result) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-cooldown error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+// adam-explain.mjs — render the analyst's clustering trace in summary / full / json modes.
+//
+// The adam agent ALWAYS emits a fenced ```trace block after its proposals. The
+// adam-self-improvement skill persists the most recent trace to
+// ~/.claude/adam/last-trace.txt. This tool parses and presents it.
+//
+// Trace line grammar (per agents/adam.md "Clustering trace (always emit)"):
+//   <cluster_id> | signal=<type> count=<N> sessions=<M> | gates: threshold=<pass|fail:<reason>>, cross_session=<pass|fail>, window=<in:<N>/out:<M>>, contradiction=<none|vetoed:[[memory-name]]> | decision: <proposal_emitted:<type>|skipped:<reason>>
+// Trailing summary line:
+//   SUMMARY: considered=<N> emitted=<M> skipped=<N-M> reasons={threshold:X, contradiction:Y, window:Z, other:W}
+//
+// Usage: adam-explain.mjs [--input <path>] [--mode summary|full|json] [--home <path>]
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+function parseArgs(argv) {
+  const args = { input: null, mode: "summary", home: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--input" && i + 1 < argv.length) args.input = argv[++i];
+    else if (a === "--mode" && i + 1 < argv.length) args.mode = argv[++i];
+    else if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+  }
+  return args;
+}
+
+// Extract the inside of a ```trace ... ``` fenced block, or return the input
+// verbatim if no fence is present (tolerant mode).
+function extractFenced(text) {
+  const m = text.match(/```trace\s*\n([\s\S]*?)\n```/);
+  return m ? m[1] : text;
+}
+
+// Parse a single cluster line. Returns null when no recognisable structure.
+function parseClusterLine(line) {
+  // Three pipe-separated chunks: id | signal=… count=… sessions=… | gates: … | decision: …
+  const parts = line.split("|").map((s) => s.trim());
+  if (parts.length < 4) return null;
+  const id = parts[0];
+  if (!id) return null;
+  const sigChunk = parts[1];
+  const gatesChunk = parts[2];
+  const decisionChunk = parts.slice(3).join("|").trim();
+
+  const sigM = sigChunk.match(/signal=(\S+)\s+count=(\d+)\s+sessions=(\d+)/);
+  if (!sigM) return null;
+  const signal = sigM[1];
+  const count = Number(sigM[2]);
+  const sessions = Number(sigM[3]);
+
+  if (!gatesChunk.startsWith("gates:")) return null;
+  const gatesBody = gatesChunk.slice("gates:".length).trim();
+  const gates = {};
+  // gates body is a comma-separated list of key=value with possible commas inside values
+  // we accept simple key=token,key=token,… — split on commas not inside [[ ]]
+  const tokens = [];
+  let depth = 0;
+  let buf = "";
+  for (const ch of gatesBody) {
+    if (ch === "[") depth++;
+    else if (ch === "]") depth--;
+    if (ch === "," && depth === 0) { tokens.push(buf.trim()); buf = ""; }
+    else buf += ch;
+  }
+  if (buf.trim()) tokens.push(buf.trim());
+  for (const t of tokens) {
+    const idx = t.indexOf("=");
+    if (idx === -1) continue;
+    gates[t.slice(0, idx).trim()] = t.slice(idx + 1).trim();
+  }
+
+  if (!decisionChunk.startsWith("decision:")) return null;
+  const decision = decisionChunk.slice("decision:".length).trim();
+
+  return { id, signal, count, sessions, gates, decision };
+}
+
+function parseSummaryLine(line) {
+  // SUMMARY: considered=N emitted=M skipped=K [regressions=R] reasons={...}
+  // `regressions` is optional (added in #5 — A/B measurement). Pre-existing
+  // traces lacking the token still parse.
+  const m = line.match(
+    /^SUMMARY:\s*considered=(\d+)\s+emitted=(\d+)\s+skipped=(\d+)(?:\s+regressions=(\d+))?\s+reasons=\{([^}]*)\}\s*$/
+  );
+  if (!m) return null;
+  const reasons = {};
+  for (const piece of m[5].split(",")) {
+    const kv = piece.trim();
+    if (!kv) continue;
+    const idx = kv.indexOf(":");
+    if (idx === -1) continue;
+    reasons[kv.slice(0, idx).trim()] = Number(kv.slice(idx + 1).trim()) || 0;
+  }
+  return {
+    considered: Number(m[1]),
+    emitted: Number(m[2]),
+    skipped: Number(m[3]),
+    regressions: m[4] != null ? Number(m[4]) : 0,
+    reasons,
+  };
+}
+
+export function parseTrace(text) {
+  const body = extractFenced(text || "");
+  const lines = body.split("\n").map((l) => l.replace(/\s+$/, "")).filter((l) => l.trim().length);
+  const clusters = [];
+  let summary = null;
+  const warnings = [];
+  for (const line of lines) {
+    if (line.startsWith("SUMMARY:")) {
+      const s = parseSummaryLine(line);
+      if (s) summary = s;
+      else warnings.push(`malformed summary line: ${line}`);
+      continue;
+    }
+    const c = parseClusterLine(line);
+    if (c) clusters.push(c);
+    else warnings.push(`malformed cluster line: ${line}`);
+  }
+  // Synthesize a summary from clusters when none provided AND clusters parsed.
+  if (!summary && clusters.length) {
+    const reasons = { threshold: 0, contradiction: 0, window: 0, other: 0 };
+    let emitted = 0;
+    for (const c of clusters) {
+      if (c.decision.startsWith("proposal_emitted")) emitted++;
+      else {
+        const r = (c.decision.match(/^skipped:(\S+)/) || [])[1] || "other";
+        reasons[r in reasons ? r : "other"]++;
+      }
+    }
+    summary = {
+      considered: clusters.length,
+      emitted,
+      skipped: clusters.length - emitted,
+      regressions: 0,
+      reasons,
+    };
+  }
+  return { clusters, summary, warnings };
+}
+
+function countByDecision(clusters) {
+  const counts = {};
+  for (const c of clusters) {
+    const key = c.decision.startsWith("proposal_emitted")
+      ? "proposal_emitted"
+      : (c.decision.match(/^skipped:(\S+)/)?.[1] || "other");
+    counts[key] = (counts[key] || 0) + 1;
+  }
+  return counts;
+}
+
+export function formatSummary(parsed) {
+  const s = parsed.summary;
+  if (!s) return "no trace data";
+  const reasonStr = Object.entries(s.reasons)
+    .map(([k, v]) => `${k}:${v}`)
+    .join(", ");
+  const counts = countByDecision(parsed.clusters);
+  const breakdown = Object.entries(counts)
+    .map(([k, v]) => `${k}=${v}`)
+    .join(" ");
+  const head = `considered=${s.considered} emitted=${s.emitted} skipped=${s.skipped} reasons={${reasonStr}}`;
+  return breakdown ? `${head}\nclusters by decision: ${breakdown}` : head;
+}
+
+export function formatFull(parsed) {
+  const lines = [];
+  for (const c of parsed.clusters) {
+    const gatesStr = Object.entries(c.gates).map(([k, v]) => `${k}=${v}`).join(", ");
+    lines.push(`${c.id} | signal=${c.signal} count=${c.count} sessions=${c.sessions} | gates: ${gatesStr} | decision: ${c.decision}`);
+  }
+  if (parsed.summary) {
+    const s = parsed.summary;
+    const reasonStr = Object.entries(s.reasons).map(([k, v]) => `${k}:${v}`).join(", ");
+    lines.push(`SUMMARY: considered=${s.considered} emitted=${s.emitted} skipped=${s.skipped} regressions=${s.regressions ?? 0} reasons={${reasonStr}}`);
+  }
+  // Histogram footer: only count actual rejection reasons from clusters.
+  const hist = {};
+  for (const c of parsed.clusters) {
+    const m = c.decision.match(/^skipped:(\S+)/);
+    if (m) hist[m[1]] = (hist[m[1]] || 0) + 1;
+  }
+  const histStr = Object.entries(hist).map(([k, v]) => `${k} ${v}`).join(", ");
+  lines.push(`Rejection reasons: ${histStr || "none"}`);
+  return lines.join("\n");
+}
+
+export function formatJson(parsed) {
+  return JSON.stringify({
+    clusters: parsed.clusters,
+    summary: parsed.summary,
+  }, null, 2);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const claudeHome = args.home || join(homedir(), ".claude");
+  const defaultInput = join(claudeHome, "adam", "last-trace.txt");
+  const inputPath = args.input || defaultInput;
+
+  let raw;
+  try {
+    if (!existsSync(inputPath)) {
+      process.stderr.write(`adam-explain: input not found: ${inputPath}\n`);
+      process.exit(1);
+    }
+    raw = readFileSync(inputPath, "utf8");
+  } catch (e) {
+    process.stderr.write(`adam-explain: read failed: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  const parsed = parseTrace(raw);
+  if (!parsed.clusters.length && !parsed.summary) {
+    process.stderr.write(`adam-explain: no parseable trace lines in ${inputPath}\n`);
+    process.exit(1);
+  }
+  for (const w of parsed.warnings) {
+    process.stderr.write(`adam-explain: warn: ${w}\n`);
+  }
+
+  const mode = args.mode || "summary";
+  let out;
+  if (mode === "full") out = formatFull(parsed);
+  else if (mode === "json") out = formatJson(parsed);
+  else out = formatSummary(parsed);
+  process.stdout.write(out + "\n");
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  try { main(); } catch (e) {
+    process.stderr.write(`adam-explain error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+// adam-nudge-eligibility.mjs — checks whether the current session has accrued
+// enough `dead_end` entries to warrant emitting a cross-session nudge.
+//
+// CLI: adam-nudge-eligibility.mjs [--home <path>] [--session <id>]
+//   --home    defaults to $HOME/.claude
+//   --session if absent, reads state.json `session_id` field
+//
+// Output (stdout): JSON one-liner
+//   eligible: {"eligible": true, "session_id": "...", "dead_end_count": N, "last_ts": "..."}
+//   not:      {"eligible": false, "session_id": "...", "dead_end_count": N, "last_ts": "..."|null}
+// Exit codes:
+//   0 — read succeeded (eligible OR not)
+//   1 — read failure / unable to resolve session
+//
+// Threshold: ≥3 dead_end entries within a single session_id across the active
+// journal + all rotated journal/*.jsonl files. Threshold matches the
+// "dead-end checkpoint" feedback rule.
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readJsonlSafe, listJsonlFiles } from "./adam-utils.mjs";
+
+export const DEAD_END_THRESHOLD = 3;
+
+function parseArgs(argv) {
+  const args = { home: null, session: null, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--session" && i + 1 < argv.length) args.session = argv[++i];
+    else if (a === "--help" || a === "-h") args.help = true;
+  }
+  return args;
+}
+
+function resolveSession(home, fallback) {
+  if (fallback) return fallback;
+  const statePath = join(home, "adam", "state.json");
+  if (!existsSync(statePath)) return null;
+  try {
+    const st = JSON.parse(readFileSync(statePath, "utf8"));
+    return st && typeof st.session_id === "string" ? st.session_id : null;
+  } catch { return null; }
+}
+
+export function checkEligibility(home, sessionId) {
+  const adamRoot = join(home, "adam");
+  const sources = [
+    join(adamRoot, "journal.jsonl"),
+    ...listJsonlFiles(join(adamRoot, "journal")),
+  ];
+  let count = 0;
+  let lastTs = null;
+  for (const p of sources) {
+    for (const e of readJsonlSafe(p)) {
+      if (!e || e.type !== "dead_end") continue;
+      if (e.session !== sessionId && e.session_id !== sessionId) continue;
+      count++;
+      const ts = typeof e.ts === "string" ? e.ts : null;
+      if (ts && (!lastTs || ts > lastTs)) lastTs = ts;
+    }
+  }
+  return {
+    eligible: count >= DEAD_END_THRESHOLD,
+    session_id: sessionId,
+    dead_end_count: count,
+    last_ts: lastTs,
+  };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write("usage: adam-nudge-eligibility.mjs [--home <path>] [--session <id>]\n");
+    process.exit(0);
+  }
+  const home = args.home || join(homedir(), ".claude");
+  const sessionId = resolveSession(home, args.session);
+  if (!sessionId) {
+    process.stderr.write("adam-nudge-eligibility: no session_id (pass --session or seed state.json)\n");
+    process.exit(1);
+  }
+  try {
+    const result = checkEligibility(home, sessionId);
+    process.stdout.write(JSON.stringify(result) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-nudge-eligibility error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+// adam-rollback.mjs — auto-reverts proposals that regressed after apply.
+//
+// Implements MOSS §3.5: "rollback is mandatory because... a candidate that
+// passes trial can still regress live."
+//
+// For each regressed proposal (detected by adam-ab-measure.mjs):
+//   1. Reads the applied proposal from applied/
+//   2. Parses the `# Rollback` section for undo commands
+//   3. Moves proposal from applied/ to proposals/ with `rolled_back: true`
+//   4. Creates a regression nudge for next SessionStart
+//   5. Removes the ab-tracking entry (so it doesn't re-trigger)
+//
+// CLI:
+//   adam-rollback.mjs --proposal-id <id> [--home <path>] [--dry-run]
+//   adam-rollback.mjs --auto [--home <path>] [--dry-run]
+//
+//   --auto mode: reads ab-measure output, rolls back all regressed proposals.
+//
+// Output: JSON object with rollback results per proposal.
+// Does NOT execute the undo commands itself — outputs them for the skill to
+// execute in-context (safety: undo commands may reference files the script
+// can't safely modify).
+
+import { readFileSync, writeFileSync, renameSync, readdirSync, existsSync, mkdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { parseFrontmatter, readJsonlSafe, listJsonlFiles } from "./adam-utils.mjs";
+
+function parseArgs(argv) {
+  const args = { home: null, proposalId: null, auto: false, dryRun: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--proposal-id" && i + 1 < argv.length) args.proposalId = argv[++i];
+    else if (a === "--auto") args.auto = true;
+    else if (a === "--dry-run") args.dryRun = true;
+    else if (a === "--help" || a === "-h") args.help = true;
+  }
+  return args;
+}
+
+function findAppliedProposal(appliedDir, proposalId) {
+  if (!existsSync(appliedDir)) return null;
+  try {
+    const files = readdirSync(appliedDir).filter(n => n.endsWith(".md"));
+    for (const f of files) {
+      if (f.includes(proposalId)) return join(appliedDir, f);
+    }
+  } catch { /* skip */ }
+  return null;
+}
+
+function extractRollbackSection(content) {
+  const idx = content.indexOf("\n# Rollback\n");
+  if (idx === -1) return null;
+  let body = content.slice(idx + "\n# Rollback\n".length);
+  const nextSection = body.search(/\n# |\n---/);
+  if (nextSection !== -1) body = body.slice(0, nextSection);
+  return body.trim() || null;
+}
+
+function extractUndoCommands(rollbackSection) {
+  if (!rollbackSection) return [];
+  const commands = [];
+  const lines = rollbackSection.split("\n");
+  let inCodeBlock = false;
+  let blockLines = [];
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      if (inCodeBlock) {
+        if (blockLines.length) commands.push(blockLines.join("\n"));
+        blockLines = [];
+      }
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) {
+      blockLines.push(line);
+    }
+  }
+  return commands;
+}
+
+export function planRollback(appliedDir, proposalId) {
+  const path = findAppliedProposal(appliedDir, proposalId);
+  if (!path) return { status: "not_found", proposal_id: proposalId };
+
+  const content = readFileSync(path, "utf8");
+  const fm = parseFrontmatter(content);
+  const rollbackSection = extractRollbackSection(content);
+  const undoCommands = extractUndoCommands(rollbackSection);
+
+  return {
+    status: "planned",
+    proposal_id: proposalId,
+    applied_path: path,
+    type: fm.type || "unknown",
+    target: fm.target || null,
+    target_skill: fm.target_skill || null,
+    undo_commands: undoCommands,
+    has_rollback_section: !!rollbackSection,
+  };
+}
+
+export function executeRollback(plan, adamRoot, opts = {}) {
+  const dryRun = opts.dryRun || false;
+  const proposalsDir = join(adamRoot, "proposals");
+  const nudgesPath = join(adamRoot, "active-nudges.json");
+  const now = Date.now();
+
+  if (plan.status !== "planned") return { ...plan, action: "skipped" };
+
+  const result = {
+    proposal_id: plan.proposal_id,
+    type: plan.type,
+    target: plan.target,
+    undo_commands: plan.undo_commands,
+    actions: [],
+  };
+
+  if (dryRun) {
+    result.actions.push("dry_run: would move applied → proposals");
+    if (plan.undo_commands.length) {
+      result.actions.push(`dry_run: would output ${plan.undo_commands.length} undo command(s)`);
+    }
+    result.actions.push("dry_run: would create regression nudge");
+    result.status = "dry_run";
+    return result;
+  }
+
+  mkdirSync(proposalsDir, { recursive: true });
+  const destName = `${basename(plan.applied_path).replace(/\.md$/, "")}-rollback.md`;
+  const destPath = join(proposalsDir, destName);
+
+  let content = readFileSync(plan.applied_path, "utf8");
+  const rollbackMeta = `\nrolled_back: true\nrolled_back_at: "${new Date(now).toISOString()}"`;
+  content = content.replace(/^(---\n[\s\S]*?)(---)/m, `$1${rollbackMeta}\n$2`);
+
+  try {
+    writeFileSync(destPath, content);
+    renameSync(plan.applied_path, plan.applied_path + ".rolled-back");
+    result.actions.push(`moved ${plan.applied_path} → ${destPath}`);
+  } catch (e) {
+    result.status = "move_failed";
+    result.error = e.message;
+    return result;
+  }
+
+  try {
+    let nudges = [];
+    if (existsSync(nudgesPath)) {
+      try { nudges = JSON.parse(readFileSync(nudgesPath, "utf8")); } catch { nudges = []; }
+    }
+    nudges.push({
+      kind: "regression_rollback",
+      message: `adam: rolled back "${plan.proposal_id}" (type: ${plan.type}) — regression detected in A/B measurement. Review with /reflect.`,
+      created_at: now,
+      expires_at_ts: now + 7 * 86400000,
+      max_displays: 3,
+      displays_used: 0,
+      source_proposal: plan.proposal_id,
+    });
+    writeFileSync(nudgesPath, JSON.stringify(nudges, null, 2));
+    result.actions.push("regression nudge created");
+  } catch (e) {
+    result.actions.push(`nudge failed: ${e.message}`);
+  }
+
+  // Remove the ab-tracking entry for this proposal so it stops re-flagging as a
+  // regression on every future /reflect (which would trigger endless not_found
+  // rollback attempts). This is the documented contract for rollback.
+  try {
+    const abPath = join(adamRoot, "ab-tracking.jsonl");
+    if (existsSync(abPath)) {
+      const before = readJsonlSafe(abPath);
+      const kept = before.filter((e) => !(e && e.proposal_id === plan.proposal_id));
+      if (kept.length !== before.length) {
+        writeFileSync(abPath, kept.length ? kept.map((e) => JSON.stringify(e)).join("\n") + "\n" : "");
+        result.actions.push(`ab-tracking entry removed (${before.length - kept.length})`);
+      }
+    }
+  } catch (e) {
+    result.actions.push(`ab-tracking cleanup failed: ${e.message}`);
+  }
+
+  result.status = "rolled_back";
+  return result;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(
+      "usage: adam-rollback.mjs --proposal-id <id> [--home <path>] [--dry-run]\n" +
+      "       adam-rollback.mjs --auto [--home <path>] [--dry-run]\n"
+    );
+    process.exit(0);
+  }
+
+  const claudeHome = args.home || join(homedir(), ".claude");
+  const adamRoot = join(claudeHome, "adam");
+  const appliedDir = join(adamRoot, "applied");
+
+  try {
+    const results = [];
+
+    if (args.auto) {
+      const abPath = join(adamRoot, "ab-tracking.jsonl");
+      const entries = readJsonlSafe(abPath);
+      const { computeDeltas } = await import("./adam-ab-measure.mjs");
+      const sources = [join(adamRoot, "journal.jsonl"), ...listJsonlFiles(join(adamRoot, "journal"))];
+      const journalAll = [];
+      for (const p of sources) for (const e of readJsonlSafe(p)) journalAll.push(e);
+      const deltas = computeDeltas(entries, journalAll);
+      const regressed = deltas.filter(d => d.status === "regressed");
+
+      for (const d of regressed) {
+        const plan = planRollback(appliedDir, d.proposal_id);
+        const result = executeRollback(plan, adamRoot, { dryRun: args.dryRun });
+        results.push(result);
+      }
+    } else if (args.proposalId) {
+      const plan = planRollback(appliedDir, args.proposalId);
+      const result = executeRollback(plan, adamRoot, { dryRun: args.dryRun });
+      results.push(result);
+    } else {
+      process.stderr.write("adam-rollback: specify --proposal-id or --auto\n");
+      process.exit(1);
+    }
+
+    process.stdout.write(JSON.stringify({ rollbacks: results }) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-rollback error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+// adam-score.mjs — computes per-session urgency dampeners + reinforcement
+// candidates from `task_completed` signals.
+//
+// Effects:
+//   1. Dampener:
+//        task_completed_count >= 3 → 0.5
+//        task_completed_count >= 1 → 0.75
+//        else                     → 1.0
+//      Analyst multiplies a cluster's urgency by the dampener of the session
+//      it originated from.
+//   2. Reinforcement candidates: per skill, count of clean task_completed
+//      events citing it (via `active_skills` payload). Skills with count >= 3
+//      are surfaced as reinforcement proposal candidates (low blast,
+//      confidence ≥ 4 required for auto-apply, same gate as memory).
+//
+// CLI:
+//   adam-score.mjs [--home <path>] [--input <jsonl-path>]
+//
+//   --input  defaults to: stdout of adam-window.mjs (preferred) — if missing,
+//            falls back to the raw active journal.
+//
+// Output: JSON object
+//   {
+//     "sessions": [
+//       {"session_id": "...", "negative_count": N, "task_completed_count": M,
+//        "severity_sum": S, "severity_by_type": {"<type>": N, ...}, "dampener": 1.0}
+//     ],
+//     "reinforcement_candidates": [
+//       {"skill_slug": "tdd-loop", "count": 3, "recent_ts": "..."}
+//     ]
+//   }
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readJsonlSafe, listJsonlFiles } from "./adam-utils.mjs";
+
+export const NEGATIVE_SIGNAL_TYPES = new Set([
+  "correction",
+  "tool_error_loop",
+  "dead_end",
+  "edit_churn",
+  "retry_loop",
+  "build_loop",
+  "weak_agent",
+  "silent_drift",
+  "error_after_recovery",
+]);
+
+export const REINFORCEMENT_THRESHOLD = 3;
+
+// Severity divisor per struggle signal type. Severity = max(1, floor(count / divisor)).
+// Entries without `count` default to severity 1. Source of truth — referenced by
+// agents/adam.md (Confidence rubric → severity-sum bullets).
+export const SEVERITY_DIVISORS = {
+  dead_end: 8,
+  edit_churn: 4,
+  tool_error_loop: 3,
+  retry_loop: 3,
+  file_reread: 3,
+  weak_agent: 2,
+  build_loop: 1,
+};
+
+export function entrySeverity(entry) {
+  if (!entry || typeof entry !== "object") return 1;
+  const divisor = SEVERITY_DIVISORS[entry.type];
+  if (!divisor) return 1;
+  const count = typeof entry.count === "number" && entry.count > 0 ? entry.count : 1;
+  return Math.max(1, Math.floor(count / divisor));
+}
+
+function parseArgs(argv) {
+  const args = { home: null, input: null, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--input" && i + 1 < argv.length) args.input = argv[++i];
+    else if (a === "--help" || a === "-h") args.help = true;
+  }
+  return args;
+}
+
+function readAllStdin() {
+  try { return readFileSync(0, "utf8"); } catch { return ""; }
+}
+
+function entriesFromText(text) {
+  const out = [];
+  for (const line of (text || "").split("\n")) {
+    if (!line) continue;
+    try { out.push(JSON.parse(line)); } catch { /* skip */ }
+  }
+  return out;
+}
+
+function computeDampener(taskCompletedCount) {
+  if (taskCompletedCount >= 3) return 0.5;
+  if (taskCompletedCount >= 1) return 0.75;
+  return 1.0;
+}
+
+export function computeSessionScores(entries) {
+  const bySession = new Map();
+  for (const e of entries || []) {
+    if (!e || typeof e !== "object") continue;
+    const sid = e.session || e.session_id || "";
+    if (!sid) continue;
+    if (!bySession.has(sid)) {
+      bySession.set(sid, {
+        session_id: sid,
+        negative_count: 0,
+        task_completed_count: 0,
+        severity_sum: 0,
+        severity_by_type: {},
+      });
+    }
+    const slot = bySession.get(sid);
+    if (e.type === "task_completed") slot.task_completed_count++;
+    else if (NEGATIVE_SIGNAL_TYPES.has(e.type)) {
+      slot.negative_count++;
+      const sev = entrySeverity(e);
+      slot.severity_sum += sev;
+      slot.severity_by_type[e.type] = (slot.severity_by_type[e.type] || 0) + sev;
+    }
+  }
+  const out = [];
+  for (const slot of bySession.values()) {
+    out.push({
+      ...slot,
+      dampener: computeDampener(slot.task_completed_count),
+    });
+  }
+  // Stable ordering by session_id for deterministic output.
+  out.sort((a, b) => (a.session_id < b.session_id ? -1 : a.session_id > b.session_id ? 1 : 0));
+  return out;
+}
+
+export function computeReinforcementCandidates(entries) {
+  const counts = new Map();
+  for (const e of entries || []) {
+    if (!e || e.type !== "task_completed") continue;
+    const skills = Array.isArray(e.active_skills) ? e.active_skills : [];
+    for (const slug of skills) {
+      if (!slug || typeof slug !== "string") continue;
+      if (!counts.has(slug)) counts.set(slug, { count: 0, recent_ts: null });
+      const slot = counts.get(slug);
+      slot.count++;
+      const ts = typeof e.ts === "string" ? e.ts : null;
+      if (ts && (!slot.recent_ts || ts > slot.recent_ts)) slot.recent_ts = ts;
+    }
+  }
+  const out = [];
+  for (const [slug, { count, recent_ts }] of counts.entries()) {
+    if (count < REINFORCEMENT_THRESHOLD) continue;
+    out.push({ skill_slug: slug, count, recent_ts });
+  }
+  out.sort((a, b) => b.count - a.count || (a.skill_slug < b.skill_slug ? -1 : 1));
+  return out;
+}
+
+function gatherInputEntries(args) {
+  if (args.input) return readJsonlSafe(args.input);
+  // Honor piped stdin only when it is non-empty AND not a TTY.
+  if (!process.stdin.isTTY) {
+    const piped = readAllStdin();
+    if (piped && piped.trim()) return entriesFromText(piped);
+  }
+  // Default fallback: active journal + rotated files.
+  const home = args.home || join(homedir(), ".claude");
+  const adamRoot = join(home, "adam");
+  const sources = [
+    join(adamRoot, "journal.jsonl"),
+    ...listJsonlFiles(join(adamRoot, "journal")),
+  ];
+  const all = [];
+  for (const p of sources) {
+    for (const e of readJsonlSafe(p)) all.push(e);
+  }
+  return all;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write("usage: adam-score.mjs [--home <path>] [--input <jsonl-path>]\n");
+    process.exit(0);
+  }
+  try {
+    const entries = gatherInputEntries(args);
+    const sessions = computeSessionScores(entries);
+    const reinforcement_candidates = computeReinforcementCandidates(entries);
+    process.stdout.write(JSON.stringify({ sessions, reinforcement_candidates }) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-score error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+// adam-skill-utility.mjs — execution-grounded per-skill utility report.
+//
+// Inspired by SkillsInjector (arXiv 2605.29794v1), which shows skill injection
+// should be driven by execution-grounded *utility* Δ(t,s), not surface keyword
+// match — and that some topically-relevant skills actively *lower* success.
+// The paper learns Δ(t,s) from rollout outcomes. We don't train anything: the
+// adam journal already attaches `active_skills` to both positive outcome events
+// (task_completed, clean_recovery, correction_free_streak) and negative ones
+// (dead_end, tool_error_loop, …). So we approximate Δ(s) as a co-occurrence
+// ratio over the data we already collect.
+//
+// CAVEAT (honest): this is CO-OCCURRENCE, not causation. A skill active during
+// a dead_end did not necessarily cause it. Read the report as "which skills
+// correlate with friction", a prompt for review — never as proof.
+//
+// Metric, per skill active during scored events:
+//   pos / neg     — count of positive / negative outcome events it co-occurred with
+//   share         — pos / (pos+neg)
+//   lift          — share − global_baseline   (>0 above baseline, <0 below)
+//   wLB           — Wilson 95% lower bound of the positive proportion; ranks
+//                   *reliably* below-baseline skills to the top (sample-aware)
+//   sevNeg        — severity-weighted negative sum (adam SEVERITY_DIVISORS)
+//   topNeg        — dominant negative event type
+// Rows sorted worst-first (lowest wLB) so harmful/over-eager skills surface.
+//
+// CLI:
+//   adam-skill-utility.mjs [--home <path>] [--input <jsonl-path>]
+//                          [--min <n>] [--days <n>] [--json]
+//   --min   min event count (n) to treat a skill's signal as confident (default 8)
+//   --days  only consider events within the last <n> days (default: all)
+//   --json  emit machine-readable JSON instead of the text table
+//
+// Reuses adam-utils (jsonl IO) and adam-score (canonical NEGATIVE set +
+// severity), so the positive/negative taxonomy stays single-sourced.
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readJsonlSafe, listJsonlFiles } from "./adam-utils.mjs";
+import { NEGATIVE_SIGNAL_TYPES, entrySeverity } from "./adam-score.mjs";
+
+// Positive outcome signals (mirror adam's vocabulary; task_completed is adam's
+// canonical "clean task", the same one adam-score uses for reinforcement).
+export const POSITIVE_SIGNAL_TYPES = new Set([
+  "task_completed",
+  "clean_recovery",
+  "correction_free_streak",
+]);
+
+export const DEFAULT_MIN_SAMPLE = 8;
+
+function round(x) {
+  return Math.round(x * 1000) / 1000;
+}
+
+// Wilson score interval lower bound for a binomial proportion. Sample-aware:
+// a skill with 1 pos / 0 neg does NOT outrank one with 40 pos / 2 neg.
+export function wilsonLower(pos, n, z = 1.96) {
+  if (n <= 0) return 0;
+  const p = pos / n;
+  const z2 = z * z;
+  const denom = 1 + z2 / n;
+  const center = p + z2 / (2 * n);
+  const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n);
+  return (center - margin) / denom;
+}
+
+// computeSkillUtility: pure. entries → { baseline, totalPos, totalNeg, min, skills[] }.
+export function computeSkillUtility(entries, opts = {}) {
+  const min = Number.isFinite(opts.min) ? opts.min : DEFAULT_MIN_SAMPLE;
+  const per = new Map();
+  let totalPos = 0;
+  let totalNeg = 0;
+
+  for (const e of entries || []) {
+    if (!e || typeof e !== "object") continue;
+    const isPos = POSITIVE_SIGNAL_TYPES.has(e.type);
+    const isNeg = NEGATIVE_SIGNAL_TYPES.has(e.type);
+    if (!isPos && !isNeg) continue;
+
+    if (isPos) totalPos++;
+    else totalNeg++;
+    const sev = isNeg ? entrySeverity(e) : 0;
+
+    const skills = Array.isArray(e.active_skills) ? e.active_skills : [];
+    for (const slug of skills) {
+      if (!slug || typeof slug !== "string") continue;
+      if (!per.has(slug)) {
+        per.set(slug, { pos: 0, neg: 0, sevNeg: 0, negTypes: {}, recent_ts: null });
+      }
+      const s = per.get(slug);
+      if (isPos) {
+        s.pos++;
+      } else {
+        s.neg++;
+        s.sevNeg += sev;
+        s.negTypes[e.type] = (s.negTypes[e.type] || 0) + 1;
+      }
+      const ts = typeof e.ts === "string" ? e.ts : null;
+      if (ts && (!s.recent_ts || ts > s.recent_ts)) s.recent_ts = ts;
+    }
+  }
+
+  const scored = totalPos + totalNeg;
+  const baseline = scored ? totalPos / scored : 0;
+
+  const skills = [];
+  for (const [slug, s] of per.entries()) {
+    const n = s.pos + s.neg;
+    const share = n ? s.pos / n : 0;
+    const topNeg = Object.entries(s.negTypes).sort((a, b) => b[1] - a[1])[0];
+    skills.push({
+      skill: slug,
+      n,
+      pos: s.pos,
+      neg: s.neg,
+      share: round(share),
+      lift: round(share - baseline),
+      wLB: round(wilsonLower(s.pos, n)),
+      sevNeg: s.sevNeg,
+      topNeg: topNeg ? topNeg[0] : null,
+      lowSample: n < min,
+      recent_ts: s.recent_ts,
+    });
+  }
+  // Worst-first: lowest Wilson lower bound, then most negatives.
+  skills.sort(
+    (a, b) =>
+      a.wLB - b.wLB ||
+      b.neg - a.neg ||
+      (a.skill < b.skill ? -1 : a.skill > b.skill ? 1 : 0),
+  );
+
+  return { baseline: round(baseline), totalPos, totalNeg, min, skills };
+}
+
+function parseArgs(argv) {
+  const args = { home: null, input: null, min: DEFAULT_MIN_SAMPLE, days: null, json: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (a === "--input" && i + 1 < argv.length) args.input = argv[++i];
+    else if (a === "--min" && i + 1 < argv.length) args.min = Number(argv[++i]);
+    else if (a === "--days" && i + 1 < argv.length) args.days = Number(argv[++i]);
+    else if (a === "--json") args.json = true;
+    else if (a === "--help" || a === "-h") args.help = true;
+  }
+  return args;
+}
+
+function readAllStdin() {
+  try { return readFileSync(0, "utf8"); } catch { return ""; }
+}
+
+function entriesFromText(text) {
+  const out = [];
+  for (const line of (text || "").split("\n")) {
+    if (!line) continue;
+    try { out.push(JSON.parse(line)); } catch { /* skip */ }
+  }
+  return out;
+}
+
+// Same gathering strategy as adam-score.mjs: explicit --input, else piped
+// stdin (e.g. from adam-window.mjs), else the active journal + rotated files.
+function gatherInputEntries(args) {
+  if (args.input) return readJsonlSafe(args.input);
+  if (!process.stdin.isTTY) {
+    const piped = readAllStdin();
+    if (piped && piped.trim()) return entriesFromText(piped);
+  }
+  const home = args.home || join(homedir(), ".claude");
+  const adamRoot = join(home, "adam");
+  const sources = [join(adamRoot, "journal.jsonl"), ...listJsonlFiles(join(adamRoot, "journal"))];
+  const all = [];
+  for (const p of sources) {
+    for (const e of readJsonlSafe(p)) all.push(e);
+  }
+  return all;
+}
+
+function filterByDays(entries, days) {
+  if (!Number.isFinite(days) || days <= 0) return entries;
+  // Anchor the window to the newest ts in the data (avoids Date.now()
+  // nondeterminism and works on historical exports).
+  let maxMs = 0;
+  for (const e of entries) {
+    const ms = e && typeof e.ts === "string" ? Date.parse(e.ts) : NaN;
+    if (Number.isFinite(ms) && ms > maxMs) maxMs = ms;
+  }
+  if (!maxMs) return entries;
+  const cutoff = maxMs - days * 86400000;
+  return entries.filter((e) => {
+    const ms = e && typeof e.ts === "string" ? Date.parse(e.ts) : NaN;
+    return Number.isFinite(ms) ? ms >= cutoff : false;
+  });
+}
+
+function pad(s, w) {
+  s = String(s);
+  return s.length >= w ? s : s + " ".repeat(w - s.length);
+}
+function padL(s, w) {
+  s = String(s);
+  return s.length >= w ? s : " ".repeat(w - s.length) + s;
+}
+
+function renderText(report) {
+  const { baseline, totalPos, totalNeg, min, skills } = report;
+  const lines = [];
+  lines.push("adam skill-utility report — execution-grounded Δ(skill) proxy");
+  lines.push(
+    `baseline positive-rate ${(baseline * 100).toFixed(1)}%  ` +
+      `(${totalPos} positive / ${totalNeg} negative outcome events)  min-sample n≥${min}`,
+  );
+  lines.push("CAVEAT: co-occurrence, not causation. Worst-first. ⚠ = below baseline with n≥min.");
+  lines.push("");
+  const head =
+    pad("skill", 44) + padL("n", 5) + padL("pos", 6) + padL("neg", 6) +
+    padL("share", 8) + padL("lift", 8) + padL("wLB", 7) + padL("sevNeg", 8) +
+    "  " + pad("topNeg", 18) + "flag";
+  lines.push(head);
+  lines.push("-".repeat(head.length));
+  for (const s of skills) {
+    const below = s.lift < 0 && !s.lowSample;
+    const flag = below ? "⚠" : s.lowSample ? "·(low n)" : "";
+    lines.push(
+      pad(s.skill, 44) +
+        padL(s.n, 5) +
+        padL(s.pos, 6) +
+        padL(s.neg, 6) +
+        padL((s.share * 100).toFixed(0) + "%", 8) +
+        padL((s.lift >= 0 ? "+" : "") + (s.lift * 100).toFixed(0) + "%", 8) +
+        padL(s.wLB.toFixed(2), 7) +
+        padL(s.sevNeg, 8) +
+        "  " +
+        pad(s.topNeg || "-", 18) +
+        flag,
+    );
+  }
+  return lines.join("\n");
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(
+      "usage: adam-skill-utility.mjs [--home <path>] [--input <jsonl-path>] " +
+        "[--min <n>] [--days <n>] [--json]\n",
+    );
+    process.exit(0);
+  }
+  try {
+    let entries = gatherInputEntries(args);
+    entries = filterByDays(entries, args.days);
+    const report = computeSkillUtility(entries, { min: args.min });
+    if (args.json) {
+      process.stdout.write(JSON.stringify(report) + "\n");
+    } else {
+      process.stdout.write(renderText(report) + "\n");
+    }
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`adam-skill-utility error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+// adam-upgrade.mjs — review/accept pending `.adam-new` files from install.sh.
+//
+// install.sh writes <file>.adam-new next to user-modified ADAM files instead
+// of clobbering. This tool surfaces those pending merges and lets users
+// review the diff + accept atomically.
+//
+// CLI:
+//   adam-upgrade.mjs --list [--home <path>]
+//   adam-upgrade.mjs --diff [<path>] [--home <path>]
+//   adam-upgrade.mjs --accept <path> [--home <path>]
+//   adam-upgrade.mjs --accept-all [--home <path>]
+//   adam-upgrade.mjs --help
+
+import {
+  readdirSync,
+  statSync,
+  existsSync,
+  renameSync,
+  readFileSync,
+  unlinkSync,
+} from "node:fs";
+import { join, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+
+const EXCLUDE_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "journal",
+  "trash",
+  "proposals",
+  "applied",
+  "rejected",
+]);
+
+// Walk a directory tree, collecting paths to files ending in `.adam-new`.
+// Excludes the dirs above defensively (no point in surfacing journal entries).
+export function findPending(home) {
+  const root = home;
+  const out = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (EXCLUDE_DIRS.has(e.name)) continue;
+        walk(full);
+      } else if (e.isFile() && e.name.endsWith(".adam-new")) {
+        out.push(full);
+      }
+    }
+  }
+  walk(root);
+  return out.sort();
+}
+
+function fileSize(p) {
+  try { return statSync(p).size; } catch { return 0; }
+}
+
+function fileAgeDays(p) {
+  try {
+    const mtime = statSync(p).mtimeMs;
+    return Math.floor((Date.now() - mtime) / 86400000);
+  } catch { return 0; }
+}
+
+// Produce a unified diff between two files. Prefer the system `diff -u` binary
+// (universally available, accurate). On systems without `diff`, fall back to a
+// naive line-by-line diff prefixed with MISSING:/NEW: so the tool still works.
+export function diffPaths(orig, neu) {
+  const r = spawnSync("diff", ["-u", orig, neu], { encoding: "utf8" });
+  if (r.error || r.status === null || r.status === 2) {
+    // diff binary missing or fatal error — naive fallback
+    let a = [], b = [];
+    try { a = readFileSync(orig, "utf8").split("\n"); } catch {}
+    try { b = readFileSync(neu, "utf8").split("\n"); } catch {}
+    const max = Math.max(a.length, b.length);
+    const lines = [];
+    for (let i = 0; i < max; i++) {
+      const la = a[i], lb = b[i];
+      if (la === lb) continue;
+      if (la !== undefined) lines.push(`MISSING: ${la}`);
+      if (lb !== undefined) lines.push(`NEW: ${lb}`);
+    }
+    return lines.join("\n");
+  }
+  return r.stdout || "";
+}
+
+// Atomic swap: rename orig → orig.adam-prev, rename neu → orig. Overwrites any
+// prior .adam-prev backup (safe: a previous accept already promoted it).
+export function acceptOne(orig, neu) {
+  if (!existsSync(neu)) {
+    throw new Error(`missing pending file: ${neu}`);
+  }
+  const prev = `${orig}.adam-prev`;
+  if (existsSync(orig)) {
+    if (existsSync(prev)) {
+      try { unlinkSync(prev); } catch {}
+    }
+    renameSync(orig, prev);
+  }
+  renameSync(neu, orig);
+  return { orig, prev };
+}
+
+export function acceptAll(home) {
+  const pending = findPending(home);
+  const results = [];
+  for (const neu of pending) {
+    const orig = neu.replace(/\.adam-new$/, "");
+    try {
+      const r = acceptOne(orig, neu);
+      results.push({ ok: true, ...r });
+    } catch (err) {
+      results.push({ ok: false, orig, error: String(err && err.message || err) });
+    }
+  }
+  return results;
+}
+
+function parseArgs(argv) {
+  const args = { cmd: null, target: null, home: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--list") args.cmd = "list";
+    else if (a === "--diff") args.cmd = "diff";
+    else if (a === "--accept") args.cmd = "accept";
+    else if (a === "--accept-all") args.cmd = "accept-all";
+    else if (a === "--help" || a === "-h") args.cmd = "help";
+    else if (a === "--home" && i + 1 < argv.length) args.home = argv[++i];
+    else if (!a.startsWith("--") && args.target == null) args.target = a;
+  }
+  return args;
+}
+
+function usage() {
+  process.stdout.write(
+    "adam-upgrade — review pending `.adam-new` files from install.sh\n" +
+    "\n" +
+    "Usage:\n" +
+    "  adam-upgrade.mjs --list [--home <path>]\n" +
+    "  adam-upgrade.mjs --diff [<path>] [--home <path>]\n" +
+    "  adam-upgrade.mjs --accept <path> [--home <path>]\n" +
+    "  adam-upgrade.mjs --accept-all [--home <path>]\n" +
+    "  adam-upgrade.mjs --help\n"
+  );
+}
+
+function resolveHome(args) {
+  if (args.home) return args.home;
+  return join(process.env.HOME || homedir(), ".claude");
+}
+
+function cmdList(args) {
+  const home = resolveHome(args);
+  const pending = findPending(home);
+  for (const neu of pending) {
+    const orig = neu.replace(/\.adam-new$/, "");
+    const origSize = fileSize(orig);
+    const newSize = fileSize(neu);
+    const age = fileAgeDays(neu);
+    process.stdout.write(`${neu}  (orig: ${origSize}, new: ${newSize}, age: ${age}d)\n`);
+  }
+  process.stderr.write(`${pending.length} pending\n`);
+  return 0;
+}
+
+function cmdDiff(args) {
+  const home = resolveHome(args);
+  let targets;
+  if (args.target) {
+    // Allow either passing the orig path or the .adam-new path.
+    const t = args.target;
+    const orig = t.endsWith(".adam-new") ? t.replace(/\.adam-new$/, "") : t;
+    targets = [orig];
+  } else {
+    targets = findPending(home).map((n) => n.replace(/\.adam-new$/, ""));
+  }
+  for (const orig of targets) {
+    const neu = `${orig}.adam-new`;
+    process.stdout.write(`=== ${orig} ===\n`);
+    if (!existsSync(neu)) {
+      process.stderr.write(`no pending: ${neu}\n`);
+      continue;
+    }
+    process.stdout.write(diffPaths(orig, neu));
+    process.stdout.write("\n");
+  }
+  return 0;
+}
+
+function cmdAccept(args) {
+  if (!args.target) {
+    process.stderr.write("error: --accept requires a <path>\n");
+    return 1;
+  }
+  const t = args.target;
+  const orig = t.endsWith(".adam-new") ? t.replace(/\.adam-new$/, "") : t;
+  const neu = `${orig}.adam-new`;
+  try {
+    const r = acceptOne(orig, neu);
+    process.stdout.write(`accepted: ${r.orig} (backup: ${r.prev})\n`);
+    return 0;
+  } catch (err) {
+    process.stderr.write(`error: ${err.message}\n`);
+    return 1;
+  }
+}
+
+function cmdAcceptAll(args) {
+  const home = resolveHome(args);
+  const results = acceptAll(home);
+  for (const r of results) {
+    if (r.ok) {
+      process.stdout.write(`accepted: ${r.orig} (backup: ${r.prev})\n`);
+    } else {
+      process.stderr.write(`error: ${r.orig}: ${r.error}\n`);
+    }
+  }
+  return 0;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.cmd || args.cmd === "help") { usage(); return 0; }
+  if (args.cmd === "list") return cmdList(args);
+  if (args.cmd === "diff") return cmdDiff(args);
+  if (args.cmd === "accept") return cmdAccept(args);
+  if (args.cmd === "accept-all") return cmdAcceptAll(args);
+  usage();
+  return 1;
+}
+
+// Only run main() when invoked as a script (not when imported for tests).
+const invokedAsScript = (() => {
+  try {
+    const argv1 = process.argv[1] || "";
+    return argv1.endsWith("adam-upgrade.mjs");
+  } catch { return true; }
+})();
+if (invokedAsScript) {
+  process.exit(main());
+}
@@ -0,0 +1,92 @@
+// adam-utils.mjs — shared helpers used across adam-* scripts.
+//
+// Pure library: no shebang, not a CLI. Imported by adam-window.mjs,
+// adam-score.mjs, adam-ab-measure.mjs, adam-nudge-eligibility.mjs (jsonl
+// helpers) and adam-apply-reinforcement.mjs, adam-archive.mjs,
+// adam-cooldown.mjs (parseFrontmatter).
+//
+// All helpers swallow read/parse failures by design — callers expect to keep
+// going on a corrupt line/file rather than abort the whole pipeline.
+
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+// listJsonlFiles: list *.jsonl files in `dir`. Missing dir or read failure
+// returns []. Filenames are joined with `dir` so callers can read directly.
+export function listJsonlFiles(dir) {
+  if (!existsSync(dir)) return [];
+  try {
+    return readdirSync(dir)
+      .filter((n) => n.endsWith(".jsonl"))
+      .map((n) => join(dir, n));
+  } catch { return []; }
+}
+
+// readJsonlSafe: read a .jsonl file and return an array of parsed objects.
+// Missing file, unreadable file, or any malformed line are silently skipped.
+export function readJsonlSafe(path) {
+  if (!existsSync(path)) return [];
+  let buf;
+  try { buf = readFileSync(path, "utf8"); } catch { return []; }
+  const out = [];
+  for (const line of buf.split("\n")) {
+    if (!line) continue;
+    try { out.push(JSON.parse(line)); } catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+// parseFrontmatter: parse a markdown YAML-ish frontmatter block into a flat
+// object. Supports:
+//   - inline scalars         key: value
+//   - inline arrays          key: [a, b, c]
+//   - block-form arrays      key:\n  - a\n  - b
+// Quotes around scalar values are stripped. Comment-only lines (`# ...`) and
+// keys with empty inline values that are NOT followed by a block array are
+// skipped (preserves prior cooldown.mjs behavior). Missing frontmatter → {}.
+export function parseFrontmatter(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return {};
+  const out = {};
+  const lines = m[1].split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const idx = line.indexOf(":");
+    if (idx === -1) { i++; continue; }
+    const key = line.slice(0, idx).trim();
+    if (!key || key.startsWith("#")) { i++; continue; }
+    const rawValue = line.slice(idx + 1).trim();
+    if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+      const inner = rawValue.slice(1, -1)
+        .split(",")
+        .map((s) => s.trim().replace(/^['"]|['"]$/g, ""))
+        .filter(Boolean);
+      out[key] = inner;
+      i++;
+      continue;
+    }
+    if (!rawValue) {
+      // Possible block-form array: look ahead for `  - item` lines.
+      const arr = [];
+      let j = i + 1;
+      while (j < lines.length && /^\s*-\s+/.test(lines[j])) {
+        const item = lines[j].replace(/^\s*-\s+/, "").trim().replace(/^['"]|['"]$/g, "");
+        if (item) arr.push(item);
+        j++;
+      }
+      if (arr.length) {
+        out[key] = arr;
+        i = j;
+        continue;
+      }
+      // Empty value, no block follow-up: skip (cooldown/apply-reinforcement
+      // expectation — empty scalars are noise).
+      i++;
+      continue;
+    }
+    out[key] = rawValue.replace(/^['"]|['"]$/g, "");
+    i++;
+  }
+  return out;
+}
@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+// adam-window.mjs — per-signal sliding-window filter over the ADAM journal.
+//
+// Reads all journal sources (active journal.jsonl + rotated journal/*.jsonl,
+// including both new YYYY-Www.jsonl format and legacy YYYY-MM-DD-<ts>.jsonl
+// size-rotated files), applies a per-signal-type age cutoff based on each
+// entry's `ts` field, and emits the filtered JSONL stream to stdout.
+//
+// Exclusion: entries whose `ts` appears in any applied/*.md or rejected/*.md
+// proposal frontmatter `source_entries` array are dropped (same semantics the
+// adam agent previously enforced manually). Keeps actioned signals out of the
+// next /reflect even if they're inside the analysis window.
+//
+// Usage: adam-window.mjs [--home <path>]   default: $HOME/.claude
+// Output: filtered JSONL on stdout. One-line summary on stderr.
+
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readJsonlSafe, listJsonlFiles } from "./adam-utils.mjs";
+
+// Per-signal sliding window in days. Source of truth — referenced by agents/adam.md.
+export const SIGNAL_WINDOWS_DAYS = {
+  dead_end: 7,
+  correction: 30,
+  tool_error_loop: 30,
+  edit_churn: 14,
+  retry_loop: 14,
+  build_loop: 30,
+  weak_agent: 30,
+  subagent_dispatch_pattern: 30,
+  silent_drift: 14,
+  file_reread: 14,
+  error_after_recovery: 30,
+  correction_free_streak: 60,
+  clean_recovery: 60,
+  task_completed: 60,
+};
+
+// Fallback window for unknown / future signal types.
+export const DEFAULT_WINDOW_DAYS = 30;
+
+const DAY_MS = 86400000;
+
+function parseArgs(argv) {
+  const args = { home: null };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--home" && i + 1 < argv.length) {
+      args.home = argv[++i];
+    }
+  }
+  return args;
+}
+
+// Crude single-pass frontmatter source_entries extractor. Mirrors adam-archive.mjs
+// parsing: handles both YAML block form and inline-array form. Only pulls the
+// `source_entries` key — we don't need anything else for exclusion.
+function extractSourceEntries(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return [];
+  const lines = m[1].split("\n");
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    if (key !== "source_entries") continue;
+    const value = line.slice(idx + 1).trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      const inner = value.slice(1, -1).split(",")
+        .map((s) => s.trim().replace(/^['"]|['"]$/g, ""))
+        .filter(Boolean);
+      out.push(...inner);
+      continue;
+    }
+    let j = i + 1;
+    while (j < lines.length && /^\s*-\s+/.test(lines[j])) {
+      const item = lines[j].replace(/^\s*-\s+/, "").trim().replace(/^['"]|['"]$/g, "");
+      if (item) out.push(item);
+      j++;
+    }
+  }
+  return out;
+}
+
+function buildExclusionSet(...dirs) {
+  const set = new Set();
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    let names;
+    try { names = readdirSync(dir); } catch { continue; }
+    for (const name of names) {
+      if (!name.endsWith(".md")) continue;
+      const p = join(dir, name);
+      try {
+        const content = readFileSync(p, "utf8");
+        for (const ts of extractSourceEntries(content)) set.add(ts);
+      } catch { /* skip */ }
+    }
+  }
+  return set;
+}
+
+function windowDaysFor(type) {
+  if (Object.prototype.hasOwnProperty.call(SIGNAL_WINDOWS_DAYS, type)) {
+    return SIGNAL_WINDOWS_DAYS[type];
+  }
+  return DEFAULT_WINDOW_DAYS;
+}
+
+export function filterEntries(entries, exclusionSet, now = new Date()) {
+  const nowMs = now.getTime();
+  const dropped = { stale: {}, excluded: 0, no_ts: 0 };
+  const kept = [];
+  for (const e of entries) {
+    if (!e || typeof e !== "object") continue;
+    if (!e.ts || typeof e.ts !== "string") {
+      dropped.no_ts++;
+      continue;
+    }
+    if (exclusionSet.has(e.ts)) {
+      dropped.excluded++;
+      continue;
+    }
+    const type = e.type || "unknown";
+    const days = windowDaysFor(type);
+    const tsMs = Date.parse(e.ts);
+    if (Number.isNaN(tsMs)) {
+      dropped.no_ts++;
+      continue;
+    }
+    if (nowMs - tsMs > days * DAY_MS) {
+      dropped.stale[type] = (dropped.stale[type] || 0) + 1;
+      continue;
+    }
+    kept.push(e);
+  }
+  return { kept, dropped };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const claudeHome = args.home || join(homedir(), ".claude");
+  const adamRoot = join(claudeHome, "adam");
+  const activeJournal = join(adamRoot, "journal.jsonl");
+  const journalDir = join(adamRoot, "journal");
+  const appliedDir = join(adamRoot, "applied");
+  const rejectedDir = join(adamRoot, "rejected");
+
+  const sources = [activeJournal, ...listJsonlFiles(journalDir)];
+  const all = [];
+  for (const p of sources) {
+    for (const e of readJsonlSafe(p)) all.push(e);
+  }
+
+  const exclusion = buildExclusionSet(appliedDir, rejectedDir);
+  const { kept, dropped } = filterEntries(all, exclusion);
+
+  // Stable output: sort by ts ascending so downstream clustering sees chronological order.
+  kept.sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0));
+
+  const out = kept.map((e) => JSON.stringify(e)).join("\n");
+  if (out) process.stdout.write(out + "\n");
+
+  const staleParts = Object.entries(dropped.stale).map(([t, n]) => `${t}=${n}`).join(",") || "none";
+  process.stderr.write(
+    `windowed: ${all.length} in, ${kept.length} out (stale: ${staleParts}; excluded: ${dropped.excluded}; no_ts: ${dropped.no_ts})\n`
+  );
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  try { main(); } catch (e) {
+    process.stderr.write(`adam-window error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
@@ -1,6 +1,6 @@
 ---
 name: adam
-description: Self-improvement analyst. Reads adam journal + transcript context, clusters observations, scores against a deterministic rubric, and emits proposal files for new skills, memory entries, agent edits, hook changes, CLAUDE.md edits, and soft deletions. Invoked only via the adam-self-improvement skill.
+description: "Self-improvement analyst. Reads the adam journal and transcript context, clusters observations, scores them against a deterministic rubric, and writes proposal files for new skills, memory entries, agent edits, hook changes, CLAUDE.md edits and soft deletions. Invoked only via the adam-self-improvement skill (/reflect). Not for: editing skills, agents or memory directly (the main thread applies approved proposals), or reviewing code (use code-reviewer)."
 tools: Read, Write, Edit, Grep, Glob, Bash
 ---

@@ -8,6 +8,73 @@ tools: Read, Write, Edit, Grep, Glob, Bash

 You analyse Claude Code's own behaviour to propose targeted, surgical improvements. You operate offline (no LLM round-trips outside this run) and produce **files**, not actions. Main-thread Claude reviews and applies changes with the user.

+## Stage mode
+
+The skill dispatches you in one of two stages (MOSS-inspired multi-stage pipeline — §3.3: "a single prompt asked to diagnose, plan, implement, verify, and decide overloads context and produces lower-quality output than a sequenced flow"):
+
+- **`stage=diagnose`**: Read batched journal entries, cluster, diagnose root causes, plan fix types. Output diagnoses JSON to `/tmp/adam-diagnoses.json`. Do NOT draft proposals.
+- **`stage=implement`**: Read approved diagnoses from `/tmp/adam-diagnoses.json`. Draft full proposal files to `proposals_dir/`. Emit the clustering trace and punch list.
+
+If no `stage` is specified in the dispatch prompt, run **both stages sequentially** within a single pass (backward-compatible with pre-MOSS flow).
+
+**Adaptive re-diagnose** (ReContext P5 — depth is task-dependent, not uniformly larger): a `stage=diagnose` dispatch may carry `redigest: <cluster_id[,…]>` and `prior_diagnoses_path`. When it does, re-diagnose ONLY those clusters: re-read each cluster's `context_window` (and up to ~30 extra transcript messages) *conditioned on the prior diagnosis*, and overwrite the trigger/action/mismatch/outcome for those `cluster_id`s in `/tmp/adam-diagnoses.json`. This is how an ambiguous cluster earns a second, deeper pass while clear clusters stay at one. Never re-diagnose a cluster more than once per `/reflect`.
+
+### Diagnose-stage output format
+
+When `stage=diagnose`, write `/tmp/adam-diagnoses.json` containing:
+
+```json
+{
+  "diagnoses": [
+    {
+      "cluster_id": "c1",
+      "signal_type": "correction",
+      "cluster_key": "wrong|approach",
+      "count": 5,
+      "sessions": 3,
+      "diagnosis": {
+        "trigger": "...",
+        "action": "...",
+        "mismatch": "...",
+        "outcome": "... `verbatim quote` ..."
+      },
+      "plan": {
+        "type": "memory",
+        "target": "~/.claude/projects/-Users-nvm/memory/go-test-cache.md",
+        "scope": "add feedback memory about go test -count=1"
+      },
+      "keypoints": {
+        "tool_selection": 1,
+        "scope_discipline": 2,
+        "error_recovery": 0,
+        "first_attempt": 0,
+        "build_reliability": 1
+      },
+      "gates": {
+        "threshold": "pass",
+        "cross_session": "pass",
+        "window": "in:5/out:0",
+        "contradiction": "none"
+      },
+      "source_entries": ["2026-05-20T10:00:00Z", "2026-05-21T11:00:00Z"],
+      "context_evidence": ["... excerpts from context_window ..."]
+    }
+  ],
+  "skipped": [
+    {"cluster_id": "c3", "signal_type": "retry_loop", "reason": "threshold", "count": 2}
+  ],
+  "summary": "considered=4 diagnosed=2 skipped=2"
+}
+```
+
+The skill validates diagnoses between stages (see SKILL.md §2 "Inter-stage validation").
+
+## Context window evidence
+
+Journal entries for struggle signals now carry a `context_window` field — an array of the last 8 events (user prompts, tool calls, responses) surrounding the friction point. This is the ADAM equivalent of MOSS's "original transcript captured by auto-scan at evidence time" (§3.4).
+
+When drafting diagnoses, **prefer `context_window` evidence over transcript file lookups** when it is present. The `context_window` is already scoped to the friction point and more reliable than file-based transcript pulls. Fall back to `transcripts_root` only when `context_window` is absent (pre-upgrade entries).
+
 ## Karpathy constraints (mandatory)

 You MUST obey these on every proposal:
@@ -20,7 +87,33 @@ You MUST obey these on every proposal:

 ## Inputs

-Paths arrive via the dispatch prompt — see `~/.claude/skills/adam-self-improvement/SKILL.md` §1.
+Paths arrive via the dispatch prompt — see `~/.claude/skills/adam-self-improvement/SKILL.md` §2.
+
+## Analysis window
+
+The journal you receive is **pre-filtered** by `~/.claude/adam/scripts/adam-window.mjs` before this agent runs. You do NOT apply window math yourself — every entry in the input stream is already within its signal type's freshness window. The same script also drops entries whose `ts` already appears in `applied/*.md` or `rejected/*.md` frontmatter `source_entries`, so the manual excluded-timestamps computation in the Process section below becomes a no-op when the pre-filter is healthy (still keep the logic — it's the fallback if the pre-filter is bypassed).
+
+Per-signal windows (single source of truth: `SIGNAL_WINDOWS_DAYS` in `~/.claude/adam/scripts/adam-window.mjs`):
+
+| signal | window | rationale |
+|---|---|---|
+| `dead_end` | 7 d | autonomy friction — fix-or-forget fast |
+| `correction` | 30 d | user phrasing patterns drift slowly |
+| `tool_error_loop` | 30 d | error fingerprints stable across days |
+| `edit_churn` | 14 d | per-file churn is task-local |
+| `retry_loop` | 14 d | tool-arg retries are task-local |
+| `build_loop` | 30 d | build/test failure patterns |
+| `weak_agent` | 30 d | subagent quality signal |
+| `subagent_dispatch_pattern` | 30 d | dispatch routing pattern |
+| `silent_drift` | 14 d | exploration-without-action is task-local |
+| `file_reread` | 14 d | redundant same-file reads are task-local |
+| `error_after_recovery` | 30 d | recovery-then-same-error patterns persist |
+| `correction_free_streak` | 60 d | wins accumulate slowly |
+| `clean_recovery` | 60 d | wins accumulate slowly |
+| `task_completed` | 60 d | recipe wins accumulate slowly |
+| (unknown / new types) | 30 d | `DEFAULT_WINDOW_DAYS` fallback |
+
+Cross-session evidence gate: "≥3 occurrences across ≥2 sessions" is now scoped — it means **≥3 occurrences across ≥2 sessions WITHIN the signal's analysis window**. Entries that fall outside the window are not visible to clustering or scoring at all.

 ## Signal types

@@ -36,8 +129,12 @@ The hook emits these `type` values into the journal:
 | `edit_churn` | same file edited 4× in window | file basename |
 | `build_loop` | 2 build/test/compile commands fail in session | session |
 | `subagent_dispatch_pattern` | same subagent dispatched ≥3× cumulatively | subagent_type |
+| `silent_drift` | 5 consecutive read-only PostToolUse without an action tool (reset on action or UserPromptSubmit) | `active_skills[0]` |
+| `file_reread` | same file Read ≥3× in the 10-tool window, ignoring offset/limit (escapes `retry_loop`'s argsHash dedup) | file basename |
+| `error_after_recovery` | same error fingerprint returns within 5 PostToolUse of a `clean_recovery` | (`recovered_from`, `original_fp`) |
 | `correction_free_streak` | 5 clean UserPromptSubmits in a row (no correction phrase) | `active_skills[0]` |
 | `clean_recovery` | 3 clean PostToolUse events after a `tool_error_loop`/`dead_end`/`retry_loop` | (`recovered_from`, `active_skills[0]`) |
+| `task_completed` | UserPromptSubmit closes a run of ≥5 tool calls with ≥3 distinct tool kinds and 0 corrections | sorted `tool_kinds` tuple |

 ## Process

@@ -60,9 +157,20 @@ The hook emits these `type` values into the journal:
   - `edit_churn`: cluster by file basename pattern (e.g. `*.test.ts`).
   - `build_loop`: cluster by `session`.
   - `subagent_dispatch_pattern`: cluster by `subagent_type`.
+   - `silent_drift`: cluster by `active_skills[0]` (empty string when no skill is active).
+   - `file_reread`: cluster by file basename (same offset-agnostic same-file re-Read pattern).
+   - `error_after_recovery`: cluster by (`recovered_from`, `original_fp`).
   - `correction_free_streak`: cluster by `active_skills[0]`. Treat ≥3 streaks across ≥2 sessions naming the same skill as cross-session evidence.
   - `clean_recovery`: cluster by (`recovered_from`, `active_skills[0]`). A win cluster qualifies for `skill_edit` only when the named skill exists in `skills_root`.
-5. **Multi-axis correlation**: for each session that produced ≥2 distinct struggle types (`tool_error_loop`, `dead_end`, `weak_agent`, `retry_loop`, `edit_churn`, `build_loop`), tag clusters from that session as `multi_axis: true`. This grants +1 confidence at scoring.
+   - `task_completed`: cluster by sorted `tool_kinds` tuple (the multi-tool recipe). Single entry qualifies for `skill_new` proposal (drafting protocol applies). Cross-session evidence requires ≥2 entries from distinct sessions with same tuple — without it, proposal queues, never auto-applies. Run the existing skill-overlap rule before drafting: if the recipe matches an existing skill's name/description tokens, route to `skill_edit` instead.
+4b. **Cross-type associative pass** (ReContext P5 — surface evidence related to already-selected spans): after primary clustering, for each cluster gather active observations from *other* signal types that share the cluster's `session` or file basename (e.g. a `dead_end` and the `edit_churn` on the same file/session that led to it). Attach them to the cluster as `associated_entries` — do NOT merge cluster keys or re-count them for the rubric — so the diagnosis can reconstruct causation across signal types instead of from one isolated type. Cap at ~8 associated entries per cluster, nearest-in-time first.
+5. **Multi-axis correlation**: for each session that produced ≥2 distinct struggle types (`tool_error_loop`, `dead_end`, `weak_agent`, `retry_loop`, `edit_churn`, `build_loop`, `silent_drift`, `file_reread`, `error_after_recovery`), tag clusters from that session as `multi_axis: true`. This grants +1 confidence at scoring.
+
+5b. **Skill-attribution sub-clustering**: after primary clustering (step 4), for every struggle cluster (`tool_error_loop`, `dead_end`, `weak_agent`, `retry_loop`, `edit_churn`, `build_loop`, `silent_drift`, `file_reread`, `error_after_recovery`) that contains entries with non-empty `active_skills[0]`:
+   - Split into per-skill sub-clusters keyed on `active_skills[0]`. Entries with empty `active_skills` stay in the original cluster.
+   - If a sub-cluster has ≥3 entries AND names a skill that exists in `skills_root`, mark it as a candidate for `skill_edit` (struggle-driven variant; see "Struggle-driven `skill_edit` eligibility"). Otherwise treat the parent cluster normally.
+   - The umbrella cluster (cross-skill) still emits its usual proposal type (memory, etc.) — sub-clusters do NOT replace it, they supplement it.
+   - **Utility cross-check**: for every `skill_edit`/`skill_new` candidate, look up the named skill in `skill_utility_path` (the pre-computed `adam-skill-utility.mjs --json` report). If the skill is reliably below baseline (negative `lift` + worst-tier `wLB` at ≥ its `--min` events), apply the utility-lift penalty (see rubric) — do NOT pile more text onto a skill that already correlates with friction; prefer a `memory` or a scoped new skill instead.
 6. For each cluster qualifying under the rubric — ≥3 occurrences across ≥2 sessions, OR (for struggle types) ≥1 entry within a single session, OR (for `correction`) ≥3 occurrences across ≥2 cwds:
   a. If cluster topic matches a rejected idea via the rejected-ideas fuzzy set (≥2 token overlap with rejection's `# Why`), skip with reason `"rejected-similar"`.
   b. Pull ~20 messages of transcript context from `transcripts_root` to enrich. Never read full transcripts.
@@ -146,10 +254,12 @@ Required structure:

 ```markdown
 ---
-name: <human-readable name, ≤80 chars>
-description: <one-line description used to decide future relevance — be specific, ≤200 chars>
-type: user | feedback | project | reference
-originSessionId: <session_id from journal entries that fed this cluster>
+name: <slug — snake_case, MUST equal the target filename without `.md`, e.g. feedback_go_test_cache>
+description: "<one-line used to decide future relevance — be specific, ≤200 chars>"
+metadata:
+  node_type: memory
+  type: user | feedback | project | reference
+  originSessionId: <session_id from journal entries that fed this cluster>
 ---

 <Body content per type, see CLAUDE.md memory schema:
@@ -159,12 +269,17 @@ originSessionId: <session_id from journal entries that fed this cluster>
  - reference: pointer to external system + what's there.>
 ```

+The frontmatter MUST match the live auto-memory schema exactly: `name` is the
+slug (NOT a prose title), and `node_type`, `type`, `originSessionId` live under
+a `metadata:` block (verify against an existing file in the target memory dir
+before drafting — match its shape).
+
 Constraints:
- Frontmatter fields `name`, `description`, `type` are **required**. Skill enforces this at apply time.
- `originSessionId` is required — must be a `session` value from one of the cluster's journal entries.
+- Top-level `name` + `description` and nested `metadata.node_type` (always `memory`) + `metadata.type` are **required**. Skill enforces this at apply time.
+- `metadata.originSessionId` is required — must be a `session` value from one of the cluster's journal entries.
 - ≤50 LOC of body content. Surgical.
- Slug (used in `target` path filename) must not collide with any existing memory file.
- For `type=feedback` and `type=project`, body MUST contain `**Why:**` and `**How to apply:**` lines (CLAUDE.md memory schema).
+- `name`/slug (also the `target` path filename) must not collide with any existing memory file.
+- For `type: feedback` and `type: project`, body MUST contain `**Why:**` and `**How to apply:**` lines (CLAUDE.md memory schema).

 ## Diagnosis drafting protocol (required for every proposal)

@@ -229,14 +344,109 @@ A `skill_edit` proposal sets `auto_apply_eligible: true` ONLY when ALL hold:

 If any of (3)–(9) fails: still emit the proposal, but `auto_apply_eligible: false` — main thread queues for review.

+## Struggle-driven `skill_edit` eligibility
+
+Skill-attribution sub-clustering (step 5b) produces struggle-driven `skill_edit` candidates: a sub-cluster of ≥3 struggle entries all naming the same `active_skills[0]` that exists in `skills_root`. These proposals are emitted but **ALWAYS queue** — `auto_apply_eligible: false` regardless of confidence. Negative evidence on a skill is a weaker basis for self-modification than positive evidence (the skill may be active during friction caused by something else), so the human reviews every one.
+
+A struggle-driven `skill_edit` proposal MUST:
+
+1. Set `target` to the matched skill's `SKILL.md` path.
+2. Cluster severity-sum ≥ 10 (same threshold as the +1 rubric bullet).
+3. Sub-cluster names exactly one skill (no ambiguity across distinct `active_skills[0]` values).
+4. `# Proposed change` is an append-only diff adding a `## When struggling` section (naive default body: a checkpoint-or-pause rule appropriate to the dominant signal — e.g. `dead_end` → "After 16 PostToolUse events without UserPromptSubmit, emit a one-line checkpoint summary before continuing.").
+5. Frontmatter includes `struggle_evidence: "<ts of one source entry naming this skill>"` and `struggle_signals: [<list of signal types in the sub-cluster>]`. The win-driven `win_evidence` field is omitted.
+6. Subject to the same Per-(skill, fingerprint) cooldown as win-driven `skill_edit`.
+
+If gate (2) or (3) fails: skip the sub-cluster (the parent cluster still produces its umbrella proposal). The sub-cluster's `source_entries` overlap with the parent's — the apply pipeline handles dedup via the excluded-timestamps set.
+
+## Per-(skill, fingerprint) cooldown
+
+The cooldown gate is keyed on **(target_skill, proposal_fingerprint)** — not on target_skill alone. A rejected/applied proposal for skill `X` with fingerprint `A` does NOT block future proposals for skill `X` with fingerprint `B`.
+
+`proposal_fingerprint` is computed deterministically as `djb2(skill_slug + "\n" + signal_cluster_id + "\n" + normalized_diff_body)` returned as base36, where:
+
+- `skill_slug` — target skill basename (or proposed slug for `skill_new`)
+- `signal_cluster_id` — a **stable** cluster id derived from signal type + key (e.g. `tool_error_loop-ECONNREFUSED:5432`), NOT the ephemeral per-run trace id (`c1`). Stability matters: the same logical proposal must hash identically across `/reflect` runs or the cooldown can never match a prior applied/rejected record.
+- `normalized_diff_body` — proposal's `# Proposed change` section with all whitespace collapsed to single spaces and trimmed
+
+Do NOT hand-compute the hash (an LLM cannot reproduce djb2 reliably). Run the canonical implementation (`computeProposalFingerprint()` in `adam-cooldown.mjs`) via Bash, then write the result into frontmatter:
+
+```bash
+node ~/.claude/adam/scripts/adam-cooldown.mjs --compute \
+  --skill <slug> --cluster <signal_cluster_id> --diff-file <file-with-Proposed-change-body>
+# → {"fingerprint":"<djb2_base36>"}   (diff body may also be piped on stdin)
+```
+
+Both apply-time and analyst-time *gate* checks then invoke `adam-cooldown.mjs --skill <slug> --fingerprint <hash>`. The script returns one of `{"status":"cool"}`, `{"status":"cooldown",...}`, or `{"status":"blacklisted",...}`. Auto-apply requires `cool`.
+
+Backward compat: proposals from before this rubric version (no `proposal_fingerprint` field) are treated as `fingerprint = "legacy"`. The cooldown script matches legacy applied/rejected records against any query fingerprint for the same skill — i.e. coarse-grained gating until those records age out of their windows (7d / 30d).
+
+## Scoring: task_completed dampener
+
+Before scoring each cluster's confidence, multiply the cluster's urgency score by the `dampener` value reported by `adam-score.mjs` for the session the cluster originated from:
+
+- `task_completed_count >= 3` in that session → dampener `0.5`
+- `task_completed_count >= 1` in that session → dampener `0.75`
+- otherwise → dampener `1.0`
+
+Rationale: sessions that successfully closed several multi-tool tasks alongside the friction signal are noisier proposal sources than sessions that produced only friction. The dampener does not zero out signals; it down-weights urgency so cross-session friction beats single-session friction-with-recoveries.
+
+The skill (`adam-self-improvement/SKILL.md` §1) runs `adam-score.mjs` immediately after `adam-window.mjs` and passes both outputs into the analyst's dispatch prompt.
+
+## A/B effectiveness
+
+Every auto-applied edit (`skill_edit`, `skill_new`, `memory`, `nudge`) gets a one-line tracking entry written to `~/.claude/adam/ab-tracking.jsonl` by `adam-self-improvement/apply-by-type.md` (loaded from SKILL.md) immediately after the proposal is moved to `applied/`. **`reinforcement` is the one exception — it is a positive-only ledger and is intentionally NOT A/B-tracked (see §"`reinforcement` proposals"), to avoid skewing regression detection.** Schema:
+
+```json
+{"applied_at":<ms>,"proposal_id":"<id>","proposal_type":"...","target_skill":"<slug>","proposal_fingerprint":"<hash>","originating_signals":[{"type":"<signal>","count":<N>,"session_ids":[...]}],"pre_window_days":7}
+```
+
+After ≥7 days, `~/.claude/adam/scripts/adam-ab-measure.mjs` reads each entry and compares signal counts in the 7-day window BEFORE `applied_at` against the 7-day window AFTER (raw journal counts — does NOT use `adam-window.mjs` filtering). Status assignment:
+
+- `delta_pct = (post - pre) / pre * 100`
+- `pre == 0` → `no_baseline` (cold start, no measurement possible)
+- `delta_pct <= -25` → `improved`
+- `-25 < delta_pct < 25` → `neutral`
+- `delta_pct >= 25` → `regressed`
+- entry younger than 7 days → `pending`
+
+The `/reflect` skill runs `adam-ab-measure.mjs --format json` before dispatching this agent, filters to `status == "regressed"`, and passes the list as `ab_regressions` (each object has `proposal_id`, `target_skill`, `proposal_type`, `delta_pct`, `pre_count`, `post_count`).
+
+**When `ab_regressions` is non-empty, you MUST emit a `## Regressions` section at the TOP of your output (above the proposals listing).** One bullet per regressed proposal listing `proposal_id`, `target_skill`, `delta_pct`. The skill auto-rolls back regressed proposals via `adam-rollback.mjs` before dispatching you — this section is your record of what was rolled back and why.
+
+The clustering trace summary (see §"Clustering trace") adds an extra `regressions=<N>` key alongside `considered/emitted/skipped`. When no `ab_regressions` arrive (or list is empty), emit `regressions=0`.
+
+## Keypoint matrix (MOSS §3.3/§4.2)
+
+When running in `stage=diagnose`, you MUST produce a **keypoint matrix** alongside each batch diagnosis. This structured evaluation replaces ad-hoc confidence with per-capability scoring.
+
+Capability dimensions (score each 0–2 per batch: 0=no signal, 1=partial, 2=strong evidence):
+
+| dimension | description | positive signals | negative signals |
+|---|---|---|---|
+| `tool_selection` | correct tool chosen first try | low `retry_loop` | high `retry_loop`, `weak_agent` |
+| `scope_discipline` | stays within requested scope | low `edit_churn`, low `dead_end` | high `edit_churn`, `dead_end`, `silent_drift` |
+| `error_recovery` | recovers from errors without user help | `clean_recovery` | `error_after_recovery`, `tool_error_loop` |
+| `first_attempt` | succeeds without corrections | `correction_free_streak` | `correction` |
+| `build_reliability` | builds/tests pass on first try | `task_completed` with build tools | `build_loop` |
+
+The matrix goes into the diagnosis output as `keypoints: {tool_selection: N, scope_discipline: N, ...}`. The implement stage uses it to:
+1. Prioritize proposals targeting the weakest dimensions.
+2. Include `keypoint_target: "<dimension>"` in proposal frontmatter.
+3. Track dimension trends across `/reflect` runs (persisted in `~/.claude/adam/keypoint-history.jsonl`).
+
 ## Confidence rubric (deterministic — do NOT vibe)

 Sum:
 - Signal repeated ≥3× across ≥2 sessions: **+2**
- Struggle signal (`tool_error_loop`, `dead_end`, `weak_agent`, `retry_loop`, `edit_churn`, `build_loop`) appearing ≥1× within a single session: **+2** *(each struggle entry already represents a hook-side threshold crossing — e.g. 8 tools without a prompt, 3 same-args retries, 4 edits to one file. Treat each entry as one piece of evidence. Does not stack with the cross-session bonus.)*
+- Struggle signal (`tool_error_loop`, `dead_end`, `weak_agent`, `retry_loop`, `edit_churn`, `build_loop`, `silent_drift`, `file_reread`, `error_after_recovery`) appearing ≥1× within a single session: **+2** *(each struggle entry already represents a hook-side threshold crossing — e.g. 8 tools without a prompt, 3 same-args retries, 4 edits to one file, 5 read-only tools in a row, same-fp error after a recovery. Treat each entry as one piece of evidence. Does not stack with the cross-session bonus.)*
 - Transcript contains positive endorsement (`yes`, `exactly`, `do that`, `keep doing`) within 2 messages of related action: **+2**
 - Multi-axis cluster (≥2 distinct struggle types in same session): **+1**
+- Cluster severity-sum ≥ 10 (severity per entry = `max(1, floor(count / divisor))` using `SEVERITY_DIVISORS` from `adam-score.mjs` — `dead_end:8, edit_churn:4, tool_error_loop:3, retry_loop:3, file_reread:3, weak_agent:2, build_loop:1`; entries without `count` count as 1): **+1**
+- Cluster severity-sum ≥ 32: **+1** *(additive — a severity-sum of 32 gets +1 from the previous bullet AND +1 here, total +2.)*
+- Skill-attributed sub-cluster (≥3 entries naming the same `active_skills[0]` that exists in `skills_root`): **+1**
 - Type-bias penalty from feedback loop (≥3 rejections, applied:rejected ratio <1:2 for this `type`): **-1**
+- Utility-lift penalty: proposal is a `skill_edit` (or a `skill_new` whose recipe duplicates an existing skill's scope) whose target skill is ranked reliably below baseline in `skill_utility_path` — negative `lift` AND worst-tier `wLB`, with event count ≥ its `--min`: **-2** *(adding text to a skill that already correlates with friction raises access while likely lowering utilization — SkillsInjector, cited in `adam-skill-utility.mjs`. Read the skill's row as a review prompt, not proof of causation.)*
 - Diagnosis flags `Mismatch: unclear` (causation could not be reconstructed from transcript context): **-1**
 - Blast radius: low **+1**, medium **0**, high **-1** (default per type — see Proposal types table)
 - Surgical (one file, ≤50 LOC for non-skill_new; ≤80 LOC for skill_new): **+1**
@@ -254,13 +464,77 @@ Sum:
 |---|---|---|---|
 | `memory` | `~/.claude/projects/-Users-nvm/memory/*.md` | low | yes if conf≥4 AND cross_session |
 | `skill_new` | new dir under `~/.claude/skills/` | low | yes if conf≥4 AND cross_session |
-| `skill_edit` | existing skill file | medium | yes if win-evidence + LOC + cooldown gates all pass (see "Win-driven skill_edit eligibility") |
+| `skill_edit` | existing skill file | medium | yes (win-driven only) if win-evidence + LOC + cooldown gates all pass (see "Win-driven skill_edit eligibility"); struggle-driven variant ALWAYS queues (see "Struggle-driven skill_edit eligibility") |
+| `nudge` | append to `~/.claude/adam/active-nudges.json` | low | yes when `dead_end_count ≥ 3` in a single session (single-session evidence sufficient; skips cross-session gate). Does NOT modify skills/memories/CLAUDE.md — only seeds a SessionStart reminder for a future session. |
+| `reinforcement` | append entry to `~/.claude/adam/reinforcements.jsonl` | low | yes if conf≥4 AND blast_radius=low (same gate as memory). Applies via `adam-apply-reinforcement.mjs`; appends one JSONL entry, no code/memory/skill changes. |
 | `agent_new` | new file under `~/.claude/agents/` | medium | no |
 | `agent_edit` | existing agent file | medium | no |
 | `claude_md_edit` | `~/.claude/CLAUDE.md` | high | no |
 | `hook_new` / `hook_edit` | `settings.json` hooks | high | no |
+| `harness_edit` | adam's own scripts/agent/hooks (see "Harness self-modification") | high | **never** |
 | `deletion` | any skill/agent (soft delete) | high | no |

+### `nudge` proposals
+
+A `nudge` proposal does NOT modify any persistent rubric/skill/memory artifact. Its sole side-effect is to append an entry to `~/.claude/adam/active-nudges.json` so a future session surfaces a one-line checkpoint reminder — at SessionStart (`adam-nudge.mjs`) and mid-session on the matching cwd (`adam-observe.mjs` on UserPromptSubmit).
+
+Trigger: `adam-nudge-eligibility.mjs --session <id>` returns `eligible: true` (i.e. ≥3 `dead_end` entries inside a single session). Distinguished from `skill_edit` precisely because there is no learning artifact to mutate — the action surfaces a checkpoint reminder, not a behavior change.
+
+Required proposal frontmatter (the entry is built deterministically by `adam-apply-nudge.mjs` — do NOT hand-author the JSON message/cue):
+
+```yaml
+type: nudge
+source_session: <originating session_id>
+cwd: <cluster's dominant cwd — becomes cue.cwd; adam-batch.mjs aggregates `cwds` per batch>
+dead_end_count: <N ≥ 3 from adam-nudge-eligibility.mjs>
+confidence: <int>
+blast_radius: low
+```
+
+The helper writes `{kind, message, created_at, expires_at_ts: now+7d, max_displays: 3, displays_used: 0, source_session, cue: {cwd}}`. The `cue.cwd` binds the reminder to the project it came from: both surfaces (SessionStart + mid-session) fire the nudge only when the session's cwd matches, deferring it elsewhere without consuming a display (ReContext-style query-conditioned replay). Omit `cwd` from frontmatter only for a deliberately project-agnostic reminder (then the nudge has no cue and surfaces unconditionally at SessionStart, as legacy).
+
+### `reinforcement` proposals
+
+A `reinforcement` proposal is logged when `adam-score.mjs` reports `count >= 3` clean `task_completed` events citing the same `active_skills[0]` slug. Frontmatter MUST include `skill_slug`, `count`, `source_session`, `confidence`, `blast_radius: low`. Apply gate (`confidence >= 4 AND blast_radius == low`) is identical to the `memory` gate — when both hold, the skill invokes `~/.claude/adam/scripts/adam-apply-reinforcement.mjs <proposal-path>` which appends one JSON line to `~/.claude/adam/reinforcements.jsonl` of shape `{ts, skill_slug, count, source_session}`. No code/memory/skill modifications either side of the gate — reinforcements are a positive-only ledger, separate from `ab-tracking.jsonl` (A/B intentionally does NOT measure positive signals to avoid skewing regression detection).
+
+Note that `task_completed` alone — without an adjacent negative signal cluster — is NOT a proposal source. It is a urgency *modifier* (see "Scoring: task_completed dampener") and a reinforcement input only.
+
+### `harness_edit` proposals (MOSS §1 Table 1)
+
+MOSS's core thesis: "routing, hook ordering, state invariants, and dispatch live in code rather than in any text artifact, an entire class of structural failure is physically unreachable from the text layer." This proposal type extends ADAM's evolution scope to its own harness.
+
+**Allowed targets** (harness files that ADAM may propose edits to):
+
+| target | what it controls |
+|---|---|
+| `~/.claude/adam/scripts/adam-observe.mjs` | signal detection regexes, thresholds, counters |
+| `~/.claude/adam/scripts/adam-score.mjs` | severity divisors, dampener thresholds |
+| `~/.claude/adam/scripts/adam-window.mjs` | per-signal sliding window durations |
+| `~/.claude/adam/scripts/adam-batch.mjs` | evidence batching logic |
+| `~/.claude/agents/adam.md` | this agent's own rubric, clustering, proposal rules |
+| `~/.claude/hooks/adam-observe.mjs` | hook integration, event routing |
+
+**Gates (all must hold — stricter than any other type):**
+
+1. `confidence ≥ 5`
+2. `cross_session_evidence == true` (≥5 occurrences across ≥3 sessions)
+3. `auto_apply_eligible: false` — **always**. Harness edits are never auto-applied.
+4. `blast_radius: high`
+5. Proposal includes a `# Test verification` section with the command `bash ~/.claude/adam/tests/run-tests.sh` and the expected result "140 passed, 0 failed" (or current pass count). The skill runs this test before applying.
+6. Change is surgical: ≤30 LOC diff, single file.
+7. `# Diagnosis` reconstructs the causal chain from harness-level behavior (not from text-artifact behavior). The mismatch must name a specific code path (function, regex, threshold) in the target file.
+
+**When to propose `harness_edit`:**
+- Signal detection misses a recurring friction pattern (false negative in adam-observe.mjs)
+- A/B measurement shows systematic bias (e.g., windows too short/long in adam-window.mjs)
+- Scoring thresholds produce consistently over/under-weighted proposals (adam-score.mjs)
+- Batch clustering produces too-coarse or too-fine groupings (adam-batch.mjs)
+
+**When NOT to propose `harness_edit`:**
+- The fix is achievable via a text-mutable type (skill, memory, nudge)
+- Evidence is from a single session only
+- The change would affect test outcomes without clear improvement evidence
+
 ## Special handling

 ### CLAUDE.md edits
@@ -287,7 +561,7 @@ Filename: `proposals_dir/YYYY-MM-DD-NNN-<type>-<slug>.md` (NNN is daily counter
 ```markdown
 ---
 id: YYYY-MM-DD-NNN
-type: skill_new | memory | skill_edit | agent_new | agent_edit | claude_md_edit | hook_new | hook_edit | deletion
+type: skill_new | memory | skill_edit | nudge | reinforcement | agent_new | agent_edit | claude_md_edit | hook_new | hook_edit | harness_edit | deletion
 target: <absolute path — for skill_new, the will-be path: ~/.claude/skills/<slug>/SKILL.md>
 confidence: <int>
 blast_radius: low | medium | high
@@ -299,6 +573,12 @@ source_entries:
  - "<journal entry ts that fed this cluster>"
  - "<another ts>"
  - "..."
+# skill_edit / skill_new — required for cooldown gate (see "Per-(skill, fingerprint) cooldown" below)
+proposal_fingerprint: "<djb2_base36 hash — compute via `adam-cooldown.mjs --compute`; see §Per-(skill, fingerprint) cooldown>"
+target_skill: "<slug — populated for skill_edit (basename of target dir) and skill_new (proposed slug)>"
+# A/B effectiveness — required on every proposal; consumed at apply time to seed ab-tracking.jsonl
+originating_signals:
+  - {type: "<signal_type>", count: <N>, session_ids: ["<sid>", "..."]}
 # skill_edit only — required when auto_apply_eligible: true
 win_evidence: "<ts of triggering clean_recovery or correction_free_streak entry>"
 bytes_before: <int>
@@ -307,6 +587,11 @@ bytes_after: <int>
 contradiction_flag: "<one-line summary or null>"
 # optional — auto-populated from Diagnosis Mismatch line
 diagnosis_summary: "<≤120 chars, single sentence>"
+# keypoint matrix — which capability dimension this proposal targets (MOSS §4.2)
+keypoint_target: "<tool_selection | scope_discipline | error_recovery | first_attempt | build_reliability>"
+# harness_edit only — test command and expected output
+test_command: "bash ~/.claude/adam/tests/run-tests.sh"
+test_expected: "<N> passed, 0 failed"
 ---

 # Why
@@ -345,7 +630,52 @@ Print a single JSON line to stdout:
 ## What you must NOT do

 - Do not call other agents.
- Do not write to `~/.claude/skills/`, `~/.claude/agents/`, `settings.json`, `CLAUDE.md`, or any existing skill/agent file directly. All changes go through proposal files for main-thread review and apply.
+- Do not write to `~/.claude/skills/`, `~/.claude/agents/`, `settings.json`, `CLAUDE.md`, adam scripts, or any existing skill/agent/harness file directly. All changes go through proposal files for main-thread review and apply. This includes `harness_edit` proposals — you draft the diff, the skill applies it after test verification.
 - Do not delete files. Deletion proposals describe a soft-move; the main thread executes it.
 - Do not write outside `proposals_dir/` and `state_path`.
 - Do not invent trigger phrases for `skill_new` — every trigger must come from observed user input.
+
+## Clustering trace (always emit)
+
+After your proposals are written and BEFORE the final punch-list JSON line, you MUST emit a fenced code block tagged ` ```trace ` containing one line per cluster considered during this pass. This is mandatory regardless of whether any proposals were emitted, and regardless of any flags. The skill controls whether to SHOW this block to the user; you always produce it.
+
+Line format (one cluster per line, all four pipe-separated chunks required):
+
+```
+<cluster_id> | signal=<type> count=<N> sessions=<M> | gates: threshold=<pass|fail:<reason>>, cross_session=<pass|fail>, window=<in:<N>/out:<M>>, contradiction=<none|vetoed:[[memory-name]]> | decision: <proposal_emitted:<type>|skipped:<reason>>
+```
+
+Field semantics:
+
+- `cluster_id` — short stable identifier you assign per cluster this pass (e.g. `c1`, `c2`, …, or `<signal>-<short-key>`). Used by humans + adam-explain.mjs.
+- `signal=<type>` — the journal signal type (e.g. `correction`, `dead_end`).
+- `count=<N>` — number of journal entries that fell into this cluster.
+- `sessions=<M>` — distinct session ids contributing.
+- `gates:` — four sub-fields, all required:
+  - `threshold=pass` if the cluster met the "≥3 across ≥2 sessions" (or single-session struggle) rubric gate, else `fail:<short reason>` (e.g. `fail:only_1_session`, `fail:count_below_3`).
+  - `cross_session=pass|fail` — boolean restatement matching the `cross_session_evidence` rubric field.
+  - `window=in:<N>/out:<M>` — entries that survived per-signal sliding window vs entries dropped as stale. Pre-filter from `adam-window.mjs` makes `out` usually 0; record what you observed.
+  - `contradiction=none` for non-skill_edit clusters; for `skill_edit` set `vetoed:[[<memory-or-skill-name>]]` when the contradiction heuristic flagged a conflict, else `none`.
+- `decision:` — one of:
+  - `proposal_emitted:<type>` (e.g. `proposal_emitted:memory`, `proposal_emitted:skill_new`).
+  - `skipped:<reason>` where reason is a single token from `{threshold, contradiction, window, rejected-similar, type-bias, deletion-criteria, claude-md-scope, overlap, other}`.
+
+After the cluster lines, emit exactly one summary line (this trailing line is REQUIRED — adam-explain.mjs falls back to synthesising it from the cluster lines if you omit it, but you should always write it):
+
+```
+SUMMARY: considered=<N> emitted=<M> skipped=<N-M> regressions=<R> reasons={threshold:X, contradiction:Y, window:Z, other:W}
+```
+
+`reasons` keys: the same skip-reason tokens used in `decision:`; values are counts; include all four canonical keys (`threshold`, `contradiction`, `window`, `other`) even when zero — `other` is the catch-all for any reason not in the first three. `regressions=<R>` is the count of entries with `status == "regressed"` in the `ab_regressions` input (0 when empty/absent — see §"A/B effectiveness").
+
+Worked example (4 clusters, 2 emitted, 2 skipped):
+
+```trace
+c1 | signal=correction count=5 sessions=3 | gates: threshold=pass, cross_session=pass, window=in:5/out:0, contradiction=none | decision: proposal_emitted:memory
+c2 | signal=dead_end count=1 sessions=1 | gates: threshold=pass, cross_session=fail, window=in:1/out:0, contradiction=none | decision: proposal_emitted:skill_new
+c3 | signal=retry_loop count=2 sessions=1 | gates: threshold=fail:count_below_3, cross_session=fail, window=in:2/out:0, contradiction=none | decision: skipped:threshold
+c4 | signal=tool_error_loop count=4 sessions=2 | gates: threshold=pass, cross_session=pass, window=in:4/out:6, contradiction=none | decision: skipped:window
+SUMMARY: considered=4 emitted=2 skipped=2 regressions=0 reasons={threshold:1, contradiction:0, window:1, other:0}
+```
+
+Clusters that were filtered out entirely BEFORE clustering (e.g. excluded by `applied/*.md` `source_entries`) do not appear here — only clusters that the agent actually considered as candidates. Note: the trace lives entirely in your final assistant message, alongside the punch-list JSON; nothing else writes to disk on the agent side.
@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 160 160" width="160" height="160" role="img" aria-label="claude-adam logo">
+  <title>claude-adam</title>
+  <desc>A swaddled baby — rounded A-shape bundle with a face inside and small hands extending from the wrap-band. Dark-background variant.</desc>
+  <g stroke="#f0f6fc">
+    <path d="M 36 134 Q 30 78 80 28 Q 130 78 124 134 Z" fill="none" stroke-width="9" stroke-linejoin="round"/>
+    <path d="M 16 100 L 44 100 Q 80 115 116 100 L 144 100" fill="none" stroke-width="6" stroke-linecap="round"/>
+    <path d="M 75 78 Q 80 82 85 78" fill="none" stroke-width="2.5" stroke-linecap="round"/>
+  </g>
+  <g fill="#f0f6fc">
+    <circle cx="72" cy="64" r="3.2"/>
+    <circle cx="88" cy="64" r="3.2"/>
+  </g>
+</svg>
@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 160 160" width="160" height="160" role="img" aria-label="claude-adam logo">
+  <title>claude-adam</title>
+  <desc>A swaddled baby — rounded A-shape bundle with a face inside and small hands extending from the wrap-band. Light-background variant.</desc>
+  <g stroke="#24292f">
+    <path d="M 36 134 Q 30 78 80 28 Q 130 78 124 134 Z" fill="none" stroke-width="9" stroke-linejoin="round"/>
+    <path d="M 16 100 L 44 100 Q 80 115 116 100 L 144 100" fill="none" stroke-width="6" stroke-linecap="round"/>
+    <path d="M 75 78 Q 80 82 85 78" fill="none" stroke-width="2.5" stroke-linecap="round"/>
+  </g>
+  <g fill="#24292f">
+    <circle cx="72" cy="64" r="3.2"/>
+    <circle cx="88" cy="64" r="3.2"/>
+  </g>
+</svg>
@@ -0,0 +1,19 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 160 160" width="160" height="160" role="img" aria-label="claude-adam logo">
+  <title>claude-adam</title>
+  <desc>A swaddled baby — rounded A-shape bundle with a face inside and small hands extending from the wrap-band. Adapts to light/dark via embedded media query + currentColor fallback.</desc>
+  <style>
+    svg { color: #24292f; }
+    @media (prefers-color-scheme: dark) {
+      svg { color: #f0f6fc; }
+    }
+  </style>
+  <g stroke="currentColor">
+    <path d="M 36 134 Q 30 78 80 28 Q 130 78 124 134 Z" fill="none" stroke-width="9" stroke-linejoin="round"/>
+    <path d="M 16 100 L 44 100 Q 80 115 116 100 L 144 100" fill="none" stroke-width="6" stroke-linecap="round"/>
+    <path d="M 75 78 Q 80 82 85 78" fill="none" stroke-width="2.5" stroke-linecap="round"/>
+  </g>
+  <g fill="currentColor">
+    <circle cx="72" cy="64" r="3.2"/>
+    <circle cx="88" cy="64" r="3.2"/>
+  </g>
+</svg>
@@ -1,16 +1,233 @@
 #!/usr/bin/env node
-import { readdirSync } from "node:fs";
+// adam-nudge.mjs — SessionStart hook. Prints reminders:
+//   1. Pending proposals (≥3 queued in adam/proposals/).
+//   2. Cross-session nudges (entries in adam/active-nudges.json whose
+//      source_session differs from the current session and that haven't
+//      expired or exhausted their max_displays). An entry may carry an optional
+//      `cue.cwd`; when set, it only surfaces in a session whose cwd matches
+//      (otherwise it is deferred, not consumed).
+//   3. Pending local-edit upgrades (`.adam-new` sidecars).
+//   4. New-release notice: if a newer GitHub release exists than the installed
+//      `.version`, print a notify-only one-line update prompt. Cached + checked
+//      at most once/day, network call hard-capped at 1.5s, fully best-effort —
+//      never blocks SessionStart. Opt out with ADAM_NO_UPDATE_CHECK=1.
+//      NOTE: notify-only by design — applying an update re-runs install.sh,
+//      which resets ADAM's own /reflect-applied skill edits. The user chooses
+//      when to accept that, so we never auto-install.
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";

-const PROPOSALS = join(homedir(), ".claude", "adam", "proposals");
+const HOME = process.env.HOME || homedir();
+const CLAUDE_ROOT = join(HOME, ".claude");
+const ADAM_ROOT = join(CLAUDE_ROOT, "adam");
+const PROPOSALS = join(ADAM_ROOT, "proposals");
+const NUDGES_FILE = join(ADAM_ROOT, "active-nudges.json");
+const STATE_FILE = join(ADAM_ROOT, "state.json");
+const VERSION_FILE = join(ADAM_ROOT, ".version");
+const UPDATE_CHECK_FILE = join(ADAM_ROOT, ".update-check.json");
 const THRESHOLD = 3;
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_FETCH_TIMEOUT_MS = 1500;
+const RELEASES_API = "https://api.github.com/repos/lukaszraczylo/claude-adam/releases/latest";
+const INSTALL_ONELINER = "curl -fsSL https://raw.githubusercontent.com/lukaszraczylo/claude-adam/main/install.sh | bash";

-try {
-  const PROPOSAL_RE = /^\d{4}-\d{2}-\d{2}-\d{3}-/;
-  const files = readdirSync(PROPOSALS).filter(f => PROPOSAL_RE.test(f) && f.endsWith(".md"));
-  if (files.length >= THRESHOLD) {
-    process.stdout.write(`adam: ${files.length} proposals queued. Run /reflect to review.\n`);
+// Known installable paths (mirrors install.sh copy_file list). Checking a
+// fixed shortlist keeps SessionStart latency under control vs full FS walk.
+const PENDING_CHECK_PATHS = [
+  "hooks/adam-observe.mjs",
+  "hooks/adam-nudge.mjs",
+  "agents/adam.md",
+  "skills/adam-self-improvement/SKILL.md",
+  "skills/adam-self-improvement/apply-by-type.md",
+  "commands/reflect.md",
+  "adam/scripts/adam-archive.mjs",
+  "adam/scripts/adam-upgrade.mjs",
+  "adam/scripts/adam-window.mjs",
+  "adam/scripts/adam-explain.mjs",
+  "adam/scripts/adam-nudge-eligibility.mjs",
+  "adam/scripts/adam-cooldown.mjs",
+  "adam/scripts/adam-score.mjs",
+  "adam/scripts/adam-ab-measure.mjs",
+  "adam/scripts/adam-skill-utility.mjs",
+  "adam/scripts/adam-apply-reinforcement.mjs",
+  "adam/scripts/adam-apply-nudge.mjs",
+  "adam/scripts/adam-utils.mjs",
+  "adam/scripts/adam-batch.mjs",
+  "adam/scripts/adam-rollback.mjs",
+  "adam/tests/run-tests.sh",
+];
+
+function readJson(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return fallback; }
+}
+
+function readSessionInput() {
+  // SessionStart payload arrives on stdin; return the parsed object so callers
+  // can read both session_id and cwd. We don't block on stdin — best-effort.
+  try {
+    const buf = readFileSync(0, "utf8");
+    if (!buf) return null;
+    const parsed = JSON.parse(buf);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch { return null; }
+}
+
+function emitProposalReminder() {
+  try {
+    const PROPOSAL_RE = /^\d{4}-\d{2}-\d{2}-\d{3}-/;
+    const files = readdirSync(PROPOSALS).filter((f) => PROPOSAL_RE.test(f) && f.endsWith(".md"));
+    if (files.length >= THRESHOLD) {
+      process.stdout.write(`adam: ${files.length} proposals queued. Run /reflect to review.\n`);
+    }
+  } catch { /* proposals dir absent → silent */ }
+}
+
+function emitActiveNudges(currentSession, currentCwd) {
+  if (!existsSync(NUDGES_FILE)) return;
+  const raw = readJson(NUDGES_FILE, null);
+  if (!Array.isArray(raw)) return;
+  const now = Date.now();
+  const kept = [];
+  let mutated = false;
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") { mutated = true; continue; }
+    const expires = Number(entry.expires_at_ts || 0);
+    if (!expires || expires <= now) { mutated = true; continue; }
+    const sourceSession = entry.source_session || "";
+    const max = Number(entry.max_displays || 0);
+    const used = Number(entry.displays_used || 0);
+    if (max > 0 && used >= max) { mutated = true; continue; }
+    // Cross-session gate: only print when current session differs.
+    if (sourceSession && currentSession && sourceSession === currentSession) {
+      kept.push(entry);
+      continue;
+    }
+    // Cue gate (optional, additive): a nudge may carry `cue.cwd` binding it to
+    // the project it originated in. When set and the current session's cwd does
+    // not match, defer it — keep the entry, do NOT consume a display — instead of
+    // surfacing an irrelevant reminder. Nudges without a cue print unconditionally,
+    // exactly as before (ReContext P5/P7: replay should be conditioned on the cue).
+    if (entry.cue && typeof entry.cue === "object" && entry.cue.cwd &&
+        currentCwd && entry.cue.cwd !== currentCwd) {
+      kept.push(entry);
+      continue;
+    }
+    if (typeof entry.message === "string" && entry.message) {
+      process.stdout.write(entry.message + "\n");
+      const nextUsed = used + 1;
+      mutated = true;
+      if (max > 0 && nextUsed >= max) continue; // drop after exhaustion
+      kept.push({ ...entry, displays_used: nextUsed });
+    } else {
+      kept.push(entry);
+    }
  }
-} catch {}
-process.exit(0);
+  if (mutated) {
+    try { writeFileSync(NUDGES_FILE, JSON.stringify(kept, null, 2)); } catch { /* swallow */ }
+  }
+}
+
+function emitPendingUpgrades() {
+  // Cheap: stat a fixed shortlist of `.adam-new` candidates. Non-fatal.
+  try {
+    let count = 0;
+    for (const rel of PENDING_CHECK_PATHS) {
+      const p = join(CLAUDE_ROOT, `${rel}.adam-new`);
+      try {
+        if (existsSync(p)) count++;
+      } catch { /* per-path swallow */ }
+    }
+    if (count > 0) {
+      process.stdout.write(
+        `[adam] ${count} pending upgrade(s). Review: node ~/.claude/adam/scripts/adam-upgrade.mjs --list\n`
+      );
+    }
+  } catch { /* never break SessionStart */ }
+}
+
+// --- update notifier (notify-only; see header note) ---
+
+function readVersion() {
+  try { return readFileSync(VERSION_FILE, "utf8").trim() || null; } catch { return null; }
+}
+
+// Parse "vX.Y.Z" (leading v optional; pre-release/build suffix ignored).
+function parseSemver(s) {
+  if (typeof s !== "string") return null;
+  const m = s.trim().replace(/^v/i, "").match(/^(\d+)\.(\d+)\.(\d+)/);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+
+// isNewer(a, b): true iff version a is strictly newer than b. Unparseable → false.
+function isNewer(a, b) {
+  const pa = parseSemver(a), pb = parseSemver(b);
+  if (!pa || !pb) return false;
+  for (let i = 0; i < 3; i++) { if (pa[i] !== pb[i]) return pa[i] > pb[i]; }
+  return false;
+}
+
+async function fetchLatestTag() {
+  // Best-effort, hard-capped. Any failure (offline / timeout / rate-limit /
+  // parse / fetch-unavailable) returns null and the caller silently skips.
+  try {
+    if (typeof fetch !== "function") return null;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), UPDATE_FETCH_TIMEOUT_MS);
+    let tag = null;
+    try {
+      const res = await fetch(RELEASES_API, {
+        signal: ctrl.signal,
+        headers: { "User-Agent": "claude-adam-nudge", "Accept": "application/vnd.github+json" },
+      });
+      if (res && res.ok) {
+        const j = await res.json();
+        if (j && typeof j.tag_name === "string") tag = j.tag_name;
+      }
+    } finally { clearTimeout(timer); }
+    return tag;
+  } catch { return null; }
+}
+
+function printUpdateNudge(latest, installed) {
+  process.stdout.write(
+    `[adam] update available: ${installed} → ${latest}. Apply: ${INSTALL_ONELINER}\n` +
+    `       (re-runs install.sh — resets ADAM's own /reflect-applied skill edits; apply when you're ready)\n`
+  );
+}
+
+async function emitUpdateCheck() {
+  if (process.env.ADAM_NO_UPDATE_CHECK) return;      // explicit opt-out
+  const installed = readVersion();
+  if (!installed) return;                            // no marker → nothing to compare
+  const cache = readJson(UPDATE_CHECK_FILE, {}) || {};
+  const now = Date.now();
+  let nudged = false;
+  // Instant nudge from cache (no network).
+  if (cache.latest && isNewer(cache.latest, installed)) { printUpdateNudge(cache.latest, installed); nudged = true; }
+  // Refresh cache at most once/day, best-effort — drives the nudge on the NEXT run.
+  if (!cache.last_check || (now - Number(cache.last_check)) > UPDATE_CHECK_INTERVAL_MS) {
+    const latest = await fetchLatestTag();
+    const next = { last_check: now, latest: latest || cache.latest || null };
+    try { writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(next)); } catch { /* swallow */ }
+    if (latest && !nudged && isNewer(latest, installed)) printUpdateNudge(latest, installed);
+  }
+}
+
+async function main() {
+  const payload = readSessionInput();
+  const stdinSession = payload && typeof payload.session_id === "string" ? payload.session_id : null;
+  const stateSession = (() => {
+    const st = readJson(STATE_FILE, null);
+    return st && typeof st.session_id === "string" ? st.session_id : null;
+  })();
+  const currentSession = stdinSession || stateSession || "";
+  const currentCwd = (payload && typeof payload.cwd === "string" && payload.cwd) || process.cwd();
+  emitProposalReminder();
+  emitActiveNudges(currentSession, currentCwd);
+  emitPendingUpgrades();
+  await emitUpdateCheck();
+}
+
+main().catch(() => { /* never block SessionStart */ }).finally(() => process.exit(0));
@@ -14,11 +14,85 @@ const JOURNAL = join(ROOT, "journal.jsonl");
 const STATE = join(ROOT, "state.json");
 const USAGE = join(ROOT, "usage.json");
 const JOURNAL_DIR = join(ROOT, "journal");
+// Safety fuse only — primary rotation is weekly (ISO Monday 00:00 UTC).
+// If active journal exceeds this even mid-week, force-rotate to avoid runaway growth.
+// Override via $ADAM_MAX_JOURNAL_BYTES (used by tests).
+const MAX_JOURNAL_BYTES = Number(process.env.ADAM_MAX_JOURNAL_BYTES) || 50 * 1024 * 1024;

-const CORRECTION_RE = /\b(no|stop|don't|don\'t|wrong|actually|nope|undo|revert)\b/i;
+// Strong-correction tokens: any single occurrence in a prompt is a correction.
+// Weak tokens (no/actually/wait) require co-occurrence with a negation/contrast
+// token within an 8-token window — see isCorrection() below.
+const CORRECTION_RE = /\b(stop|don't|don\'t|wrong|nope|undo|revert|incorrect|nevermind|never\s+mind|disregard|redo)\b|that's\s+wrong|hold\s+on|wait\s+wait|try\s+again|different\s+approach|that's\s+not\s+what\s+i\s+meant|not\s+what\s+i\s+wanted|start\s+over|go\s+back/i;
+const WEAK_CORRECTION_TOKENS = new Set(["no", "actually", "wait"]);
+const NEGATION_RE = /^(not|wrong|but|isn't|isn\'t|didn't|didn\'t|aren't|aren\'t|won't|won\'t|shouldn't|shouldn\'t|don't|don\'t|nope|bad|broken|fail|fails|failed|failing)$/i;
+const WEAK_WINDOW = 8;
+
+function isCorrection(text) {
+  if (!text || typeof text !== "string") return false;
+  if (CORRECTION_RE.test(text)) return true;
+  // Weak-token path: token must co-occur with a negation/contrast within WEAK_WINDOW tokens.
+  const tokens = text.toLowerCase().split(/\s+/).map(t => t.replace(/^[^\w']+|[^\w']+$/g, "")).filter(Boolean);
+  for (let i = 0; i < tokens.length; i++) {
+    if (!WEAK_CORRECTION_TOKENS.has(tokens[i])) continue;
+    const lo = Math.max(0, i - WEAK_WINDOW);
+    const hi = Math.min(tokens.length - 1, i + WEAK_WINDOW);
+    for (let j = lo; j <= hi; j++) {
+      if (j === i) continue;
+      if (NEGATION_RE.test(tokens[j])) return true;
+    }
+  }
+  return false;
+}
+
+// Canonical error codes. Surface text → code mapping below.
+const ERROR_CODES = new Set([
+  "ENOENT", "ECONNREFUSED", "ETIMEDOUT", "EACCES", "EPERM", "EADDRINUSE",
+  "ENOTFOUND", "EISDIR", "ENOTDIR", "EEXIST", "EMFILE", "EPIPE", "ECONNRESET"
+]);
+const ERROR_CODE_RE = /\b(ENOENT|ECONNREFUSED|ETIMEDOUT|EACCES|EPERM|EADDRINUSE|ENOTFOUND|EISDIR|ENOTDIR|EEXIST|EMFILE|EPIPE|ECONNRESET)\b/;
+// Phrase → code mapping. First match wins; order matters.
+const ERROR_PHRASE_MAP = [
+  [/no such file or directory/i,    "ENOENT"],
+  [/connection refused/i,           "ECONNREFUSED"],
+  [/permission denied/i,            "EACCES"],
+  [/address already in use/i,       "EADDRINUSE"],
+  [/connection reset/i,             "ECONNRESET"],
+  [/operation timed out/i,          "ETIMEDOUT"],
+  [/name resolution|getaddrinfo/i,  "ENOTFOUND"],
+];
+
+function normalizeErrorText(text) {
+  if (!text || typeof text !== "string") return "";
+  let s = text;
+  // ISO timestamps first (contain digits we'd otherwise strip individually).
+  s = s.replace(/\d{4}-\d{2}-\d{2}T[\d:.Z+-]+/g, " ");
+  // Windows paths.
+  s = s.replace(/[A-Z]:\\[^\s]+/g, " ");
+  // Absolute POSIX paths.
+  s = s.replace(/\/[^\s:]+/g, " ");
+  // Hex addresses.
+  s = s.replace(/0x[0-9a-f]+/gi, " ");
+  // Unix epoch (seconds or ms): 10-13 digit runs.
+  s = s.replace(/\b\d{10,13}\b/g, " ");
+  // Line/col refs.
+  s = s.replace(/:\d+(?::\d+)?/g, " ");
+  // UUIDs.
+  s = s.replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, " ");
+  // Large integers (>6 digits) that survived above.
+  s = s.replace(/\b\d{7,}\b/g, " ");
+  // Lowercase + collapse whitespace.
+  s = s.toLowerCase().replace(/\s+/g, " ").trim();
+  return s.slice(0, 80);
+}
 const ERROR_RE = /\b(error|failed|exception|traceback|denied|cannot|unable to|not found|undefined|nullpointer|typeerror|syntaxerror|panic|fatal|enoent|econnrefused|etimedout|eaccess|segfault|crashed|uncaught)\b/i;
 const BUILD_RE = /\b(build|compile|make|gradle|cargo|tsc|webpack|vite|rollup|pytest|jest|mocha|vitest|go\s+test|npm\s+test|yarn\s+test|npm\s+run\s+build|yarn\s+build|ctest|ninja|bazel)\b/i;
 const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+const READ_ONLY_TOOLS = new Set([
+  "Read", "Grep", "Glob", "ToolSearch", "WebFetch", "WebSearch",
+  "mcp__filepuff__file_read", "mcp__filepuff__file_search",
+  "mcp__filepuff__find_definition", "mcp__filepuff__find_references",
+  "mcp__filepuff__ast_query", "mcp__filepuff__symbol_at", "mcp__filepuff__ping",
+]);
 const WINDOW_SIZE = 10;
 const RETRY_THRESHOLD = 3;
 const AGENT_RESPAWN_THRESHOLD = 2;
@@ -30,8 +104,20 @@ const BUILD_LOOP_THRESHOLD = 2;
 const SUBAGENT_DISPATCH_THRESHOLD = 3;
 const CORRECTION_FREE_THRESHOLD = 5;
 const CLEAN_RECOVERY_WINDOW = 3;
-const STRUGGLE_TYPES = new Set(["tool_error_loop", "dead_end", "retry_loop"]);
+const SILENT_DRIFT_THRESHOLD = 5;
+const FILE_REREAD_THRESHOLD = 3;
+const ERROR_AFTER_RECOVERY_WINDOW = 5;
+const RECENT_RECOVERIES_MAX = 3;
+const STRUGGLE_TYPES = new Set([
+  "tool_error_loop", "dead_end", "retry_loop", "weak_agent",
+  "edit_churn", "build_loop", "silent_drift", "error_after_recovery",
+  "file_reread",
+]);
 const ACTIVE_SKILLS_LOOKBACK = 10;
+const TASK_TOOL_MIN = 5;
+const TASK_DIVERSITY_MIN = 3;
+const CONTEXT_RING_SIZE = 8;
+const CONTEXT_EXCERPT_LEN = 200;
 const STATE_MAX_BYTES = 1_000_000;

 function safeRead(path, fallback) {
@@ -42,14 +128,69 @@ function safeWrite(path, obj) {
  try { writeFileSync(path, JSON.stringify(obj)); } catch {}
 }

-function rotateIfLarge(path, max) {
+// ISO-8601 week: returns { year, week } for a Date (UTC).
+// Week 1 = the week containing the first Thursday of the year (Monday-based weeks).
+function isoWeek(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  // Shift to Thursday in current week (ISO week-numbering year tracks the Thursday).
+  const day = d.getUTCDay() || 7; // 1..7, Mon=1..Sun=7
+  d.setUTCDate(d.getUTCDate() + 4 - day);
+  const isoYear = d.getUTCFullYear();
+  const yearStart = new Date(Date.UTC(isoYear, 0, 1));
+  const week = Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
+  return { year: isoYear, week };
+}
+
+function isoWeekTag(date) {
+  const { year, week } = isoWeek(date);
+  return `${year}-W${String(week).padStart(2, "0")}`;
+}
+
+function firstEntryTs(path) {
  try {
-    if (existsSync(path) && statSync(path).size > max) {
-      mkdirSync(JOURNAL_DIR, { recursive: true });
-      const today = new Date().toISOString().slice(0, 10);
-      const dest = join(JOURNAL_DIR, `${today}-${Date.now()}.jsonl`);
-      renameSync(path, dest);
+    const buf = readFileSync(path, "utf8");
+    const nl = buf.indexOf("\n");
+    const firstLine = nl === -1 ? buf : buf.slice(0, nl);
+    if (!firstLine.trim()) return null;
+    const obj = JSON.parse(firstLine);
+    return obj && typeof obj.ts === "string" ? obj.ts : null;
+  } catch { return null; }
+}
+
+// Weekly ISO rotation + size safety fuse.
+// - If active journal's first entry is in a different ISO week than now, rotate to
+//   journal/<that-entry's-iso-week>.jsonl and start fresh.
+// - If active journal exceeds MAX_JOURNAL_BYTES, force-rotate even mid-week
+//   using the current ISO week tag (suffixed with timestamp to avoid clobber).
+function rotateIfNeeded(path) {
+  try {
+    if (!existsSync(path)) return;
+    const size = statSync(path).size;
+    if (size === 0) return;
+    const now = new Date();
+    const currentTag = isoWeekTag(now);
+    const firstTs = firstEntryTs(path);
+    let rotate = false;
+    let destTag = null;
+    if (firstTs) {
+      const firstTag = isoWeekTag(new Date(firstTs));
+      if (firstTag !== currentTag) {
+        rotate = true;
+        destTag = firstTag;
+      }
    }
+    if (!rotate && size > MAX_JOURNAL_BYTES) {
+      rotate = true;
+      destTag = `${currentTag}-${Date.now()}`; // safety-fuse: keep mid-week rotations unique
+    }
+    if (!rotate) return;
+    mkdirSync(JOURNAL_DIR, { recursive: true });
+    let dest = join(JOURNAL_DIR, `${destTag}.jsonl`);
+    if (existsSync(dest)) {
+      // Append-merge collision (rare: two mid-week safety-fuse rotations in same ms).
+      dest = join(JOURNAL_DIR, `${destTag}-${Date.now()}.jsonl`);
+    }
+    renameSync(path, dest);
  } catch {}
 }

@@ -63,7 +204,7 @@ function readStdin() {
 }

 function appendJournal(entry) {
-  rotateIfLarge(JOURNAL, STATE_MAX_BYTES * 5);
+  rotateIfNeeded(JOURNAL);
  try {
    appendFileSync(JOURNAL, JSON.stringify(entry) + "\n");
  } catch {}
@@ -92,8 +233,28 @@ function activeNames(state, kind) {
  return [...seen];
 }

+function excerpt(text, len) {
+  if (!text || typeof text !== "string") return null;
+  return text.length > len ? text.slice(0, len) + "…" : text;
+}
+
+function pushContext(state, entry) {
+  state.context_ring.push(entry);
+  if (state.context_ring.length > CONTEXT_RING_SIZE) state.context_ring.shift();
+}
+
+function snapshotContext(state) {
+  return state.context_ring.length ? state.context_ring.slice() : undefined;
+}
+
 function errorFingerprint(toolResponse) {
  if (!toolResponse) return null;
+  // Read/Edit/Write success objects carry `file`/`filePath` and no `is_error`.
+  // PostToolUse never receives failed calls (CC routes them to
+  // PostToolUseFailure), so ERROR_RE here would only match source-file text.
+  if (typeof toolResponse === "object" && !Array.isArray(toolResponse) &&
+      toolResponse.is_error !== true &&
+      ("file" in toolResponse || "filePath" in toolResponse)) return null;
  let text = "";
  if (typeof toolResponse === "string") text = toolResponse;
  else if (toolResponse.content !== undefined) {
@@ -105,16 +266,66 @@ function errorFingerprint(toolResponse) {
  }
  if (!text) return null;
  text = text.slice(0, 4000);
+  // ERROR_RE fallback covers tools that omit `is_error` entirely (text-only
+  // responses, third-party tools). Explicit `is_error: false` is honored as-is
+  // — the regex is NOT used to second-guess a tool that already declared success.
  const isError = toolResponse.is_error === true ||
    (toolResponse.is_error === undefined && ERROR_RE.test(text));
  if (!isError) return null;
-  const m = text.match(ERROR_RE);
-  const idx = m && typeof m.index === "number" ? m.index : 0;
-  const start = Math.max(0, idx - 20);
-  const slice = text.slice(start, start + 80).toLowerCase().replace(/\s+/g, " ").trim();
-  if (!slice) return null;
-  return djb2(slice);
+
+  // 1. Try canonical code (literal token first, then phrase mapping).
+  let code = null;
+  const codeMatch = text.match(ERROR_CODE_RE);
+  if (codeMatch && ERROR_CODES.has(codeMatch[1])) {
+    code = codeMatch[1];
+  } else {
+    for (const [re, mapped] of ERROR_PHRASE_MAP) {
+      if (re.test(text)) { code = mapped; break; }
+    }
+  }
+
+  // 2. When canonical code matched, the bucket key IS the code — residual
+  //    surface text (ports, hostnames, syscall names) varies across instances
+  //    of the same root cause, so we hash a fixed sentinel for stability.
+  //    When no code matched, normalize residual and hash it for the raw bucket.
+  if (code) {
+    return `${code}:${djb2(code)}`;
+  }
+  const normalized = normalizeErrorText(text);
+  if (!normalized) return null;
+  return `raw:${djb2(normalized)}`;
 }
+// Mid-session nudge reactivation (ReContext P5/P7): on UserPromptSubmit, surface a
+// stored active-nudge whose `cue.cwd` matches the current directory, so a deferred
+// reminder lands when the user is actually working in that project instead of only
+// at SessionStart. Read-only — SessionStart (adam-nudge.mjs) owns display accounting;
+// this path surfaces each matching nudge at most once per session (state.surfaced_nudges)
+// and respects expiry + max_displays. Opt out with ADAM_NO_MIDSESSION_NUDGE.
+// UserPromptSubmit hook stdout is injected into the session context, so this is the
+// reliable surface (unlike PostToolUse). Any failure is swallowed — never block a prompt.
+function surfaceMatchingNudges(state, cwd) {
+  if (process.env.ADAM_NO_MIDSESSION_NUDGE || !cwd) return;
+  const nudgesPath = join(ROOT, "active-nudges.json");
+  let raw;
+  try { raw = JSON.parse(readFileSync(nudgesPath, "utf8")); } catch { return; }
+  if (!Array.isArray(raw)) return;
+  const now = Date.now();
+  if (!Array.isArray(state.surfaced_nudges)) state.surfaced_nudges = [];
+  for (const n of raw) {
+    if (!n || typeof n !== "object" || typeof n.message !== "string" || !n.message) continue;
+    if (Number(n.expires_at_ts || 0) <= now) continue;
+    const max = Number(n.max_displays || 0);
+    if (max > 0 && Number(n.displays_used || 0) >= max) continue;
+    const cue = n.cue && typeof n.cue === "object" ? n.cue : null;
+    if (!cue || !cue.cwd || cue.cwd !== cwd) continue;   // cue-conditioned on cwd
+    const id = String(n.created_at || n.message);
+    if (state.surfaced_nudges.includes(id)) continue;
+    process.stdout.write(n.message + "\n");
+    state.surfaced_nudges.push(id);
+    if (state.surfaced_nudges.length > 50) state.surfaced_nudges.shift();
+  }
+}
+

 function resetFrictionCounters(state) {
  state.tools_since_user = 0;
@@ -124,6 +335,8 @@ function resetFrictionCounters(state) {
  state.edit_churn_emitted = {};
  state.build_failure_count = 0;
  state.build_loop_emitted = false;
+  state.silentDriftCounter = 0;
+  state.silentDriftEmitted = false;
 }

 function resetSessionLocal(state) {
@@ -132,7 +345,14 @@ function resetSessionLocal(state) {
  state.subagent_dispatch_emitted = {};
  state.correctionFreeCounter = 0;
  state.recoveryWatch = null;
+  state.recentRecoveries = [];
+  state.session_post_count = 0;
  state.tool_window = [];
+  state.context_ring = [];
+  state.task_tool_kinds = {};
+  state.task_tool_count = 0;
+  state.task_corrections = 0;
+  state.surfaced_nudges = [];
 }

 function ensureStateDefaults(state) {
@@ -149,12 +369,25 @@ function ensureStateDefaults(state) {
  if (typeof state.correctionFreeCounter !== "number") state.correctionFreeCounter = 0;
  if (state.recoveryWatch === undefined) state.recoveryWatch = null;
  if (!Array.isArray(state.activity_ring)) state.activity_ring = [];
+  if (!state.task_tool_kinds || typeof state.task_tool_kinds !== "object") state.task_tool_kinds = {};
+  if (typeof state.task_tool_count !== "number") state.task_tool_count = 0;
+  if (typeof state.task_corrections !== "number") state.task_corrections = 0;
+  if (typeof state.silentDriftCounter !== "number") state.silentDriftCounter = 0;
+  if (typeof state.silentDriftEmitted !== "boolean") state.silentDriftEmitted = false;
+  if (!Array.isArray(state.recentRecoveries)) state.recentRecoveries = [];
+  if (typeof state.session_post_count !== "number") state.session_post_count = 0;
+  if (!Array.isArray(state.context_ring)) state.context_ring = [];
+  if (!Array.isArray(state.surfaced_nudges)) state.surfaced_nudges = [];
 }

 function main() {
  const input = readStdin();
  if (!input || typeof input !== "object") return;

+  // Weekly rotation check at hook entry — ensures the active journal rolls over
+  // even if this invocation appends nothing.
+  rotateIfNeeded(JOURNAL);
+
  const event = input.hook_event_name;
  const session = input.session_id || "unknown";
  const cwd = input.cwd || process.cwd();
@@ -169,7 +402,9 @@ function main() {

  if (event === "UserPromptSubmit") {
    const prompt = (input.prompt || "").slice(0, 200);
-    if (CORRECTION_RE.test(prompt)) {
+    pushContext(state, { event: "user", prompt: excerpt(prompt, CONTEXT_EXCERPT_LEN), ts });
+    surfaceMatchingNudges(state, cwd);
+    if (isCorrection(prompt)) {
      const last = state.tool_window[state.tool_window.length - 1] || {};
      appendJournal({
        ts, session, cwd, type: "correction",
@@ -178,6 +413,7 @@ function main() {
        prev_file: last.file || null,
      });
      state.correctionFreeCounter = 0;
+      state.task_corrections += 1;
    } else {
      state.correctionFreeCounter += 1;
      if (state.correctionFreeCounter >= CORRECTION_FREE_THRESHOLD) {
@@ -190,6 +426,22 @@ function main() {
        state.correctionFreeCounter = 0;
      }
    }
+    // Evaluate prior task (work between previous UserPromptSubmit and this one).
+    const taskKinds = Object.keys(state.task_tool_kinds);
+    if (state.task_tool_count >= TASK_TOOL_MIN &&
+        taskKinds.length >= TASK_DIVERSITY_MIN &&
+        state.task_corrections === 0) {
+      appendJournal({
+        ts, session, cwd, type: "task_completed",
+        tool_count: state.task_tool_count,
+        tool_kinds: taskKinds,
+        active_skills: activeNames(state, "skill"),
+        active_agents: activeNames(state, "agent"),
+      });
+    }
+    state.task_tool_kinds = {};
+    state.task_tool_count = 0;
+    state.task_corrections = 0;
    resetFrictionCounters(state);
  } else if (event === "PreToolUse") {
    const tool = input.tool_name;
@@ -213,14 +465,41 @@ function main() {
        state.subagent_dispatch_emitted[name] = true;
      }
    }
-  } else if (event === "PostToolUse") {
+  } else if (event === "PostToolUse" || event === "PostToolUseFailure") {
    const tool = input.tool_name || "unknown";
    const argsHash = djb2(JSON.stringify(input.tool_input || {}));
    const file = (input.tool_input && (input.tool_input.file_path || input.tool_input.path)) || null;

+    // Claude Code sends failed tool calls to PostToolUseFailure with the error
+    // text in `error`. Shape it like an is_error response so every PostToolUse
+    // detector sees real failures. An interrupt is an abort, not a tool error.
+    const toolResponse = event === "PostToolUseFailure"
+      ? { is_error: input.is_interrupt !== true, content: String(input.error || "") }
+      : input.tool_response;
+    const respExcerpt = (() => {
+      if (!toolResponse) return null;
+      const text = typeof toolResponse === "string" ? toolResponse
+        : typeof toolResponse.content === "string" ? toolResponse.content
+        : null;
+      return excerpt(text, CONTEXT_EXCERPT_LEN);
+    })();
+    pushContext(state, {
+      event: "tool", tool, ts,
+      input_excerpt: excerpt(JSON.stringify(input.tool_input || {}), CONTEXT_EXCERPT_LEN),
+      response_excerpt: respExcerpt,
+      is_error: !!(toolResponse && toolResponse.is_error),
+    });
+
    let struggleEmittedThisTurn = null;
    const emit = (entry) => {
-      if (STRUGGLE_TYPES.has(entry.type)) struggleEmittedThisTurn = entry.type;
+      if (STRUGGLE_TYPES.has(entry.type)) {
+        entry.context_window = snapshotContext(state);
+        // Struggle signals carry the active skill set so the analyst can run
+        // skill-attribution sub-clustering (agents/adam.md §5b) and so silent_drift
+        // — whose primary cluster key IS active_skills[0] — clusters correctly.
+        if (entry.active_skills === undefined) entry.active_skills = activeNames(state, "skill");
+        struggleEmittedThisTurn = entry.type;
+      }
      appendJournal(entry);
    };

@@ -231,12 +510,34 @@ function main() {
    }
    state.tool_window.push(windowEntry);
    if (state.tool_window.length > WINDOW_SIZE) state.tool_window.shift();
+    state.session_post_count += 1;

    const sameToolArgs = state.tool_window.filter(e => e.tool === tool && e.argsHash === argsHash).length;
    if (sameToolArgs >= RETRY_THRESHOLD) {
      emit({ ts, session, cwd, type: "retry_loop", tool, count: sameToolArgs });
    }

+    // Offset-aware same-file reread: consecutive Reads of the same file_path
+    // (ignoring offset/limit) escape the argsHash-based retry_loop dedup above.
+    // Emit a distinct, actionable signal instead of leaking into tool_error_loop.
+    if (READ_ONLY_TOOLS.has(tool) && file) {
+      const sameFileReads = state.tool_window.filter(e => e.tool === tool && e.file === file).length;
+      if (sameFileReads >= FILE_REREAD_THRESHOLD && sameToolArgs < RETRY_THRESHOLD) {
+        emit({ ts, session, cwd, type: "file_reread", tool, file, count: sameFileReads });
+      }
+    }
+
+    if (READ_ONLY_TOOLS.has(tool)) {
+      state.silentDriftCounter += 1;
+      if (state.silentDriftCounter >= SILENT_DRIFT_THRESHOLD && !state.silentDriftEmitted) {
+        emit({ ts, session, cwd, type: "silent_drift", read_count: state.silentDriftCounter, last_tool: tool });
+        state.silentDriftEmitted = true;
+      }
+    } else {
+      state.silentDriftCounter = 0;
+      state.silentDriftEmitted = false;
+    }
+
    if (tool === "Agent") {
      const subagent = (input.tool_input && (input.tool_input.subagent_type || input.tool_input.agent)) || "unknown";
      const recent = state.tool_window.slice(-5).filter(e => e.tool === "Agent" && e.subagent === subagent).length;
@@ -245,13 +546,30 @@ function main() {
      }
    }

-    if (input.tool_response && typeof input.tool_response === "object") {
+    if (toolResponse && typeof toolResponse === "object") {
      bumpUsage("payload:tool_response_seen");
    }

-    const fp = errorFingerprint(input.tool_response);
+    const fp = errorFingerprint(toolResponse);
    if (fp) {
      bumpUsage("payload:tool_response_error_seen");
+      if (state.recentRecoveries.length) {
+        const keep = [];
+        for (const rec of state.recentRecoveries) {
+          const tools_since = state.session_post_count - rec.emitted_at_count;
+          if (tools_since > ERROR_AFTER_RECOVERY_WINDOW) continue;
+          if (Array.isArray(rec.fps) && rec.fps.includes(fp)) {
+            emit({
+              ts, session, cwd, type: "error_after_recovery",
+              recovered_from: rec.recovered_from, original_fp: fp,
+              tools_since_recovery: tools_since,
+            });
+            continue;
+          }
+          keep.push(rec);
+        }
+        state.recentRecoveries = keep;
+      }
      state.last_errors.push({ tool, fp });
      if (state.last_errors.length > ERROR_RING_SIZE) state.last_errors.shift();
      const sameError = state.last_errors.filter(e => e.fp === fp).length;
@@ -277,7 +595,7 @@ function main() {
    if (tool === "Bash") {
      const cmd = (input.tool_input && input.tool_input.command) || "";
      const isBuildCmd = BUILD_RE.test(cmd);
-      const hasError = (input.tool_response && input.tool_response.is_error === true) || fp !== null;
+      const hasError = (toolResponse && toolResponse.is_error === true) || fp !== null;
      if (isBuildCmd && hasError) {
        state.build_failure_count += 1;
        if (state.build_failure_count >= BUILD_LOOP_THRESHOLD && !state.build_loop_emitted) {
@@ -293,8 +611,17 @@ function main() {
      state.dead_end_emitted = true;
    }

+    state.task_tool_count += 1;
+    state.task_tool_kinds[tool] = (state.task_tool_kinds[tool] || 0) + 1;
+
    if (struggleEmittedThisTurn) {
-      state.recoveryWatch = { recovered_from: struggleEmittedThisTurn, since_ts: ts, clean_count: 0, window_tools: [] };
+      state.recoveryWatch = {
+        recovered_from: struggleEmittedThisTurn,
+        since_ts: ts,
+        clean_count: 0,
+        window_tools: [],
+        watched_fps: state.last_errors.map(e => e.fp),
+      };
    } else if (state.recoveryWatch) {
      const turnHadError = fp !== null;
      if (turnHadError) {
@@ -311,6 +638,12 @@ function main() {
            active_skills: activeNames(state, "skill"),
            active_agents: activeNames(state, "agent"),
          });
+          state.recentRecoveries.push({
+            recovered_from: state.recoveryWatch.recovered_from,
+            fps: state.recoveryWatch.watched_fps || [],
+            emitted_at_count: state.session_post_count,
+          });
+          if (state.recentRecoveries.length > RECENT_RECOVERIES_MAX) state.recentRecoveries.shift();
          state.recoveryWatch = null;
        }
      }
@@ -320,5 +653,16 @@ function main() {
  safeWrite(STATE, state);
 }

-try { main(); } catch {}
-process.exit(0);
+// Run main only when executed as a script, not when imported for tests.
+// import.meta.url comparison is the standard ESM idiom.
+const isMain = (() => {
+  try {
+    return import.meta.url === `file://${process.argv[1]}`;
+  } catch { return true; }
+})();
+if (isMain) {
+  try { main(); } catch {}
+  process.exit(0);
+}
+
+export { errorFingerprint, normalizeErrorText, isCorrection };
@@ -120,9 +120,20 @@ copy_file "$SRC/hooks/adam-nudge.mjs"                                "$DEST/hook
 # Agent / skill / command
 copy_file "$SRC/agents/adam.md"                                      "$DEST/agents/adam.md"
 copy_file "$SRC/skills/adam-self-improvement/SKILL.md"               "$DEST/skills/adam-self-improvement/SKILL.md"
+copy_file "$SRC/skills/adam-self-improvement/apply-by-type.md"      "$DEST/skills/adam-self-improvement/apply-by-type.md"
 copy_file "$SRC/commands/reflect.md"                                 "$DEST/commands/reflect.md"
 # Adam internals
 copy_file "$SRC/adam/scripts/adam-archive.mjs"                       "$DEST/adam/scripts/adam-archive.mjs"
+copy_file "$SRC/adam/scripts/adam-upgrade.mjs"                       "$DEST/adam/scripts/adam-upgrade.mjs"
+# v0.3.3 helper scripts — invoked from SKILL.md / hooks / analyst flow
+for _adam_script in adam-utils adam-window adam-explain adam-nudge-eligibility adam-cooldown \
+                    adam-score adam-ab-measure adam-apply-reinforcement adam-apply-nudge adam-batch adam-rollback \
+                    adam-skill-utility; do
+  copy_file "$SRC/adam/scripts/${_adam_script}.mjs" \
+            "$DEST/adam/scripts/${_adam_script}.mjs"
+  run "chmod +x \"$DEST/adam/scripts/${_adam_script}.mjs\""
+done
+run "chmod +x \"$DEST/adam/scripts/adam-upgrade.mjs\""
 copy_file "$SRC/adam/tests/run-tests.sh"                             "$DEST/adam/tests/run-tests.sh"
 copy_file "$SRC/adam/tests/fixtures/seed-corrections.jsonl"          "$DEST/adam/tests/fixtures/seed-corrections.jsonl"

@@ -134,6 +145,20 @@ copy_file "$SRC/adam/tests/fixtures/seed-corrections.jsonl"          "$DEST/adam
 # install marker — used by future runs to detect local mtime drift
 run "touch \"$DEST/adam/.install-marker\""

+# version marker — records the installed release tag for the update notifier
+# (adam-nudge.mjs compares it against the latest GitHub release).
+ADAM_VERSION=""
+if [ -n "$VERSION" ]; then
+  ADAM_VERSION="$VERSION"
+elif [ "$PIPED" = 1 ] && [ -n "${REF:-}" ]; then
+  ADAM_VERSION="$REF"
+else
+  ADAM_VERSION="$(git -C "$SRC" describe --tags --abbrev=0 2>/dev/null || true)"
+fi
+[ -z "$ADAM_VERSION" ] && ADAM_VERSION="unknown"
+run "printf '%s\\n' \"$ADAM_VERSION\" > \"$DEST/adam/.version\""
+log "  version marker: $ADAM_VERSION"
+
 # --------------------------------------------------------------------- settings.json
 SETTINGS="$DEST/settings.json"
 EXAMPLE="$SRC/settings.json.example"
@@ -198,9 +223,10 @@ log ""
 log "installed:"
 log "  hooks/adam-observe.mjs, hooks/adam-nudge.mjs"
 log "  agents/adam.md"
-log "  skills/adam-self-improvement/SKILL.md"
+log "  skills/adam-self-improvement/SKILL.md, apply-by-type.md"
 log "  commands/reflect.md"
 log "  adam/scripts/adam-archive.mjs"
+log "  adam/scripts/adam-upgrade.mjs"
 log "  adam/tests/run-tests.sh"
 log ""
 log "preserved (if existed):"
@@ -214,3 +240,13 @@ log ""
 log "ADAM is dormant until you run /reflect."
 log "journal:   $DEST/adam/journal.jsonl"
 log "proposals: $DEST/adam/proposals/"
+
+# --------------------------------------------------------------------- pending merges
+# If this upgrade left any `.adam-new` files behind, make the trap unmissable.
+PENDING_COUNT=$(find "$DEST" \( -name .git -o -name node_modules -o -path "*/adam/journal" -o -path "*/adam/trash" -o -path "*/adam/proposals" -o -path "*/adam/applied" -o -path "*/adam/rejected" \) -prune -o -type f -name '*.adam-new' -print 2>/dev/null | wc -l | tr -d ' ')
+if [ "${PENDING_COUNT:-0}" -gt 0 ]; then
+  log ""
+  warn "${PENDING_COUNT} file(s) need merge review."
+  warn "  Review:  node ~/.claude/adam/scripts/adam-upgrade.mjs --list"
+  warn "  Accept:  node ~/.claude/adam/scripts/adam-upgrade.mjs --accept <path>"
+fi
@@ -34,6 +34,17 @@
        ]
      }
    ],
+    "PostToolUseFailure": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.claude/hooks/adam-observe.mjs\""
+          }
+        ]
+      }
+    ],
    "SessionStart": [
      {
        "hooks": [
@@ -1,6 +1,6 @@
 ---
 name: adam-self-improvement
-description: Use when the user types /reflect, asks "what has adam learned", asks to "review proposals", or wants to inspect the self-improvement queue. Dispatches the adam subagent to analyse the observation journal and presents proposals for approve/reject/edit.
+description: Runs the ADAM /reflect review loop. Use when the user types /reflect or /reflect --explain, asks "what has adam learned", asks to "review proposals" or "review the queue", or acts on a SessionStart nudge about pending proposals. Pre-filters and scores the observation journal, dispatches the adam subagent in two stages, auto-applies verified high-confidence proposals, and walks the rest of the queue for approve, reject or edit.
 ---

 # adam-self-improvement
@@ -8,20 +8,100 @@ description: Use when the user types /reflect, asks "what has adam learned", ask
 ## When to invoke

 - User types `/reflect`
+- User types `/reflect --explain` (same flow, but the analyst's clustering trace is shown to the user — see §2b)
 - User asks: "what has adam learned", "any proposals", "review the queue"
 - SessionStart nudge said proposals are pending and user wants to act on it

+## Supporting file
+
+- [apply-by-type.md](apply-by-type.md): the Karpathy constraints and the per-type apply, move, A/B-tracking, archive, reject and edit procedures. **Read it before any apply in §3a or §4.** Its checks are mandatory. If no proposal reaches §3a or §4, you do not need it.
+
 ## Protocol

-### 1. Dispatch the analyst
+### 0. Parse flags

-Use the Agent tool with `subagent_type: "adam"` and prompt:
+Check the slash-command argument string for the literal token `--explain`. Set `explain=true` when present, otherwise `explain=false`. Unknown flags: print a one-line warning, continue with `explain=false`. `--explain` is the only argument `/reflect` accepts.
+
+### 1. Pre-filter the journal (window + exclusion) + score
+
+Run these steps in order before dispatching the analyst. Each step writes stdout to the output file and stderr to the log file. On failure, show the stderr log to the user and apply the fallback. No failure stops the run.
+
+| # | Step | Command | Fallback on non-zero exit |
+|---|------|---------|---------------------------|
+| 1 | Window filter | `node ~/.claude/adam/scripts/adam-window.mjs --home ~/.claude > /tmp/adam-windowed-journal.jsonl 2> /tmp/adam-windowed-journal.log` | Pass the raw `~/.claude/adam/journal.jsonl` path to the agent. Its manual excluded-timestamps logic still filters actioned entries. Only the freshness window is lost. |
+| 2 | Score | `node ~/.claude/adam/scripts/adam-score.mjs --input /tmp/adam-windowed-journal.jsonl > /tmp/adam-scores.json 2> /tmp/adam-scores.log` | Pass `{"sessions":[],"reinforcement_candidates":[]}` (dampener defaults to 1.0). |
+| 3 | A/B measure | `node ~/.claude/adam/scripts/adam-ab-measure.mjs --home ~/.claude --format json > /tmp/adam-ab-regressions.json 2> /tmp/adam-ab-regressions.log` | Pass `[]`. |
+| 4 | Auto-rollback (only if step 3 found `regressed`) | `node ~/.claude/adam/scripts/adam-rollback.mjs --auto --home ~/.claude > /tmp/adam-rollback-results.json 2> /tmp/adam-rollback.log` | Continue (best-effort). |
+| 5 | Evidence batching | `node ~/.claude/adam/scripts/adam-batch.mjs --input /tmp/adam-windowed-journal.jsonl > /tmp/adam-batches.json 2> /tmp/adam-batch.log` | Pass `null`. The analyst falls back to raw journal clustering. |
+| 6 | Skill utility | `node ~/.claude/adam/scripts/adam-skill-utility.mjs --input /tmp/adam-windowed-journal.jsonl --json > /tmp/adam-skill-utility.json 2> /tmp/adam-skill-utility.log` | Skip (best-effort). |
+
+What each step does and how to use its output:
+
+1. **Window filter.** Reads the active journal and all rotated journals (weekly `journal/YYYY-Www.jsonl` and legacy size-rotated `journal/YYYY-MM-DD-<ts>.jsonl`). Applies per-signal-type sliding windows (`SIGNAL_WINDOWS_DAYS` in `adam-window.mjs`). Drops entries already actioned through the `source_entries` frontmatter of `applied/*.md` and `rejected/*.md`.
+2. **Score.** Produces a per-session `dampener` (0.5 / 0.75 / 1.0, from `task_completed_count`) and a `reinforcement_candidates` list (skills cited by ≥3 clean `task_completed` events). The analyst uses both (`agents/adam.md` §"Scoring: task_completed dampener").
+3. **A/B measure.** Runs on previously auto-applied proposals (see the A/B tracking append in apply-by-type.md). Output is an array of delta objects (`pre_count`, `post_count`, `delta_pct`, `status` ∈ {`improved`,`neutral`,`regressed`,`no_baseline`,`pending`}). Filter to `status == "regressed"` and pass that as `ab_regressions`. When the list is non-empty, the analyst must put a `## Regressions` section at the top of its output (`agents/adam.md` §"A/B effectiveness").
+4. **Auto-rollback** (MOSS §3.5). Reverts regressed proposals before analyst dispatch. The script moves each one from `applied/` back to `proposals/` with `rolled_back: true` and creates a regression nudge. For each one, print: `adam: rolled back "<proposal_id>" — regression detected (delta: <delta_pct>%)`.
+5. **Evidence batching** (MOSS §3.1). Groups entries by (signal_type, cluster_key) into coherent failure batches, with per-batch metadata such as `has_context_window` (transcript evidence attached).
+6. **Skill utility** (execution-grounded selection signal, after SkillsInjector arXiv 2605.29794: utility Δ(s), not surface match). Surfaces advisory candidates for description disambiguation or archival. Ranks skills by co-occurrence with positive (`task_completed`, `clean_recovery`, `correction_free_streak`) vs negative outcome events. **CO-OCCURRENCE, NOT CAUSATION.** Show the worst 3 below-baseline skills (`lift < 0`, not low-sample) to the *user* as a one-line advisory before listing proposals (e.g. `skill-utility: chezmoi 9% pos n=85, ghostty-config 14% pos n=50, …`). Do NOT feed this into the analyst's proposal machinery or auto-draft skill archival from it. The human decides.
+
+### 2. Dispatch the analyst (two-stage pipeline)
+
+MOSS §3.3: "A single prompt asked to diagnose, plan, implement, verify, and decide overloads context and produces lower-quality output than a sequenced flow." Dispatch the analyst in two stages with a validation gate between them.
+
+**Stage 1 — Diagnose + Plan**: Use the Agent tool with `subagent_type: "adam"` and prompt:

 ```
-Run a single analysis pass.
+stage=diagnose
+
+Read the batched journal entries, cluster by signal type, diagnose root causes,
+plan fix types, and score the keypoint matrix. Write diagnoses to /tmp/adam-diagnoses.json.
+Do NOT draft proposal files.

 Inputs:
- journal_path: ~/.claude/adam/journal.jsonl
+- windowed_journal_path: /tmp/adam-windowed-journal.jsonl
+- batches_path: /tmp/adam-batches.json                     # pre-clustered evidence batches
+- scores_path: /tmp/adam-scores.json
+- ab_regressions_path: /tmp/adam-ab-regressions.json
+- skill_utility_path: /tmp/adam-skill-utility.json         # per-skill utility Δ (worst-first); already computed in pre-analysis
+- journal_path: ~/.claude/adam/journal.jsonl               # raw — fallback only
+- state_path: ~/.claude/adam/state.json
+- usage_path: ~/.claude/adam/usage.json
+- applied_dir: ~/.claude/adam/applied/
+- rejected_dir: ~/.claude/adam/rejected/
+- transcripts_root: ~/.claude/projects/
+- skills_root: ~/.claude/skills/
+
+Use batches_path for pre-clustered evidence when available. Prefer context_window
+fields in journal entries over transcript file lookups. Write /tmp/adam-diagnoses.json
+per the "Diagnose-stage output format" in your system prompt.
+```
+
+Wait for return.
+
+**Inter-stage validation** (§2a): after stage 1 returns, read `/tmp/adam-diagnoses.json` and validate each diagnosis:
+
+1. Every `source_entries` timestamp exists in the windowed journal (read `/tmp/adam-windowed-journal.jsonl`, check timestamps match).
+2. Every diagnosis has all four fields (`trigger`, `action`, `mismatch`, `outcome`).
+3. The planned `type` is a valid proposal type.
+4. Remove diagnoses that fail validation — log a one-line warning per removal.
+
+If all diagnoses are removed or the file is missing/empty, print "adam: no valid diagnoses — nothing to implement" and skip to §6.
+
+**Adaptive re-diagnose** (ReContext P5 — spend depth only where it is needed): after validation, collect validated diagnoses whose `mismatch` is `unclear` OR whose cluster severity-sum is top-tier (≥32, per `scores_path`); take at most the top 3 by severity. If any exist, re-dispatch **one** more `stage=diagnose` pass carrying `redigest: <their cluster_ids>` and `prior_diagnoses_path: /tmp/adam-diagnoses.json` (the analyst refines only those clusters in place), then re-run the inter-stage validation above on the refreshed file. Do this at most once per `/reflect`; clear clusters are never re-diagnosed. If none qualify, go straight to Stage 2.
+
+**Stage 2 — Implement**: Use the Agent tool with `subagent_type: "adam"` and prompt:
+
+```
+stage=implement
+
+Read the validated diagnoses and draft full proposal files.
+
+Inputs:
+- diagnoses_path: /tmp/adam-diagnoses.json                 # validated stage-1 output
+- windowed_journal_path: /tmp/adam-windowed-journal.jsonl
+- scores_path: /tmp/adam-scores.json
+- ab_regressions_path: /tmp/adam-ab-regressions.json
+- skill_utility_path: /tmp/adam-skill-utility.json         # per-skill utility Δ — drives the utility-lift rubric penalty
 - state_path: ~/.claude/adam/state.json
 - usage_path: ~/.claude/adam/usage.json
 - proposals_dir: ~/.claude/adam/proposals/
@@ -30,67 +110,75 @@ Inputs:
 - transcripts_root: ~/.claude/projects/
 - skills_root: ~/.claude/skills/

-Follow your system prompt exactly. Emit a single JSON punch list as your final message.
+Draft proposal files to proposals_dir/ for each diagnosis. Score against the
+confidence rubric. Emit the clustering trace and punch list as your final message.
 ```

 Wait for return.

-### 2. Auto-apply high-confidence items
+### 2b. Persist and render the clustering trace

-For each id in `high_confidence`:
- Read the proposal file from `~/.claude/adam/proposals/<id>-*.md`.
- Verify in front of the user: print `id`, `target`, `confidence`, `blast_radius`, `cross_session_evidence`, `auto_apply_eligible`.
- Apply the change:
-  - **For `skill_new`**: `mkdir -p ~/.claude/skills/<slug>/`, then `Write` the proposal's `# Proposed change` body to `~/.claude/skills/<slug>/SKILL.md`. After write, print: "skill `<slug>` written to `~/.claude/skills/<slug>/SKILL.md` — activates immediately — Claude Code v2.1.0+ auto-hot-reloads user-level skills, no restart needed."
-  - **For `memory`**: `Write` the proposal's `# Proposed change` body (which MUST include the auto-memory frontmatter — see "Memory drafting protocol" in `agents/adam.md`) to the path in `target`. Then update `MEMORY.md` index with a one-line pointer.
-  - **For `skill_edit`**: enforce the apply-time gate before writing.
-    1. Verify proposal frontmatter has `auto_apply_eligible: true`. If not, abort and queue for review.
-    2. Read `target` SKILL.md, capture `current_bytes` from a fresh stat — do NOT trust frontmatter `bytes_before`.
-    3. Verify diff in `# Proposed change`:
-       - Unified-diff format.
-       - Zero `-` lines on existing SKILL.md content (additions only).
-       - Total `+` lines ≤ 30.
-       If any check fails, print one-line refusal reason, leave proposal in `proposals/`, continue.
-    4. Cooldown re-check: scan `applied/` frontmatter for `target` matching this and `last_auto_edit` newer than 7 days ago. Refuse if found.
-    5. Blacklist re-check: scan `rejected/` frontmatter for `target` matching this and `auto_apply_blacklist: true` newer than 30 days ago. Refuse if found.
-    6. Apply via `Edit` tool (append the new section per the diff). Never use `Write` on existing SKILL.md.
-    7. Re-stat target. If new size exceeds `2 * current_bytes` (captured in step 2), revert via `Edit` (remove the just-appended section) and refuse — print refusal reason.
-    8. Add `last_auto_edit: <iso8601 utc now>` to the proposal frontmatter before moving it.
-    9. Tell user: "skill `<slug>` extended (added <N> lines) — auto-applied via win-evidence gate."
- Move proposal to `~/.claude/adam/applied/<UTC-ts>-<id>.md`.
- **Archive consumed journal entries**: `node ~/.claude/adam/scripts/adam-archive.mjs ~/.claude/adam/applied/<UTC-ts>-<id>.md` — moves entries listed in proposal's `source_entries` from `journal.jsonl` to `journal/actioned-<id>.jsonl` so subsequent `/reflect` runs do not re-cluster them.
+The analyst's final message always contains a fenced ` ```trace ` block (`agents/adam.md` §"Clustering trace (always emit)") immediately before its punch-list JSON line.

-Print: `auto-applied N proposals: [ids]`.
+1. Extract the trace block. If it is missing, print `adam: trace block missing from agent output — proceeding without observability` and continue. Do not block on this.
+2. ALWAYS write the trace verbatim (without the fences) to `~/.claude/adam/last-trace.txt`, overwriting each run.
+3. ALWAYS show the trace's `SUMMARY:` line as a one-line status BEFORE the proposals are listed, e.g. `clustering: <SUMMARY line>`, in both modes.
+4. If `explain=true`: ALSO render the full trace as a fenced ` ```text ` block under the header `Clustering trace:`. If `explain=false`: SUPPRESS the cluster-line body (step 3 already showed the SUMMARY line).

-### 3. Walk the queue
+The user can re-render any past trace:
+
+```bash
+node ~/.claude/adam/scripts/adam-explain.mjs --mode summary    # SUMMARY + per-decision counts
+node ~/.claude/adam/scripts/adam-explain.mjs --mode full       # verbatim trace + rejection histogram
+node ~/.claude/adam/scripts/adam-explain.mjs --mode json       # machine-readable
+```
+
+### 3. Pre-apply verification gate (MOSS §3.4)
+
+MOSS §3.4: "Verification must therefore be runtime, on a production-equivalent environment, and against the same prompts that produced the failure evidence."
+
+For each id in `high_confidence`, read `~/.claude/adam/proposals/<id>-*.md` and run these checks. All four must pass for auto-apply. Any failure demotes the id to `queued` for manual review.
+
+1. **Source entries exist**: every timestamp in `source_entries` frontmatter appears in `/tmp/adam-windowed-journal.jsonl`. A missing one means the evidence is stale or already actioned.
+2. **Diagnosis grounded**: the `# Diagnosis` section has all four fields (Trigger, Action, Mismatch, Outcome) with ≥1 backtick-wrapped quote.
+3. **Type-evidence match**: the proposal `type` matches what the evidence supports:
+   - `correction` signals → `memory`, `skill_new`, `skill_edit` (not `nudge`)
+   - `dead_end` signals → `nudge`, `skill_new`, `skill_edit` (not `memory`)
+   - `tool_error_loop` signals → `memory`, `skill_new`, `skill_edit`
+   - `harness_edit` → must cite harness-level evidence (false negative, scoring bias, window miscalibration)
+4. **No conflicting applied proposal**: grep `~/.claude/adam/applied/` for a proposal with the same `target` applied in the last 7 days. This prevents stacking rapid edits.
+
+Print `verified: <id> (4/4 checks passed)` or `demoted: <id> (failed: <check_name>)`.
+
+### 3a. Apply verified high-confidence items
+
+Read [apply-by-type.md](apply-by-type.md). Enforce its Karpathy constraints, then follow its §3a sections for each verified id: the per-type apply, then move, A/B tracking append and archive. Print `auto-applied N proposals: [ids]`.
+
+### 4. Walk the queue

 For each id in `queued`:

 a. Read and display the proposal in full (frontmatter + body).
 b. Ask the user: **approve** / **reject** / **edit**.
-c. On **approve**:
-   - For `claude_md_edit`: backup `cp ~/.claude/CLAUDE.md ~/.claude/adam/applied/<ts>-claude-md-backup.md` first.
-   - For `deletion`: `mkdir -p ~/.claude/adam/trash/<ts>` then `mv` the artifact into it. Print restoration command.
-   - For `skill_new`: `mkdir -p ~/.claude/skills/<slug>/`, then write `# Proposed change` body to `<slug>/SKILL.md`. Tell user: "skill `<slug>` written — activates immediately (CC v2.1.0+ auto-hot-reload)."
-   - For `skill_edit`: apply the unified diff in `# Proposed change` to the existing SKILL.md at `target` (append-only — never replace existing content).
-   - For `memory`: write `# Proposed change` body (must include auto-memory frontmatter) to `target` and update `MEMORY.md` index with a one-line pointer.
-   - For all others: apply via Write/Edit per the proposal's `# Proposed change`.
-   - Move proposal to `~/.claude/adam/applied/<ts>-<id>.md`.
-   - Archive: `node ~/.claude/adam/scripts/adam-archive.mjs ~/.claude/adam/applied/<ts>-<id>.md`.
-d. On **reject**: ask for reason in one line. Append `# Reason\n<reason>` to proposal body. If the proposal `type` is `skill_edit`, ALSO add `auto_apply_blacklist: true` to its frontmatter (so future reflects skip auto-apply on this target for 30 days). Move to `~/.claude/adam/rejected/<id>.md`. Archive: `node ~/.claude/adam/scripts/adam-archive.mjs ~/.claude/adam/rejected/<id>.md`.
-e. On **edit**: ask the user for the change, edit the proposal in place, then loop back to step 3a for that same id.
+c. On **approve**: enforce the Karpathy constraints, apply per the apply-by-type.md §4 approve section, move the proposal to `~/.claude/adam/applied/<ts>-<id>.md`, and archive it.
+d. On **reject**: follow apply-by-type.md §4 reject (reason, `auto_apply_blacklist` for `skill_edit`, move to `rejected/`, archive).
+e. On **edit**: ask the user for the change, edit the proposal in place, then loop back to step a for that same id.

-### 4. Handle failures
+### 5. Handle failures

-If apply fails (file write error, target missing): leave proposal in `proposals/`, append `# Apply error\n<error>` to its body. Tell the user. Do not move it.
+If apply fails (file write error, target missing): leave the proposal in `proposals/`, append `# Apply error\n<error>` to its body, and tell the user. Do not move it.

-### 5. Summary
+### 6. Summary

 End with one block:

 ```
 adam reflect summary:
  observations processed: <new>
+  batches formed: <N>
+  diagnoses validated: <N>/<total>
+  rolled back (regression): <N>
+  verification passed: <N>/<total high_confidence>
  auto-applied: <N>
  approved: <N>
  rejected: <N>
@@ -98,26 +186,16 @@ adam reflect summary:
  failed: <N>
 ```

-## Karpathy constraints (you must enforce on each apply)
+**Keypoint history**: after all proposals are processed, append one JSON line to `~/.claude/adam/keypoint-history.jsonl` with the aggregate keypoint scores from the diagnose stage. This is the longitudinal record of which capabilities improve across `/reflect` runs.

-Before writing any proposal:
- Confirm `# Assumptions` section is non-empty.
- Confirm `# Diagnosis` section exists and contains all four labelled lines (`Trigger:`, `Action:`, `Mismatch:`, `Outcome:`) AND at least one backtick-wrapped quote ≤80 chars in the Outcome line. Refuse if missing or malformed — agent must redraft per the "Diagnosis drafting protocol" in `agents/adam.md`.
- Confirm `# Success criterion` section is non-empty and runnable.
- Confirm change is ≤50 LOC for non-`skill_new`, or ≤80 LOC for `skill_new` body. If larger, ask the user once: "this proposal is N LOC — proceed?"
- For `claude_md_edit`: confirm 3+ distinct cwds in the `# Why` section.
- For `deletion`: confirm both criteria (a) and (b) from the agent's special handling are documented in the proposal.
- For `skill_new`: confirm the slug doesn't collide with any existing skill in `~/.claude/skills/`. If it does, refuse and ask user to rename.
- For `skill_edit`: confirm the diff is append-only (no `-` lines that remove existing content) and that target SKILL.md exists. When auto-applying, ALSO re-verify the eligibility gate steps in §2 (cooldown, blacklist, byte cap) before any `Edit` call — never trust frontmatter alone.
- For `skill_edit` with `auto_apply_eligible: true`: confirm `contradiction_flag` is absent or null in frontmatter. Refuse auto-apply if `contradiction_flag` is set with any non-empty value (treat the agent's flag as a hard veto on auto-apply; user can still manually approve in walk-the-queue if they disagree with the heuristic).
- For `memory`: confirm `# Proposed change` body starts with `---` frontmatter containing required fields `name`, `description`, `type`, `originSessionId`. Refuse if frontmatter missing — agent must redraft per the Memory drafting protocol.
- Confirm `source_entries` is present in proposal frontmatter as a non-empty list (used for archive). Warn (do not refuse) if missing — legacy proposals from before v0.2.0 won't have it.
-
-If any check fails, refuse to apply and ask the user how to proceed.
+```json
+{"ts":"<iso>","session":"<session_id>","keypoints":{"tool_selection":N,"scope_discipline":N,"error_recovery":N,"first_attempt":N,"build_reliability":N},"proposals_emitted":N,"proposals_applied":N}
+```

 ## Things you MUST NOT do

 - Do not auto-apply anything not in `high_confidence`.
+- Do not apply any proposal before you read apply-by-type.md and enforce its Karpathy constraints.
 - Do not invoke other skills during a `/reflect` run.
 - Do not modify `settings.json` without explicit user yes.
 - Do not hard-delete anything. Use `mv` to `~/.claude/adam/trash/<ts>/`.
@@ -0,0 +1,108 @@
+# Apply procedures by proposal type
+
+Read this file before any apply in SKILL.md §3a (auto-apply) or §4 (walk the queue).
+Every check here is mandatory. Section numbers (§N) refer to SKILL.md.
+
+## Contents
+
+- Karpathy constraints (every apply)
+- §3a auto-apply, per type
+- §3a after each auto-apply: move, A/B tracking, archive
+- §4 approve, per type
+- §4 reject and edit
+
+## Karpathy constraints (you must enforce on each apply)
+
+Before writing any proposal:
+
+- Confirm `# Assumptions` section is non-empty.
+- Confirm `# Diagnosis` section exists and contains all four labelled lines (`Trigger:`, `Action:`, `Mismatch:`, `Outcome:`) AND at least one backtick-wrapped quote ≤80 chars in the Outcome line. Refuse if missing or malformed — agent must redraft per the "Diagnosis drafting protocol" in `agents/adam.md`.
+- Confirm `# Success criterion` section is non-empty and runnable.
+- Confirm change is ≤50 LOC for non-`skill_new`, or ≤80 LOC for `skill_new` body. If larger, ask the user once: "this proposal is N LOC — proceed?"
+- For `claude_md_edit`: confirm 3+ distinct cwds in the `# Why` section.
+- For `deletion`: confirm both criteria (a) and (b) from the agent's special handling are documented in the proposal.
+- For `skill_new`: confirm the slug doesn't collide with any existing skill in `~/.claude/skills/`. If it does, refuse and ask user to rename.
+- For `skill_edit`: confirm the diff is append-only (no `-` lines that remove existing content) and that target SKILL.md exists. When auto-applying, ALSO re-verify the eligibility gate steps in §3 (cooldown, blacklist, byte cap) before any `Edit` call — never trust frontmatter alone.
+- For `skill_edit` with `auto_apply_eligible: true`: confirm `contradiction_flag` is absent or null in frontmatter. Refuse auto-apply if `contradiction_flag` is set with any non-empty value (treat the agent's flag as a hard veto on auto-apply; user can still manually approve in walk-the-queue if they disagree with the heuristic).
+- For `memory`: confirm `# Proposed change` body starts with `---` frontmatter matching the live auto-memory schema — top-level `name` (the slug) + `description`, plus a `metadata:` block with `node_type: memory`, `type`, and `originSessionId`. Cross-check the shape against an existing file in the target memory dir. Refuse if frontmatter is flat (`type:`/`originSessionId:` at top level) or missing the `metadata:` block — agent must redraft per the Memory drafting protocol.
+- For `harness_edit`: confirm `auto_apply_eligible: false` (never auto-apply). Confirm `confidence ≥ 5`. Confirm `# Test verification` section names the test command. Confirm diff is ≤30 LOC and targets a single allowed harness file (see `agents/adam.md` §"Harness self-modification"). Run test suite before AND after applying — revert on any regression.
+- Confirm `source_entries` is present in proposal frontmatter as a non-empty list (used for archive). Warn (do not refuse) if missing — legacy proposals from before v0.2.0 won't have it.
+
+If any check fails, refuse to apply and ask the user how to proceed.
+
+## §3a auto-apply, per type
+
+For each id that passed §3 verification, print `id`, `target`, `confidence`, `blast_radius`, `cross_session_evidence`, `auto_apply_eligible`. Then apply:
+
+- **`skill_new`**: `mkdir -p ~/.claude/skills/<slug>/`, then `Write` the proposal's `# Proposed change` body to `~/.claude/skills/<slug>/SKILL.md`. After write, print: "skill `<slug>` written to `~/.claude/skills/<slug>/SKILL.md` — activates immediately — Claude Code v2.1.0+ auto-hot-reloads user-level skills, no restart needed."
+- **`memory`**: `Write` the proposal's `# Proposed change` body (which MUST include the auto-memory frontmatter — see "Memory drafting protocol" in `agents/adam.md`) to the path in `target`. Then update `MEMORY.md` index with a one-line pointer.
+- **`nudge`**: low-blast auto-apply path. Single-session evidence is sufficient — skip the cross-session gate. Apply by invoking the helper (do NOT hand-write the JSON — the helper builds the message and the `cue` deterministically from frontmatter):
+
+  ```bash
+  node ~/.claude/adam/scripts/adam-apply-nudge.mjs ~/.claude/adam/proposals/<id>-*.md --home ~/.claude
+  ```
+
+  The proposal frontmatter MUST carry `type: nudge`, `source_session`, and `cwd` (the cluster's dominant `cwd`, from `adam-batch.mjs`'s per-batch `cwds`), plus `dead_end_count`. The helper appends one entry to `~/.claude/adam/active-nudges.json` (creating it if absent) with `cue: {cwd}` populated — so the reminder is query-conditioned: it surfaces at SessionStart *and* mid-session (via `adam-observe.mjs`) only when the user is working in that codebase. Output: `{"status":"applied"|"gated", ...}` — on `gated` leave the proposal in `proposals/`, on `applied` continue to archive. Do NOT modify any skill, memory, agent, or CLAUDE.md. Tell user: "nudge queued — surfaces when you return to `<cwd basename>` (expires in 7 days)."
+- **`reinforcement`**: gated by `confidence >= 4 AND blast_radius == low` (same as memory). Apply by invoking the helper:
+
+  ```bash
+  node ~/.claude/adam/scripts/adam-apply-reinforcement.mjs ~/.claude/adam/proposals/<id>-*.md --home ~/.claude
+  ```
+
+  The helper reads the proposal frontmatter (`skill_slug`, `count`, `source_session`) and appends one JSON line to `~/.claude/adam/reinforcements.jsonl`. No code/memory/skill modifications. Output: `{"status":"applied"|"gated", ...}`. On `gated`, leave the proposal in `proposals/` (the helper failed its own re-check). On `applied`, continue to the archive step. Tell user: "reinforcement logged for `<skill_slug>` (count=<N>) — appended to reinforcements.jsonl."
+- **`skill_edit`**: enforce the apply-time gate before writing.
+  1. Verify proposal frontmatter has `auto_apply_eligible: true`. If not, abort and queue for review.
+  2. Read `target` SKILL.md, capture `current_bytes` from a fresh stat — do NOT trust frontmatter `bytes_before`.
+  3. Verify diff in `# Proposed change`: unified-diff format, zero `-` lines on existing SKILL.md content (additions only), total `+` lines ≤ 30. If any check fails, print one-line refusal reason, leave proposal in `proposals/`, continue.
+  4. Cooldown re-check: run `node ~/.claude/adam/scripts/adam-cooldown.mjs --skill <target_skill> --fingerprint <proposal_fingerprint>` (both fields come from proposal frontmatter; missing fingerprint → "legacy"). Refuse if the script returns `status: cooldown` OR `status: blacklisted`. This per-(skill, fingerprint) gate replaces the previous coarse per-skill scan — proposals for the same skill with a different fingerprint are NOT blocked by an older entry. `adam-cooldown.mjs` returns `blacklisted` when `auto_apply_blacklist: true` is found in `rejected/` within 30 days for the same (skill, fingerprint).
+  5. Apply via `Edit` tool (append the new section per the diff). Never use `Write` on existing SKILL.md.
+  6. Re-stat target. If new size exceeds `2 * current_bytes` (captured in step 2), revert via `Edit` (remove the just-appended section) and refuse — print refusal reason.
+  7. Add `last_auto_edit: <iso8601 utc now>` to the proposal frontmatter before moving it.
+  8. Tell user: "skill `<slug>` extended (added <N> lines) — auto-applied via win-evidence gate."
+
+## §3a after each auto-apply: move, A/B tracking, archive
+
+1. Move proposal to `~/.claude/adam/applied/<UTC-ts>-<id>.md`.
+2. **A/B tracking append** (skip for `reinforcement` — positive-only ledger, intentionally not A/B-tracked per `agents/adam.md` §"`reinforcement` proposals"): as a separate atomic step right after the move, append one JSON line to `~/.claude/adam/ab-tracking.jsonl` (create with empty contents if absent). Read fields from the proposal's frontmatter (`proposal_fingerprint`, `originating_signals` — both populated per `agents/adam.md`; `originating_signals` is a list of `{type, count, session_ids}` objects). Schema:
+
+   ```json
+   {
+     "applied_at": <unix_ms now>,
+     "proposal_id": "<id>",
+     "proposal_type": "skill_edit|skill_new|memory|nudge",
+     "target_skill": "<slug or target basename>",
+     "proposal_fingerprint": "<hash>",
+     "originating_signals": [{"type":"<signal>","count":<N>,"session_ids":[...]}],
+     "pre_window_days": 7
+   }
+   ```
+
+   `adam-ab-measure.mjs` consumes this entry on later `/reflect` runs to compute pre/post signal-count deltas. See `agents/adam.md` §"A/B effectiveness". If the append fails (disk-full etc.), log a warning but do NOT abort the apply path — A/B is observability, not a gate.
+3. **Archive consumed journal entries**: `node ~/.claude/adam/scripts/adam-archive.mjs ~/.claude/adam/applied/<UTC-ts>-<id>.md`. This moves the entries listed in the proposal's `source_entries` from `journal.jsonl` to `journal/actioned-<id>.jsonl`, so later `/reflect` runs do not re-cluster them.
+
+After all ids, print: `auto-applied N proposals: [ids]`.
+
+## §4 approve, per type
+
+- **`claude_md_edit`**: back up first with `cp ~/.claude/CLAUDE.md ~/.claude/adam/applied/<ts>-claude-md-backup.md`.
+- **`deletion`**: `mkdir -p ~/.claude/adam/trash/<ts>`, then `mv` the artifact into it. Print the restoration command.
+- **`skill_new`**: `mkdir -p ~/.claude/skills/<slug>/`, then write the `# Proposed change` body to `<slug>/SKILL.md`. Tell user: "skill `<slug>` written — activates immediately (CC v2.1.0+ auto-hot-reload)."
+- **`skill_edit`**: apply the unified diff in `# Proposed change` to the existing SKILL.md at `target` (append-only — never replace existing content).
+- **`memory`**: write the `# Proposed change` body (must include auto-memory frontmatter) to `target` and update the `MEMORY.md` index with a one-line pointer.
+- **`harness_edit`** (MOSS §1): apply the unified diff to the target harness file. **Before applying**:
+  1. Run `bash ~/.claude/adam/tests/run-tests.sh` — capture pass count.
+  2. Apply the diff via `Edit`.
+  3. Run `bash ~/.claude/adam/tests/run-tests.sh` again — verify pass count is equal or higher and 0 failures.
+  4. If test regression: revert the edit, print "harness_edit reverted — test regression detected", leave proposal in `proposals/`.
+  5. If tests pass: tell user "harness edit applied to `<target>` — tests pass (<N> passed)."
+- **All other types**: apply via Write/Edit per the proposal's `# Proposed change`.
+
+Then:
+
+1. Move proposal to `~/.claude/adam/applied/<ts>-<id>.md`.
+2. Archive: `node ~/.claude/adam/scripts/adam-archive.mjs ~/.claude/adam/applied/<ts>-<id>.md`.
+
+## §4 reject and edit
+
+- **Reject**: ask for the reason in one line. Append `# Reason\n<reason>` to the proposal body. If the proposal `type` is `skill_edit`, ALSO add `auto_apply_blacklist: true` to its frontmatter (so future reflects skip auto-apply on this target for 30 days). Move to `~/.claude/adam/rejected/<id>.md`. Archive: `node ~/.claude/adam/scripts/adam-archive.mjs ~/.claude/adam/rejected/<id>.md`.
+- **Edit**: ask the user for the change, edit the proposal in place, then loop back to §4 step a for that same id.