diff --git a/.claude/tasks/contracts/2026-10-30-memory-upgrade-prose-closure-0105.md b/.claude/tasks/contracts/2026-10-30-memory-upgrade-prose-closure-0105.md new file mode 100644 index 0000000..3da4c67 --- /dev/null +++ b/.claude/tasks/contracts/2026-10-30-memory-upgrade-prose-closure-0105.md @@ -0,0 +1,33 @@ +# CONTRACT — memory-upgrade-prose-closure + +## REQUEST (verbatim — IMMUTABLE) +lib/memory.sh upgrade: _mem_upgrade_repair cements a v1 legacy-reader false-closed verdict as an explicit `- **Status (date, upgrade)**: resolved` line. Repro: orbistep (/home/bchanot/Documents/game) blockers.md BLK-021 (`date: 2026-09-20 · status: open …`, prose "another tab already resolved it" matched the case-insensitive legacy regex) and BLK-026 (`status: open (user: activate the Plus subscription)`) both get `resolved`; BLK-030 (`status: code resolved (df5818c) · SMTP open (upstream OVH)`) gets `resolved`; zenquality BLK-006 (`**Statut** : resolved (blockage), open (root delivery cause …)`) gets `resolved`. Second defect: the repair line is written twice when a `### BLK-008 UPDATE …` sub-heading repeats the ID (game BLK-008, blockers.md lines 102-103 after upgrade). The upgrade oracle cannot see it because the v1 reader already read these as closed, so the open set is "unchanged". After the fix: reset game and zenquality .claude/memory to HEAD on their chore/memory-v2 branches (user approved), re-apply game's 16-line heading fix, re-run upgrade, and verify. Also user-approved: record an open BLK in claude-config's blockers.md for this bug. + +## CLARIFICATIONS +- 2026-10-30 user: an ambiguous v1 closure (prose or mixed label) → upgrade refuses the file (rc 2) and names the ID, never guesses a status ("Refuser et nommer"). +- Plan r3: `.claude/tasks/plans/2026-10-30-memory-upgrade-prose-closure-0040.md` (fix plan steps 1-6 + R3 ADDENDUM race). The executor implements steps 1-5 + the race fix; step 6 is the oracle of criterion 4. The follow-up (resetting game/zenquality, statuses) is NOT in this diff. +- Diagnosis: BLK-038 (this repo's blockers.md). + +## ACCEPTANCE CRITERIA +1. The memory suite is green with every new T15 fixture of plan step 5 (a, b, b2, b3, c, d, d2, e, e2, e3, e4, g), each check named with the prefix listed here: T15-prose-refused, T15-mixed-date-refused, T15-mixed-statut-refused, T15-mixed-strict-boundary, T15-datestatus-word, T15-subhead-one-repair, T15-subhead-reopened, T15-remedy-roundtrip, T15-remedy-subhead, T15-dated-then-prose-refused, T15-range-continues, T15-oracle-dup-refused. + CHECK: cd /home/bchanot/Documents/claude && out=$(make test suite=lib/tests/memory.test.sh 2>&1) && printf '%s\n' "$out" | grep -q 'FAIL=0' && for n in T15-prose-refused T15-mixed-date-refused T15-mixed-statut-refused T15-mixed-strict-boundary T15-datestatus-word T15-subhead-one-repair T15-subhead-reopened T15-remedy-roundtrip T15-remedy-subhead T15-dated-then-prose-refused T15-range-continues T15-oracle-dup-refused; do grep -q "$n" lib/tests/memory.test.sh || exit 1; done && echo MEMORY-SUITE-OK + EXPECT: MEMORY-SUITE-OK + EVIDENCE: MET exit=0 marker-found :: MEMORY-SUITE-OK +2. The reconcile suite stays green and lib/reconcile.sh is unchanged (reconcile's default 2-arg v1 reader is out of scope). + CHECK: cd /home/bchanot/Documents/claude && git diff --quiet develop -- lib/reconcile.sh && out=$(make test suite=lib/tests/run-reconcile.sh 2>&1) && printf '%s\n' "$out" | grep -q ' 0 RED' && echo RECONCILE-OK + EXPECT: RECONCILE-OK + EVIDENCE: MET exit=0 marker-found :: RECONCILE-OK +3. lib/memory.sh is shellcheck-clean and no added line exceeds 80 columns. + CHECK: cd /home/bchanot/Documents/claude && shellcheck lib/memory.sh && [ "$(git diff develop -- lib/memory.sh | grep '^+' | grep -v '^+++' | awk 'length($0) > 81' | wc -l)" = 0 ] && echo LINT-OK + EXPECT: LINT-OK + EVIDENCE: MET exit=0 marker-found :: LINT-OK +4. Real data (plan step 6): replaying the upgrade with the working-tree lib on the 13 repos' pre-upgrade registries refuses exactly orbistep blockers.md (BLK-021, BLK-026, BLK-030 named) and zenquality blockers.md (BLK-006 named), leaves both files byte-identical, and reproduces every other registry byte-for-byte; no entry carries two upgrade lines. Positive control done 2026-10-30 on the unfixed lib: rc 1 (config BLK-003 race line, game/zenquality not refused, BLK-008 duplicate). + CHECK: bash /tmp/claude-1000/-home-bchanot-Documents-claude/a1113f35-c77c-47c4-95de-a37231ae0306/scratchpad/up4a/realdata.sh /home/bchanot/Documents/claude + EXPECT: REALDATA-OK + EVIDENCE: MET exit=0 marker-found :: work dir: /tmp/claude-1000/-home-bchanot-Documents-claude/a1113f35-c77c-47c4-95de-a37231ae0306/scratchpad/up4a/realdata.5uaw REALDATA-OK +5. The repair names on stderr every ID it writes (with its v1 line) and every ID it refuses (with its v1 line and the `memory.sh status …` remedy); `explicit` rows are named once and never refuse. Judged by the verifier from the code and fixture stderr assertions. +6. The v1-open / strict-closed direction (BLK-032..034 fix, BDR-129) is unchanged: such rows are still kept and named, never repaired. Judged by the verifier (existing tests stay green). + +## FILE SCOPE +- lib/memory.sh (memory_legacy_status `` branch, _mem_verdict_diff, _mem_upgrade_repair, _mem_upgrade_oracle; the header comment if the upgrade contract text changes) +- lib/tests/memory.test.sh (T15 additions) diff --git a/.claude/tasks/plans/2026-10-30-memory-upgrade-prose-closure-0040.md b/.claude/tasks/plans/2026-10-30-memory-upgrade-prose-closure-0040.md new file mode 100644 index 0000000..edae9e4 --- /dev/null +++ b/.claude/tasks/plans/2026-10-30-memory-upgrade-prose-closure-0040.md @@ -0,0 +1,155 @@ +# /bugfix memory-upgrade-prose-closure — DIAGNOSIS + FIX PLAN r2 (BLK-038) + +r2 2026-10-30 after 3 lenses: robustness FATAL(4), correctness FATAL(2), +simplicity CONCERNS(1). Changes vs r1 named in § R2 CHANGES. + +## Bug +`bash lib/memory.sh upgrade` (v1 → v2) writes `- **Status (, upgrade)**: resolved` +under blockers that are open, and writes it twice when a sub-heading repeats the ID. +Seen 2026-10-30 on orbistep (`/home/bchanot/Documents/game`, HEAD of chore/memory-v2): +BLK-021 (`date: 2026-09-20 · status: open …`, "Fix direction (not decided)"), +BLK-030 (`date: 2026-10-17 | status: code resolved (df5818c) · SMTP open (upstream +OVH)`) get `resolved`; BLK-008 gets it twice (its body holds `### BLK-008 UPDATE …`). +zenquality BLK-006 (`- **Statut** : resolved (blockage), open (root delivery cause …)`) +gets `resolved`. The oracle reported the open set unchanged: both its readers agreed. + +## Root cause +- `_mem_upgrade_repair` (lib/memory.sh ~644) writes the v1 verdict for every blocker + `_mem_verdict_diff` reports "v1 closed, strict open". The v1 verdict comes from + `memory_legacy_status` (~592): LAST entry line matching `_MEM_LEGACY_RE`, then + `_mem_legacy_open` says closed when it contains `resolved`/`RESOLVED`. Prose and + mixed lines qualify. A lexical guess becomes an explicit status line. +- `_mem_verdict_diff` (~630) iterates `_mem_heading_ids "$2" BLK` (any heading level): + `### BLK-008 UPDATE` yields BLK-008 twice → two inserts. +- Upgrade's v1 range (`_mem_legacy_open`, end `'^##* *BLK-[0-9]'`) stops at a + same-ID `### BLK-x …` sub-heading, while reconcile's v1 reader and the strict reader + continue: a later `Status: open, reopened` under the sub-heading is unseen by upgrade. + +## Evidence +Scratchpad classify over the 13 repos' pre-upgrade blockers: prose or mixed v1 +closures exist (orbistep BLK-021 really open, BLK-026 prose addendum really resolved, +BLK-030 mixed, zenquality BLK-006 mixed). BLK-021 and BLK-026 share a shape with +opposite truth: no lexical rule decides prose. User decision 2026-10-30: refuse and +name, never guess. + +## Fix plan (r2) +1. `memory_legacy_status` with `` (upgrade-only branch; reconcile's default + 2-arg branch untouched): a heading matching `` whose ID equals the entry's ID + does NOT end the range (same-ID `###` sub-heading = continuation). Pass the ID to + awk through ENVIRON or the existing `-v id` (an ID, not free text). +2. `_mem_verdict_diff`: (a) iterate unique IDs, first-occurrence order; (b) an ID + whose v1 line from OLD (`memory_legacy_status "$1" "$id" '^##* *BLK-[0-9]'`, step-1 + range) is BYTE-EQUAL to the strict winning candidate in NEW, and that line matches + `^- \*\*Status \([0-9]` and does not contain `, upgrade)`, is an explicit status + written by `memory.sh status`: emit row `IDexplicit` (strict wins). The repair + names `explicit` rows once on stderr and writes nothing; the oracle's filter stays + `$2 == "resolved"`, so `explicit` never refuses. A dated line followed by a later + prose closure is NOT byte-equal to the v1 line → normal path → refused (never a + guess). Index-derived `, upgrade)` lines are already excluded by the `ix` skip + (`_mem_index_stated`) and by the `, upgrade)` filter (not by timing: r2 claimed they + did not exist yet, false, `_mem_upgrade_text` writes them before repair). +3. `_mem_upgrade_repair`, for each `resolved` row: read the v1 line once + (`memory_legacy_status "$1" "$id" '^##* *BLK-[0-9]'`). Labelled = the line holds a + `status`/`statut` label (case-insensitive, `[^a-z:]*:` then optional `*`/spaces) + AND the label's value holds exactly ONE distinct `_MEM_WORDS` word AND that word is + closed (memory_closed). Labelled → insert `- **Status (, upgrade)**: ` and name the ID + v1 line on stderr (every write visible at the approval). + Not labelled → no insert; stderr: `memory: : v1 closed by an unlabelled or mixed + line, status unknown: ` + remedy `record it from the project root: + memory.sh status ", …" (the leading word decides), then re-run upgrade`. +4. `_mem_upgrade_oracle`: keep the existing verdict refusal unchanged (it refuses any + ID still v1-closed / strict-open after repair → unlabelled ones refuse the file, + rc 2, file left as it was). ADD an independent entry-level assert not using + `_mem_verdict_diff`: at most one `, upgrade)**:` line per entry ID in the new file + (heading of the entry = `## ID `), else `memory: upgrade lost: :dup` rc 2. +5. Tests, lib/tests/memory.test.sh T15 (fixtures via `v1blk`; remedy cases under + `d15//.claude/memory` and `-C d15/`, the relpath pattern): + a. `## BLK-001 — x` / `date: 2026-09-20 · status: open` / `prose: another tab already + resolved it` → rc 2, file byte-identical, stderr names BLK-001 and the remedy. + b. `date: 2026-10-17 | status: code resolved (abc) · SMTP open` → rc 2. + b2. `- **Statut** : resolved (x), open (y)` → rc 2. + b3. boundary: `status: code resolved (abc) · SMTP open` (strict candidate, both + readers closed) → rc 0, no `upgrade)` line. + c. existing T15-datestatus fixture: add a `memory_word_of` assert = resolved. + d. `## BLK-008 — x` / `date: 2026-07-20 · status: RESOLVED 2026-07-20` / `### BLK-008 + UPDATE 2026-07-20 (y)` / `body` → rc 0, exactly one `upgrade)` line. + d2. same with `Status: open, reopened` under the `###` → rc 0, no `upgrade)` line, + strict open. + e. remedy round trip on (a)'s shape: `memory.sh -C d15/e status BLK-001 "upstream, + SMTP OVH; code resolved (x)"` then `memory.sh -C d15/e upgrade` → rc 0, strict + word upstream, no `upgrade)` line. + e2. same remedy on an entry with a `### BLK-001 UPDATE` sub-heading → rc 0. + (r3: fixture f dropped: a v1-closed line always holds `resolved`, so the single + closed word written is in practice `resolved`; the code still writes the word it + found.) + e3. dated line then later prose closure: `## BLK-001 — x` / `date: x · status: open` + / `- **Status (2026-10-30)**: open, waiting` / `later prose: fixed, resolved in + abc` → rc 2 (no `explicit` skip: v1 line is the prose). + e4. step-1 guard: e2's shape WITHOUT the remedy line, prose closure above the + `### BLK-001 UPDATE` and `Status: open, reopened` below it → rc 0, no + `upgrade)` line (fails if the range still stops at the sub-heading). + g. oracle dup assert: a built text with two `upgrade)` lines under one ID is refused + (tamper pattern, T15-tamper style). +6. Real-data proof before merge-ready (main loop, scratchpad, `MEMORY_DATE=2026-10-30` + = the live pass date). Per repo a fresh `mktemp -d` project with + `.claude/memory` filled from: + - committed repos (config, integration_alphalink, robin_petier, trucks_at_work, + bchanot-cv, game-deploy, gitea-deploy, angelscar356, for_you, nuit-folle): `git + show ^:.claude/memory/.md`; trucks_at_work gets the 3 bullet + Indexes dropped first (live precondition). Baseline = `git show + :…` (robin_petier: 88f8dbc, before its status-line commit; + trucks_at_work: 17536ce minus the BLK-001 status line and journal line). + - orbistep: `git show HEAD:` of chore/memory-v2 + the live 16-line heading sed + (precondition); baseline = its current working tree (uncommitted upgrade). + - zenquality: `git show HEAD:` of chore/memory-v2; baseline = its working tree. + - faunosteo: `git show 81f7639:`; baseline = scratchpad fauno.6sTi/after. + Run `memory.sh -C upgrade`. Expected: orbistep blockers.md refused + naming BLK-021, BLK-026, BLK-030; zenquality blockers.md refused naming BLK-006; + every other registry rc 0 and byte-identical to its baseline (journal excluded: the + live pass appended a line). Any other difference is reported, not waived. + +## R2 CHANGES +- Classifier moved from `_mem_verdict_diff` into `_mem_upgrade_repair`; no `unclear` + protocol word; oracle verdict check unchanged (simplicity 1). +- Labelled = exactly one distinct status word, closed (robustness 1: zenquality + BLK-006); repair writes that word (robustness 5, correctness 5, simplicity 3). +- Dated `Status (date)` lib lines win over the v1 reader in `_mem_verdict_diff` + (correctness 2, robustness 3): the remedy converges even when its text says + "resolved". +- Same-ID sub-heading continues the upgrade's v1 range (robustness 4, correctness 3, + simplicity 5); fixtures d2, e2. +- Every repair write named on stderr + independent dup assert in the oracle + (robustness 2, correctness 6). +- Fixture shapes fixed: b with `date: … |` prefix, b3 boundary, remedy under + `.claude/memory` with `-C` (correctness 1, 4; simplicity 4); old 3c folded into the + datestatus fixture (simplicity 2). +- Real-data run over the 13 copies with `-C` (correctness 7, LRN-237). +- Remedy message names the project-root invocation (robustness 6). + +## R3 ADDENDUM — race found while building the step-6 oracle (main loop, 2026-10-30) +`_mem_upgrade_repair` reads `_mem_verdict_diff "$1" "$2"` through `< <(…)` while +`_mem_insert` rewrites "$2" in place (`cat "$tmp" > "$1"`, memory.sh ~288): the diff's +readers can see a torn file and report an extra blocker. Measured on config's +pre-upgrade blockers (4dc8e77): stage-by-stage trace = 2 rows (BLK-002, BLK-004); the +CLI upgrade = 3 repair lines (BLK-003 extra, its `Status: SUPERSEDED …` line is a +strict candidate, so it is never a real verdict move), 6 of 6 runs; the live run +345ee68 wrote 2. Fix: step 3 captures the full diff into a variable BEFORE the first +insert, then loops over it. Covered by the step-6 oracle (config replay must equal +345ee68); a unit test cannot force the interleaving deterministically. + +## R3 CHANGES (confirmation pass correctness FATAL(3), folded without a 3rd pass) +- Fixture f dropped (unreachable); repair word in practice `resolved` (C1). +- Step 2b skip only when OLD v1 line byte-equals NEW strict winner, dated, not + `, upgrade)`; row `explicit`, named once by the repair; new fixtures e3, e4 (C2, C4). +- Rationale for `, upgrade)` exclusion corrected (C5). +- Step 6 sources, preconditions, MEMORY_DATE and baselines named per repo (C3). + +## Out of scope +reconcile's default v1 reader, the strict parser, heading normalization, other parked +4a minors. + +## Follow-up after the fix (not in this diff) +Reset orbistep and zenquality `.claude/memory` to HEAD on chore/memory-v2 (user +approved), re-apply orbistep's 16-line heading fix, ask the user the real status of +orbistep BLK-021/026/030 and zenquality BLK-006, write them with `memory.sh status`, +re-run upgrade; regenerate the faunosteo patch with the fixed lib.