@friedbotstudio/create-baseline 0.2.1 → 0.4.0

package/obj/template/.claude/skills/memory-flush/sweep.py

@@ -1,17 +1,23 @@
 #!/usr/bin/env python3
-"""Deterministic Step 0 helper for /memory-flush.
+"""Deterministic actuator for /memory-flush Step 0 and for /commit Step 6.
 
 Scans canonical memory files for closure fields and prose closure signals,
 applies the matching action (auto-close / surface-and-confirm / stale-sweep),
-and emits a JSON action report. Invoked by SKILL.md Step 0 and exercised by
+and emits a JSON action report. Also exposes a non-interactive stamp-closure
+mode invoked by /commit (Phase 11, Step 6) to write status: picked-up +
+superseded-at: today on backlog entries named in workflow.json →
+source_backlog_keys. Invoked by SKILL.md Step 0 (auto-close / prose-scan /
+stale-sweep) and by commit/SKILL.md Step 6 (stamp-closure). Exercised by
 the fixture tests at .claude/skills/memory-flush/tests/run.sh.
 
 CLI:
-  --mode {auto-close, prose-scan, stale-sweep}
+  --mode {auto-close, prose-scan, stale-sweep, stamp-closure}
   --memory-dir <path>
+  --backlog-keys <csv>   (required iff --mode stamp-closure)
 
 For interactive modes (prose-scan, stale-sweep), one reply per surfaced entry
-is read from stdin. Empty stdin / EOF defaults to "keep".
+is read from stdin. Empty stdin / EOF defaults to "keep". stamp-closure is
+non-interactive; --backlog-keys is the input channel.
 """
 from __future__ import annotations
 import argparse
@@ -27,9 +33,16 @@ from pathlib import Path
 CANONICAL_FILES = [
     'landmarks', 'libraries', 'decisions',
     'landmines', 'conventions', 'pending-questions',
+    'backlog',
 ]
 PENDING_FILE = 'pending-questions'
 
+# Files whose entries do NOT stale-age. Backlog is intent, not a verifiable
+# fact about code state, so commit-distance and day-count are meaningless
+# signals. Closure is still tracked via superseded-at: per the canonical
+# closure-field-per-file rule.
+STALE_EXEMPT_FILES = {'backlog'}
+
 STALE_COMMITS = 30
 STALE_DAYS = 30
 
@@ -153,6 +166,8 @@ def prose_matches(block: str) -> bool:
     return any(p.search(block) for p in PROSE_PATTERNS)
 
 def is_stale(block: str, name: str, head: str, root: Path) -> bool:
+    if name in STALE_EXEMPT_FILES:
+        return False
     if is_closed(block, name):
         return False
     stamp = read_field(block, 'verified-at')
@@ -225,6 +240,50 @@ def mode_prose_scan(memdir: Path) -> dict:
             write_file(memdir, name, new_text)
     return report
 
+def mode_stamp_closure(memdir: Path, keys_csv: str) -> dict:
+    """Stamp the named backlog entries with status: picked-up + superseded-at: today.
+
+    Idempotent: re-running on already-stamped entries rewrites superseded-at:
+    to today and reports them under `already_closed`. Entries the caller named
+    that aren't present in backlog.md go into `missing`. The next /memory-flush
+    Step 0a auto-close sweep deletes the stamped entries per the existing
+    superseded-at: closure-trigger contract.
+    """
+    report = {'stamped': 0, 'missing': [], 'already_closed': []}
+    keys = [k.strip() for k in keys_csv.split(',') if k.strip()]
+    if not keys:
+        return report
+    text = read_file(memdir, 'backlog')
+    if not text:
+        report['missing'] = list(keys)
+        return report
+    new_text = text
+    today = date.today().isoformat()
+    for key in keys:
+        block = _find_entry_block(new_text, key)
+        if block is None:
+            report['missing'].append(key)
+            continue
+        was_stamped = (read_field(block, 'status') or '').strip() == 'picked-up'
+        updated = update_field(block, 'status', 'picked-up')
+        updated = update_field(updated, 'superseded-at', today)
+        new_text = new_text.replace(block, updated)
+        if was_stamped:
+            report['already_closed'].append(key)
+        else:
+            report['stamped'] += 1
+    if new_text != text:
+        write_file(memdir, 'backlog', new_text)
+    return report
+
+
+def _find_entry_block(text: str, key: str):
+    for entry_key, block in split_entries(text):
+        if entry_key == key:
+            return block
+    return None
+
+
 def mode_stale_sweep(memdir: Path) -> dict:
     report = {'reverified': 0, 'deleted': 0, 'mark_closed': 0, 'kept': 0}
     root = memdir.parent.parent
@@ -267,18 +326,27 @@ MODE_DISPATCH = {
     'auto-close': mode_auto_close,
     'prose-scan': mode_prose_scan,
     'stale-sweep': mode_stale_sweep,
+    'stamp-closure': mode_stamp_closure,
 }
 
 def parse_args(argv):
     p = argparse.ArgumentParser(description='Memory Step 0 sweep helper')
     p.add_argument('--mode', required=True, choices=list(MODE_DISPATCH))
     p.add_argument('--memory-dir', required=True)
-    return p.parse_args(argv)
+    p.add_argument('--backlog-keys', default=None,
+                   help='CSV of backlog stable keys; required when --mode stamp-closure')
+    args = p.parse_args(argv)
+    if args.mode == 'stamp-closure' and args.backlog_keys is None:
+        p.error('--backlog-keys is required when --mode stamp-closure')
+    return args
 
 def main(argv) -> int:
     args = parse_args(argv)
     memdir = Path(args.memory_dir).resolve()
-    report = MODE_DISPATCH[args.mode](memdir)
+    if args.mode == 'stamp-closure':
+        report = mode_stamp_closure(memdir, args.backlog_keys or '')
+    else:
+        report = MODE_DISPATCH[args.mode](memdir)
     print(json.dumps(report))
     return 0
 

package/obj/template/.claude/skills/memory-flush/tests/run.sh

@@ -62,7 +62,7 @@ sweep() {
 seed_skel() {
   local mem="$1"
   mkdir -p "$mem"
-  for f in landmarks libraries decisions landmines conventions pending-questions; do
+  for f in landmarks libraries decisions landmines conventions pending-questions backlog; do
     cat > "$mem/$f.md" <<EOF
 ---
 owners: [test]
@@ -304,6 +304,289 @@ test_when_pre_spec_entry_no_source_no_verbatim_then_grandfathered() {
   assert_file_contains "$mem/conventions.md" "## legacy-entry" "AC-006 grandfathered legacy entry survives" || return 1
 }
 
+# --- Phase 10.6 (memory-flush-phase) regression traps -------------------------
+# Confirms sweep.py stays scoped to canonical files and does not touch _pending.md
+# regardless of whether _pending.md body is empty (the fast-path case).
+
+PENDING_SKELETON='---
+owners: [memory_stop.sh writes; /memory-flush clears]
+category: auto-extracted candidates awaiting curation
+verifies-against: none
+---
+
+# Pending memory candidates
+
+Auto-extracted by `memory_stop.sh`. Run `/memory-flush` to review.
+
+**Content of this file is gitignored.**
+
+---
+'
+
+seed_pending_skeleton() {
+  printf '%s' "$PENDING_SKELETON" > "$1/_pending.md"
+}
+
+test_when_pending_empty_then_sweep_does_not_touch_pending() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  seed_pending_skeleton "$mem"
+  local before; before="$(cat "$mem/_pending.md")"
+  sweep auto-close "$mem" >/dev/null || { fail "sweep crashed on empty pending"; return 1; }
+  sweep prose-scan "$mem" "" >/dev/null || { fail "sweep crashed on empty pending"; return 1; }
+  sweep stale-sweep "$mem" "" >/dev/null || { fail "sweep crashed on empty pending"; return 1; }
+  local after; after="$(cat "$mem/_pending.md")"
+  if [ "$before" = "$after" ]; then return 0; fi
+  fail "_pending.md mutated by sweep.py — sweep must stay scoped to canonical files"
+  diff <(printf '%s' "$before") <(printf '%s' "$after") || true
+  return 1
+}
+
+test_when_pending_empty_AND_q999_has_resolved_at_then_q999_is_swept() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  seed_pending_skeleton "$mem"
+  add "$mem" "pending-questions" "## Q-999
+
+- Question: fast-path canonical-sweep regression trap
+- verified-at: HEAD
+- last-touched: $(today)
+- resolved-at: 2026-05-17"
+  local report; report="$(sweep auto-close "$mem")" || { fail "sweep crashed"; return 1; }
+  assert_file_not_contains "$mem/pending-questions.md" "## Q-999" "Q-999 must be auto-closed even when _pending.md is empty" || return 1
+  assert_contains "$report" '"closed": 1' "expected closed count 1 (got: $report)" || return 1
+}
+
+# --- backlog-memory-bucket: routing + bootstrap + stale-exempt + verbatim ----
+# Covers AC-005, AC-006, AC-007, AC-009, AC-011 from
+# docs/specs/backlog-memory-bucket.md. All start RED until sweep.py adds
+# 'backlog' to CANONICAL_FILES + STALE_EXEMPT_FILES, and README.md documents
+# the new register.
+
+test_when_promote_user_candidate_writes_canonical_entry_with_status_open_and_verbatim() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  # Curator-style entry: the shape /memory-flush would write on promotion.
+  add "$mem" "backlog" "## add-retry-to-webhook-worker-3f2a
+
+> verbatim (user, $(today)):
+> TODO: add retry to webhook worker
+
+- source: user-instruction
+- status: open
+- raised-on: $(today)
+- raised-in-context: backlog-memory-bucket
+- verified-at: HEAD
+- last-touched: $(today)"
+  # Auto-close should NOT touch this entry (no closure field present).
+  local report; report="$(sweep auto-close "$mem")" || { fail "AC-005 sweep crashed"; return 1; }
+  assert_file_contains "$mem/backlog.md" "## add-retry-to-webhook-worker-3f2a" "AC-005 open entry must survive auto-close" || return 1
+  assert_file_contains "$mem/backlog.md" "status: open" "AC-005 status:open missing" || return 1
+  assert_file_contains "$mem/backlog.md" "> verbatim (user," "AC-005 verbatim blockquote missing" || return 1
+  assert_file_contains "$mem/backlog.md" "raised-on: $(today)" "AC-005 raised-on missing" || return 1
+  assert_file_contains "$mem/backlog.md" "raised-in-context: backlog-memory-bucket" "AC-005 raised-in-context missing" || return 1
+  assert_contains "$report" '"closed": 0' "AC-005 expected closed:0 (open entry shouldn't auto-close)" || return 1
+}
+
+test_when_bootstrap_entry_has_superseded_at_today_then_auto_close_removes_it() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  add "$mem" "backlog" "## bootstrap
+
+- source: inferred-from-code
+- status: dropped
+- raised-on: $(today)
+- raised-in-context: backlog-memory-bucket
+- verified-at: HEAD
+- last-touched: $(today)
+- superseded-at: $(today)"
+  local report; report="$(sweep auto-close "$mem")" || { fail "AC-006 sweep crashed"; return 1; }
+  assert_file_not_contains "$mem/backlog.md" "## bootstrap" "AC-006 bootstrap must be auto-closed" || return 1
+  assert_contains "$report" '"closed": 1' "AC-006 expected closed:1 (got: $report)" || return 1
+}
+
+test_when_backlog_entry_verified_at_old_sha_then_not_classified_stale() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  # Non-git tempdir → stale predicate falls back to days-since(last-touched).
+  # 120 days ago should be stale for any other canonical file; backlog must
+  # be stale-exempt and NOT surface.
+  add "$mem" "backlog" "## ancient-intent-aaaa
+
+> verbatim (user, $(days_ago 120)):
+> TODO: this is intentionally aged
+
+- source: user-instruction
+- status: open
+- raised-on: $(days_ago 120)
+- raised-in-context: legacy-workflow
+- verified-at: HEAD
+- last-touched: $(days_ago 120)"
+  # stale-sweep reads one reply per surfaced entry from stdin; if backlog is
+  # correctly stale-exempt, NO entry is surfaced and stdin is never consumed.
+  local report; report="$(sweep stale-sweep "$mem" "")" || { fail "AC-009 sweep crashed"; return 1; }
+  assert_file_contains "$mem/backlog.md" "## ancient-intent-aaaa" "AC-009 backlog entry must survive stale-sweep" || return 1
+  assert_contains "$report" '"reverified": 0' "AC-009 expected reverified:0 (entry never surfaced)" || return 1
+  assert_contains "$report" '"deleted": 0' "AC-009 expected deleted:0" || return 1
+  assert_contains "$report" '"mark_closed": 0' "AC-009 expected mark_closed:0" || return 1
+  assert_contains "$report" '"kept": 0' "AC-009 expected kept:0 (kept counts a surfaced entry that was skipped — backlog should never surface)" || return 1
+}
+
+test_when_readme_documents_backlog_and_assistant_deferral_then_present() {
+  # Asserts the LIVE README.md (which the implement worker edits) — not a
+  # fixture. Covers AC-007 schema-doc lockstep.
+  local readme="$REPO_ROOT/.claude/memory/README.md"
+  [ -f "$readme" ] || { fail "AC-007 README missing at $readme"; return 1; }
+  assert_file_contains "$readme" "backlog.md" "AC-007 README missing backlog.md mention" || return 1
+  assert_file_contains "$readme" "assistant-deferral" "AC-007 README missing assistant-deferral provenance value" || return 1
+  # backlog.md should be listed under both the Files table and the stable-key
+  # table; greedy substring matches the row prefix.
+  local backlog_rows; backlog_rows="$(grep -cE '^\|\s*`backlog\.md`' "$readme" 2>/dev/null || true)"
+  [ -z "$backlog_rows" ] && backlog_rows=0
+  if [ "$backlog_rows" -lt 2 ]; then
+    fail "AC-007 expected backlog.md row in BOTH Files table and stable-key table (>=2 rows); got $backlog_rows"
+    return 1
+  fi
+}
+
+# --- workflow-loop-closing-hygiene: stamp-closure mode (Goal 3) --------------
+# Covers AC-005, AC-006, AC-007, AC-008 from
+# docs/specs/workflow-loop-closing-hygiene.md. All start RED until sweep.py
+# adds `mode_stamp_closure` + `--backlog-keys` arg + a 4th MODE_DISPATCH entry.
+
+# Reuse the existing `sweep` helper for stamp-closure: pass a 4th positional
+# argument forwarding the --backlog-keys CSV. The current helper signature
+# `sweep mode mem replies` — we extend behavior with a sibling invoker so the
+# existing call sites stay untouched.
+sweep_stamp_closure() {
+  local mem="$1" keys="${2:-}"
+  if [ ! -f "$SWEEP" ]; then
+    echo "{\"error\":\"sweep.py missing\"}"
+    return 127
+  fi
+  python3 "$SWEEP" --mode stamp-closure --memory-dir "$mem" --backlog-keys "$keys"
+}
+
+# Add a backlog entry shaped like the canonical write from /memory-flush.
+add_open_backlog_entry() {
+  local mem="$1" key="$2"
+  add "$mem" "backlog" "## $key
+
+> verbatim (user, $(today)):
+> stub intent line for $key
+
+- source: user-instruction
+- status: open
+- raised-on: $(today)
+- raised-in-context: test-fixture
+- verified-at: HEAD
+- last-touched: $(today)"
+}
+
+test_when_stamp_closure_runs_then_status_and_superseded_at_set() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  add_open_backlog_entry "$mem" "k1"
+  add_open_backlog_entry "$mem" "k2"
+  add_open_backlog_entry "$mem" "k3"
+  local report; report="$(sweep_stamp_closure "$mem" "k1,k2")" \
+    || { fail "AC-005 sweep crashed (got: $report)"; return 1; }
+  assert_contains "$report" '"stamped": 2' "AC-005 expected stamped:2 (got: $report)" || return 1
+  # k1 and k2 must now carry status: picked-up + superseded-at: today.
+  # k3 must remain status: open (no superseded-at:).
+  python3 - "$mem/backlog.md" "$(today)" <<'PY' || return 1
+import re, sys
+path, today = sys.argv[1], sys.argv[2]
+text = open(path).read()
+def find(key):
+    m = re.search(rf'^## {re.escape(key)}$(.*?)(?=^## |\Z)', text, re.M | re.DOTALL)
+    return m.group(1) if m else ''
+for key in ("k1", "k2"):
+    block = find(key)
+    if not block:
+        sys.exit(f"missing block for {key}")
+    if 'status: picked-up' not in block:
+        sys.exit(f"{key}: expected status: picked-up; got: {block!r}")
+    if f'superseded-at: {today}' not in block:
+        sys.exit(f"{key}: expected superseded-at: {today}; got: {block!r}")
+k3 = find("k3")
+if 'status: open' not in k3:
+    sys.exit(f"k3: expected status: open (untouched); got: {k3!r}")
+if 'superseded-at:' in k3:
+    sys.exit(f"k3: expected NO superseded-at: (untouched); got: {k3!r}")
+PY
+}
+
+test_when_stamp_closure_then_auto_close_deletes() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  add_open_backlog_entry "$mem" "k1"
+  add_open_backlog_entry "$mem" "k2"
+  sweep_stamp_closure "$mem" "k1,k2" >/dev/null \
+    || { fail "AC-007 stamp-closure crashed"; return 1; }
+  local report; report="$(sweep auto-close "$mem")" \
+    || { fail "AC-007 auto-close crashed"; return 1; }
+  assert_file_not_contains "$mem/backlog.md" "## k1" "AC-007 expected k1 deleted by auto-close" || return 1
+  assert_file_not_contains "$mem/backlog.md" "## k2" "AC-007 expected k2 deleted by auto-close" || return 1
+  assert_contains "$report" '"closed": 2' "AC-007 expected closed:2 (got: $report)" || return 1
+}
+
+test_when_stamp_closure_with_empty_keys_then_zero_stamped() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  add_open_backlog_entry "$mem" "k1"
+  local before; before="$(cat "$mem/backlog.md")"
+  local report; report="$(sweep_stamp_closure "$mem" "")" \
+    || { fail "AC-008 sweep crashed on empty keys"; return 1; }
+  assert_contains "$report" '"stamped": 0' "AC-008 expected stamped:0 (got: $report)" || return 1
+  local after; after="$(cat "$mem/backlog.md")"
+  if [ "$before" = "$after" ]; then return 0; fi
+  fail "AC-008 backlog.md was modified despite empty keys"
+  diff <(printf '%s' "$before") <(printf '%s' "$after") || true
+  return 1
+}
+
+test_when_stamp_closure_with_nonexistent_key_then_missing_list() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  add_open_backlog_entry "$mem" "k1"
+  local report; report="$(sweep_stamp_closure "$mem" "nonexistent-key")" \
+    || { fail "AC-008 sweep crashed (got: $report)"; return 1; }
+  assert_contains "$report" '"stamped": 0' "AC-008 expected stamped:0 for missing key" || return 1
+  assert_contains "$report" '"missing"' "AC-008 expected missing list in report (got: $report)" || return 1
+  assert_contains "$report" 'nonexistent-key' "AC-008 expected key in missing list" || return 1
+}
+
+test_when_stamp_closure_called_twice_then_idempotent() {
+  local mem; mem="$(mktemp -d)"; trap "rm -rf $mem" RETURN
+  seed_skel "$mem"
+  add_open_backlog_entry "$mem" "k1"
+  sweep_stamp_closure "$mem" "k1" >/dev/null \
+    || { fail "AC-005 first stamp crashed"; return 1; }
+  sweep_stamp_closure "$mem" "k1" >/dev/null \
+    || { fail "AC-005 second stamp crashed"; return 1; }
+  # status: picked-up should appear exactly once; superseded-at: today exactly once.
+  local picked_count; picked_count="$(grep -c 'status: picked-up' "$mem/backlog.md")"
+  local sup_count; sup_count="$(grep -c "superseded-at: $(today)" "$mem/backlog.md")"
+  if [ "$picked_count" -ne 1 ] || [ "$sup_count" -ne 1 ]; then
+    fail "AC-005 idempotency violated: status-count=$picked_count, superseded-count=$sup_count (expected 1, 1)"
+    return 1
+  fi
+}
+
+test_when_stamp_closure_missing_keys_arg_then_argparse_error() {
+  if [ ! -f "$SWEEP" ]; then
+    fail "AC-005 sweep.py missing"
+    return 1
+  fi
+  python3 "$SWEEP" --mode stamp-closure --memory-dir "$REPO_ROOT/.claude/memory" >/dev/null 2>&1
+  local ec=$?
+  if [ "$ec" -ne 2 ]; then
+    fail "AC-005 expected argparse exit 2 when --backlog-keys missing, got $ec"
+    return 1
+  fi
+}
+
 # --- runner -------------------------------------------------------------------
 
 run test_when_resolved_at_present_on_pending_then_flush_removes_block
@@ -317,6 +600,22 @@ run test_when_2_stale_then_flush_offers_reverify_then_delete_prompts
 run test_when_stale_mark_closed_on_pending_then_resolved_at_added_not_deleted
 run test_when_no_closure_no_prose_no_stale_then_entry_survives_all_paths
 run test_when_pre_spec_entry_no_source_no_verbatim_then_grandfathered
+run test_when_pending_empty_then_sweep_does_not_touch_pending
+run test_when_pending_empty_AND_q999_has_resolved_at_then_q999_is_swept
+
+# backlog-memory-bucket coverage
+run test_when_promote_user_candidate_writes_canonical_entry_with_status_open_and_verbatim
+run test_when_bootstrap_entry_has_superseded_at_today_then_auto_close_removes_it
+run test_when_backlog_entry_verified_at_old_sha_then_not_classified_stale
+run test_when_readme_documents_backlog_and_assistant_deferral_then_present
+
+# workflow-loop-closing-hygiene: stamp-closure coverage
+run test_when_stamp_closure_runs_then_status_and_superseded_at_set
+run test_when_stamp_closure_then_auto_close_deletes
+run test_when_stamp_closure_with_empty_keys_then_zero_stamped
+run test_when_stamp_closure_with_nonexistent_key_then_missing_list
+run test_when_stamp_closure_called_twice_then_idempotent
+run test_when_stamp_closure_missing_keys_arg_then_argparse_error
 
 echo "----"
 echo "Passed: $PASS  Failed: $FAIL"

package/obj/template/.claude/skills/tdd/SKILL.md

@@ -77,7 +77,8 @@ Create tasks via `TaskCreate`; wire `addBlockedBy` so the chain is sequential. U
 - **Task B — implement-tick**: subject `"Run /implement for <slug>"`; metadata `{phase: "implement-tick", slug}`; activeForm `"Running implement"`; `addBlockedBy [A]`.
 - **Task C — verify-tick**: subject `"Run inline verify for <slug>"`; metadata `{phase: "verify-tick", slug}`; activeForm `"Running verify (inlined)"`; `addBlockedBy [B]`. The harness, when this task becomes next-pending, inlines the four mechanical operations from `.claude/skills/verify/SKILL.md` rather than invoking that skill via the Skill tool (the verify skill is contract-only after the harness-auto-continuation refactor).
 - **Tasks D₁..D_N — design-ui-tick (post-verify design implementation step; only when design_calls_rows is non-empty AND the implement write_set intersects `tdd.ui_globs`)**: one task per row. Subject `"Run /design-ui for <row.slug>"`; metadata `{phase: "design-ui-tick", slug, row_index: i}`; activeForm `"Running design-ui row <i>"`; `addBlockedBy [C]` for D₁, then chained `addBlockedBy [D_{i-1}]`. The design-ui worker handles the design implementation per the spec's `## Design calls` rows. After every D_i completes, the harness inlines a second verify pass (re-stamps `last_test_result`) to confirm the design work did not break behavior tests.
-- **Task Z — tdd-finalize**: subject `"Finalize tdd for <slug>"`; metadata `{phase: "tdd-finalize", slug}`; activeForm `"Finalizing tdd"`; `addBlockedBy` the last D_i (or C if no design-ui). On execution, the harness appends `"tdd"` to `workflow.json → completed`, writes `harness_state: continue` with reason "tdd green; next: simplify", and proceeds.
+- **Task E — drift-check-tick (spec-to-implementation drift analysis; seeded for every spec-track workflow)**: subject `"Run drift-check for <slug>"`; metadata `{phase: "drift-check-tick", slug}`; activeForm `"Running drift-check (inlined)"`; `addBlockedBy [D_N]` if any design-ui-tick exists, else `[C]`. The harness inlines `python3 .claude/skills/tdd/drift_check.py --slug <slug>` against the approved spec and the branch diff. On exit 0 (zero unresolved): write the drift report path to the harness log; continue to Task Z. On exit 1 (≥ 1 unresolved): EXIT LOOP with YIELD (`reason: "drift analysis: <N> unresolved items"`); the user investigates and either fixes the impl gap or amends the spec + re-`/approve-spec`s. NO auto-loop. On `chore`-track workflows (no spec on disk), drift_check exits 0 with "no spec; skipped" and the harness proceeds to Z. On the workflow that initially introduces drift-check-tick, the harness instance in flight at that workflow predates the SKILL.md update and SHALL NOT seed Task E — the helper is unit-tested via the recipe scenarios and live runtime use begins in the next spec-track workflow.
+- **Task Z — tdd-finalize**: subject `"Finalize tdd for <slug>"`; metadata `{phase: "tdd-finalize", slug}`; activeForm `"Finalizing tdd"`; `addBlockedBy` Task E (if seeded), else the last D_i, else C. On execution, the harness appends `"tdd"` to `workflow.json → completed`, writes `harness_state: continue` with reason "tdd green; next: simplify", and proceeds.
 
 ## 7. Write harness_state and yield
 

package/obj/template/.claude/skills/tdd/drift_check.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""Spec-to-implementation drift analysis (Phase 6 worker step).
+
+CLI:
+  python3 drift_check.py --slug <slug> [--project-root <path>] [--diff <path>]
+
+Reads `docs/specs/<slug>.md` from `--project-root`, scores every numbered AC
+in the ## Acceptance criteria table and every row of the ## Design calls
+table against the implementation diff (--diff override, else `git diff
+<merge-base>..HEAD` against the main branch). Writes a markdown report at
+`<project-root>/.claude/state/drift/<slug>.md` with a per-item verdict of
+`resolved | unresolved | unknown` plus evidence.
+
+Exit codes:
+  0  zero unresolved (`resolved` and `unknown` items are advisory)
+  1  >=1 unresolved
+  2  tool error (handled by argparse / unhandled exception)
+
+Special case: spec file missing at the named slug → print "no spec; skipped"
+to stdout, exit 0, no report file written (supports chore-track workflows).
+"""
+from __future__ import annotations
+import argparse
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+# --- Foundation: regex + IO --------------------------------------------------
+
+AC_ROW_RE = re.compile(r'^\|\s*(AC-\d+)\s*\|', re.MULTILINE)
+DESIGN_CALLS_SECTION_RE = re.compile(
+    r'^##\s+Design calls\s*\n(.*?)(?=^##\s|\Z)',
+    re.MULTILINE | re.DOTALL,
+)
+DESIGN_ROW_RE = re.compile(r'^\|\s*([^|]+?)\s*\|', re.MULTILINE)
+NONE_BODY_RE = re.compile(r'^[\s\-]*\*?\(?none\)?\*?[\s\-]*$', re.IGNORECASE)
+
+
+def load_spec(project_root: Path, slug: str) -> str | None:
+    spec_path = project_root / 'docs' / 'specs' / f'{slug}.md'
+    if not spec_path.is_file():
+        return None
+    return spec_path.read_text(encoding='utf-8', errors='replace')
+
+
+def load_diff(project_root: Path, diff_path: Path | None) -> str:
+    if diff_path:
+        return diff_path.read_text(encoding='utf-8', errors='replace')
+    try:
+        merge_base = subprocess.check_output(
+            ['git', '-C', str(project_root), 'merge-base', 'HEAD', 'main'],
+            stderr=subprocess.DEVNULL, text=True,
+        ).strip()
+        return subprocess.check_output(
+            ['git', '-C', str(project_root), 'diff', f'{merge_base}..HEAD'],
+            stderr=subprocess.DEVNULL, text=True,
+        )
+    except Exception:
+        return ''
+
+
+def write_report(project_root: Path, slug: str, body: str) -> Path:
+    out_dir = project_root / '.claude' / 'state' / 'drift'
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / f'{slug}.md'
+    out_path.write_text(body, encoding='utf-8')
+    return out_path
+
+
+def now_iso() -> str:
+    return datetime.now(tz=timezone.utc).isoformat(timespec='seconds').replace('+00:00', 'Z')
+
+
+def added_lines(diff_text: str) -> list[str]:
+    return [ln for ln in diff_text.splitlines()
+            if ln.startswith('+') and not ln.startswith('+++')]
+
+
+# --- Domain: parse + score ---------------------------------------------------
+
+def parse_acs(spec_text: str) -> list[str]:
+    return AC_ROW_RE.findall(spec_text)
+
+
+def parse_design_calls(spec_text: str) -> list[str]:
+    """Return the list of row-slugs in the spec's `## Design calls` table.
+    Empty list iff section absent or body is the *(none)* sentinel."""
+    m = DESIGN_CALLS_SECTION_RE.search(spec_text)
+    if not m:
+        return []
+    body = m.group(1).strip()
+    if NONE_BODY_RE.match(body) or '*(none)*' in body or '(none)' in body.lower():
+        return []
+    rows = []
+    for row_match in DESIGN_ROW_RE.finditer(body):
+        first_cell = row_match.group(1).strip()
+        if re.match(r'^[\s:|\-]+$', first_cell):
+            continue
+        if first_cell.lower() in ('slug', 'kind'):
+            continue
+        rows.append(first_cell)
+    return rows
+
+
+def score_against_diff(item_id: str, diff_added: list[str]) -> tuple[str, str]:
+    for ln in diff_added:
+        if item_id in ln:
+            snippet = ln.strip()
+            if len(snippet) > 120:
+                snippet = snippet[:117] + '...'
+            return ('resolved', f'found in diff: {snippet}')
+    return ('unresolved', 'no diff added-line references this item')
+
+
+def render_report(slug: str,
+                  acs: list[tuple[str, str, str]],
+                  design_rows: list[tuple[str, str, str]]) -> str:
+    lines = [
+        f'# Drift report — {slug}',
+        '',
+        f'Generated at: {now_iso()}',
+        '',
+        '## Acceptance criteria',
+        '',
+        '| kind | id | verdict | evidence |',
+        '|---|---|---|---|',
+    ]
+    for ac_id, verdict, evidence in acs:
+        lines.append(f'| ac | {ac_id} | {verdict} | {evidence} |')
+    lines.append('')
+    lines.append('## Design calls')
+    lines.append('')
+    if not design_rows:
+        lines.append('no design calls — skipped')
+    else:
+        lines.append('| kind | id | verdict | evidence |')
+        lines.append('|---|---|---|---|')
+        for row_slug, verdict, evidence in design_rows:
+            lines.append(f'| design-call | {row_slug} | {verdict} | {evidence} |')
+    lines.append('')
+    return '\n'.join(lines)
+
+
+# --- Orchestration -----------------------------------------------------------
+
+def main(argv) -> int:
+    parser = argparse.ArgumentParser(description='Spec-to-implementation drift analysis')
+    parser.add_argument('--slug', required=True)
+    parser.add_argument('--project-root', default='.')
+    parser.add_argument('--diff', default=None)
+    args = parser.parse_args(argv)
+
+    project_root = Path(args.project_root).resolve()
+    spec_text = load_spec(project_root, args.slug)
+    if spec_text is None:
+        print('no spec; skipped')
+        return 0
+
+    diff_path = Path(args.diff).resolve() if args.diff else None
+    diff_text = load_diff(project_root, diff_path)
+    diff_added = added_lines(diff_text)
+
+    ac_results = [(ac_id, *score_against_diff(ac_id, diff_added))
+                  for ac_id in parse_acs(spec_text)]
+
+    design_results = [(slug_, *score_against_diff(slug_, diff_added))
+                      for slug_ in parse_design_calls(spec_text)]
+
+    report = render_report(args.slug, ac_results, design_results)
+    write_report(project_root, args.slug, report)
+
+    unresolved = sum(1 for _, v, _ in ac_results if v == 'unresolved')
+    unresolved += sum(1 for _, v, _ in design_results if v == 'unresolved')
+    return 0 if unresolved == 0 else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))