fix(.agent): address post-merge codex review round

Written by Minimax-M2.7 in Claude Code Harness.

- [P1] write_candidates now does a claim-level terminal check
  against accepted lessons before the slug-based lifecycle
  lookup. Cluster-membership shifts can change `conditions`
  (intersection of shared tokens) and therefore the pattern id,
  so accepted patterns could re-stage under a new slug and bypass
  the "status=accepted = terminal" guard. Checking by claim text
  is stable regardless of id drift. Provisional and legacy
  lessons remain absent from the terminal set, so they still
  allow re-review.

- [P2] graduate.py now detects a partial-completion retry and
  completes the candidate move without re-appending to
  lessons.jsonl. Previously, if semantic writes succeeded but
  mark_graduated crashed, the next retry saw its own prior
  lesson in LESSONS.md and heuristic_check rejected it as a
  self-duplicate, leaving the candidate stuck. The retry path
  now recognizes the lesson_id already exists and skips
  duplicate-check + append, just finishing the move.

Author: codejunkie99

.agent/memory/promote.py

@@ -11,7 +11,7 @@
 import os, json, datetime, hashlib
 from cluster import content_cluster, extract_pattern
 from review_state import _lessons_sha
-from validate import extract_lesson_lines
+from validate import extract_lesson_lines, check_exact_duplicate
 
 
 def cluster_and_extract(entries, threshold=0.3):
@@ -87,6 +87,18 @@ def write_candidates(patterns, candidates_dir):
         claim = (p.get("claim") or "").strip()
         if not claim:
             continue
+
+        # Claim-level terminal check: if this exact claim is already an
+        # accepted lesson, skip regardless of slug. Cluster membership
+        # changes can shift the id (conditions = intersection, shrinks
+        # when outlier members join), so the slug-based graduated check
+        # below would miss an accepted pattern under a new id. This
+        # catches it by claim text, which IS stable. Provisional and
+        # legacy lessons don't appear in extract_lesson_lines, so they
+        # correctly do NOT block re-review.
+        if lessons_text and check_exact_duplicate(claim, lessons_text):
+            continue
+
         # Prefer the claim+conditions id from extract_pattern — stable slug
         # means lifecycle state carries across cluster membership changes.
         slug = _slug(p)

.agent/tools/graduate.py

@@ -13,7 +13,7 @@
 
 from review_state import mark_graduated
 from validate import heuristic_check
-from render_lessons import append_lesson, render_lessons
+from render_lessons import append_lesson, render_lessons, load_lessons
 
 CANDIDATES = os.path.join(BASE, "memory/candidates")
 SEMANTIC = os.path.join(BASE, "memory/semantic")
@@ -55,6 +55,28 @@ def main():
     with open(cand_path) as f:
         cand = json.load(f)
 
+    lesson_id = _lesson_id(cand)
+
+    # Retry-safety: if a prior graduation run got as far as appending to
+    # lessons.jsonl but crashed before the candidate move, the staged file
+    # still exists and the lesson is already recorded. Heuristic check
+    # would otherwise reject the retry as an exact duplicate of its own
+    # prior output, leaving the candidate stuck. Detect and complete the
+    # move without re-appending.
+    prior_lesson = next(
+        (l for l in load_lessons(SEMANTIC) if l.get("id") == lesson_id),
+        None,
+    )
+    if prior_lesson:
+        print(f"retry detected: lesson {lesson_id} already in lessons.jsonl; "
+              f"completing candidate move")
+        mark_graduated(
+            args.candidate_id, args.reviewer, args.rationale, CANDIDATES,
+            provisional=args.provisional,
+        )
+        print(f"graduated {args.candidate_id} → lesson {lesson_id} (retry)")
+        return
+
     lessons_md = os.path.join(SEMANTIC, "LESSONS.md")
     existing = open(lessons_md).read() if os.path.exists(lessons_md) else ""
     # When superseding, exclude the target lesson from the duplicate check —
@@ -73,13 +95,11 @@ def main():
 
     # Atomicity: write to semantic memory BEFORE moving the candidate.
     # If we crash mid-graduation, the staged candidate remains and the
-    # reviewer can retry. Append-only lessons.jsonl is deduped by id at
-    # render time, so a retry that re-appends produces one lesson bullet,
-    # not two. Crashing AFTER the move would leave the candidate lost and
-    # the lesson unlogged — the failure mode this reorder prevents.
+    # reviewer can retry. The retry-safety block above catches the
+    # specific "lesson appended but candidate not moved" scenario.
     accepted_at = datetime.datetime.now().isoformat()
     lesson = {
-        "id": _lesson_id(cand),
+        "id": lesson_id,
         "claim": cand.get("claim"),
         "conditions": cand.get("conditions", []),
         "evidence_ids": cand.get("evidence_ids", []),