Files
claude/lib/reconcile.sh
T
bchanot 99f10b2a26 feat(prune-memory): read statuses through one classifier, v1 and v2
reconcile_status_classify generalizes the BLK classifier to a prefix; STEP 1
runs it on decisions and blockers, unreadable statuses are an info-only count.
RED-9 runs the shipped block on v1 and v2 fixtures.
2026-11-12 00:11:03 +01:00

186 lines
8.3 KiB
Bash
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env bash
# reconcile.sh — deterministic engine for /reconcile.
#
# Confronts DECLARATIVE sources (TODO checkboxes, registry statuses) against
# REAL state (git, fs, registry BODY). It is the engine behind the /reconcile
# skill; the skill orchestrates + gates, this file holds the mechanical
# truth-probes.
#
# FOUNDING PRINCIPLE — recursive coherence (LRN-055): a reconciler must NEVER
# trust a declarative source as an oracle. So this engine NEVER reads the
# `## Index` table nor believes a `[x]`/`[ ]` checkbox; it enumerates registry
# entries from the BODY `## ID —` headings and decides "done/stale" from
# git/fs only. It practices what it preaches — the recursive-coherence test
# (run-reconcile.sh T1) reds if this is broken.
# v2 registries carry no Index at all (lib/memory.sh); v1 ones still may.
#
# HONEST LIMITS (graven, do not over-read):
# - Deferral detection is LEXICAL (reconcile_deferrals): it catches
# deferrals MARKED by a keyword, misses ones phrased without one ("à
# reprendre quand X"). Deterministic on the detectable; the skill
# SURFACES the ambiguous for human review, never asserts.
# - Contradiction detection surfaces CANDIDATES (token overlap), never
# asserts a verdict.
#
# Layers:
# reconcile_enumerate_ids — body-only `## ID` heading enumeration
# (recursive-coherence core); v1 `###` entries
# are invisible to it
# reconcile_oracle_* — live git/fs truth probes
# reconcile_blk_current_status — registry status: lib/memory.sh shared
# parser on v2, legacy lexical reader on v1
# reconcile_blk_open — blockers whose CURRENT status is not closed
# (resolved | superseded | deprecated on v2)
# reconcile_status_classify — entries of any prefix (BLK, BDR): open
# (word) | unreadable, closed omitted
# reconcile_blk_classify — its BLK wrapper, for a client deliverable
# reconcile_verdict — pure kernel: declared checkbox × real fact
# → verdict
# reconcile_deferrals — lexical deferral sweep (honest limit)
# reconcile_contradiction_candidates — accepted-BDR ⇄ open-chantier token
# overlap (surface)
set -uo pipefail
# LRN-074: pin grep, never assume GNU flags
RECONCILE_GREP="${RECONCILE_GREP:-/usr/bin/grep}"
# the status parser and classifier are shared with lib/memory.sh (BDR-125 4a)
# shellcheck source=/dev/null
. "$(dirname "${BASH_SOURCE[0]}")/memory.sh"
# markers that LEXICALLY signal a deferral/follow-up (honest limit: marked-only)
RECONCILE_DEFER_RE='[Dd]efer|[Ff]ollow-?up|[Oo]ut.of.scope|OUT-OF-SCOPE'
RECONCILE_DEFER_RE+='|[Rr]econsider|[Rr]evisit|2e passage|won.t.do'
RECONCILE_DEFER_RE+='|optional\)|one-line ticket'
# v1 decisions carry `**Statut** :` and `Superseded by …` lines the blocker
# selector skips; an unlabelled winner stays unreadable (_mem_v1_word)
RECONCILE_BDR_RE="$_MEM_LEGACY_RE|statut|superseded|deprecated"
# --- recursive coherence: enumerate IDs from the BODY, never the ## Index ---
# $1 registry file, $2 prefix (BDR|LRN|BLK|EVAL). Emits one id per line, unique.
reconcile_enumerate_ids() {
"$RECONCILE_GREP" -oE "^## ${2}-[0-9]+" "$1" \
| "$RECONCILE_GREP" -oE "${2}-[0-9]+" | sort -u
}
# --- live truth probes (query the REAL repo/fs; the "verify, don't believe"
# core) ---
reconcile_oracle_tree_clean() { # rc 0 = working tree clean
[ -z "$(git -C "${1:-.}" status --porcelain 2>/dev/null)" ]
}
# $1 repo, $2 branch fragment → rc 0 if a merge commit exists
reconcile_oracle_merge_done() {
[ -n "$(git -C "${1:-.}" log --oneline --grep "Merge .*$2" -1 2>/dev/null)" ]
}
# $1 repo, $2 branch → rc 0 if nothing unpushed vs origin
reconcile_oracle_pushed() {
[ -z "$(git -C "${1:-.}" rev-list "origin/$2..$2" 2>/dev/null)" ]
}
# $1 repo, $2 sha → rc 0 if the commit object exists
reconcile_oracle_sha_exists() {
git -C "${1:-.}" cat-file -e "${2}^{commit}" 2>/dev/null
}
# $1 repo, $2 grep → rc 0 if a commit message matches
reconcile_oracle_msg_committed() {
[ -n "$(git -C "${1:-.}" log --oneline --grep "$2" -1 2>/dev/null)" ]
}
# $1 path → rc 0 if it still exists on disk
reconcile_oracle_path_present() { [ -e "${1:?}" ]; }
# --- registry status: LAST candidate wins (the BLK-008 trap A fell into) ---
# $1 blockers file, $2 id. A v2 registry (lib/memory.sh): the entry's own
# header `[tag]` or a labelled body line, never a status word in prose or in
# the title (the BLK-032..034 false-open). A v1 registry keeps the lexical
# reader (memory_legacy_status): its dialects (title suffix `— RESOLVED`,
# `date: … · status:`, `**Statut** :`) carry status where the strict parser
# cannot see it.
reconcile_blk_current_status() {
if memory_is_v2 "$1"; then memory_entry_status "$1" "$2"; return; fi
MEM_GREP="$RECONCILE_GREP" memory_legacy_status "$1" "$2"
}
# blockers whose CURRENT status does not close them → "id<TAB>status".
# v2: memory_closed (resolved | superseded | deprecated); v1: the substring.
reconcile_blk_open() {
local id st v2=""
memory_is_v2 "$1" && v2=1
for id in $(reconcile_enumerate_ids "$1" BLK); do
st=$(reconcile_blk_current_status "$1" "$id")
if [ -n "$v2" ]; then
memory_closed "$(memory_status_word "$st")" && continue
else
case "$st" in *RESOLVED*|*resolved*) continue ;; esac
fi
printf '%s\t%s\n' "$id" "$st"
done
}
_reconcile_status() { # <file> <ID> <PREFIX> → the current status line
[ "$3" = BLK ] && { reconcile_blk_current_status "$1" "$2"; return; }
if memory_is_v2 "$1"; then memory_entry_status "$1" "$2"; return; fi
MEM_GREP="$RECONCILE_GREP" MEM_LEGACY_RE="$RECONCILE_BDR_RE" \
memory_legacy_status "$1" "$2" "^##* *$3-[0-9]"
}
# entries of one prefix (BLK blockers, BDR decisions) → "id<TAB>open|
# unreadable<TAB>word or line"; closed ones are omitted. A status no
# reader maps to exactly one known word is unreadable, never open
# (BDR-129, BDR-133): v2 strict word, v1 the single word of a
# status/statut label (_mem_v1_word: prose, mixed or negated lines give
# none). Entries under a heading the enumerator cannot see (`### BLK-`)
# are unreadable too.
# $1 file, $2 prefix. The status source: _reconcile_status.
reconcile_status_classify() {
local id st w v2=""
memory_is_v2 "$1" && v2=1
for id in $(reconcile_enumerate_ids "$1" "$2"); do
st=$(_reconcile_status "$1" "$id" "$2")
if [ -n "$v2" ]; then w=$(memory_status_word "$st")
else w=$(_mem_v1_word "$st"); fi
[ -n "$st" ] || w=""
memory_closed "$w" && continue
case " $_MEM_WORDS " in
*" $w "*)
[ -n "$w" ] && { printf '%s\topen\t%s\n' "$id" "$w"; continue; } ;;
esac
printf '%s\tunreadable\t%s\n' "$id" "${st:0:80}"
done
MEM_GREP="$RECONCILE_GREP" _mem_heading_ids "$1" "$2" | sort -u \
| comm -23 - <(reconcile_enumerate_ids "$1" "$2") \
| while read -r id; do printf '%s\tunreadable\theading level\n' "$id"; done
return 0
}
reconcile_blk_classify() { reconcile_status_classify "$1" BLK; }
# --- pure reconciliation kernel: declared checkbox × real fact → verdict
# (no git, fully testable) ---
# $1 checkbox char (x| |~), $2 real_done (true|false).
reconcile_verdict() {
case "$1:$2" in
" :true") echo "STALE:open-but-done" ;;
"x:false") echo "STALE:done-but-open" ;;
"~:true") echo "STALE:partial-but-done" ;;
*) echo "CONSISTENT" ;;
esac
}
# --- lexical deferral sweep (HONEST LIMIT: marked-only)
# → "src<TAB>line<TAB>text" ---
reconcile_deferrals() {
[ -f "$1" ] && "$RECONCILE_GREP" -nE "$RECONCILE_DEFER_RE" "$1" 2>/dev/null \
| sed 's/^/TODO\t/'
[ -f "$2" ] && "$RECONCILE_GREP" -nE "$RECONCILE_DEFER_RE" "$2" 2>/dev/null \
| sed 's/^/BDR\t/'
return 0
}
# --- contradiction CANDIDATES (surface, never assert): CLI-flag token shared
# by a BDR + the TODO ---
# $1 decisions file, $2 todo file. CLI-flag-like tokens are distinctive enough
# to flag for review.
reconcile_contradiction_candidates() {
local tok why=' in a BDR title and an open TODO chantier'
why+=' — review for contradiction'
for tok in $("$RECONCILE_GREP" -oE '\-\-[a-z][a-z-]+' "$1" 2>/dev/null \
| sort -u); do
"$RECONCILE_GREP" -qF -- "$tok" "$2" 2>/dev/null \
&& printf 'CANDIDATE\t%s\tflag "%s"%s\n' "$tok" "$tok" "$why"
done
return 0
}