@friedbotstudio/create-baseline 0.2.0 → 0.3.0

package/obj/template/.claude/skills/impeccable/NOTICE

@@ -0,0 +1,24 @@
+impeccable
+==========
+
+This skill is vendored from the `impeccable` repository published by Phil
+Bakaus (pbakaus) and is redistributed here under the terms of the Apache
+License, Version 2.0 (see LICENSE in this directory).
+
+Upstream:
+  Repository: https://github.com/pbakaus/impeccable
+  Author:     Phil Bakaus (pbakaus)
+
+Vendored into:  .claude/skills/impeccable/
+Vendored on:    2026-05-15 (this commit) — prior install date unknown; LICENSE
+                + NOTICE added retroactively as part of the licensing-attribution
+                drift fix in the branch-aware-git-policy workflow.
+
+Local changes:
+  - Frontmatter `owner: baseline` added so the audit-baseline drift check
+    tracks this file as a shipped baseline artifact. The Apache 2.0 license
+    permits redistribution under attribution; this NOTICE file fulfills the
+    notice-preservation requirement.
+  - PROJECT_NOTES.md captures local annotations made in the course of using
+    impeccable within the baseline. The vendored SKILL.md and agents/* files
+    are otherwise unmodified from upstream.

package/obj/template/.claude/skills/memory-flush/SKILL.md

@@ -1,9 +1,19 @@
 ---
 name: memory-flush
 owner: baseline
-description: Review the auto-extracted candidates in `.claude/memory/_pending.md` and commit keepers to the canonical memory files (`landmarks.md`, `libraries.md`, `decisions.md`, `landmines.md`, `conventions.md`, `pending-questions.md`). Invoke at session start when the SessionStart hook reports pending candidates, or any time `_pending.md` has accumulated entries you want to curate. Reset the pending body after flushing.
+description: Review the auto-extracted candidates in `.claude/memory/_pending.md` and commit keepers to the canonical memory files (`landmarks.md`, `libraries.md`, `decisions.md`, `landmines.md`, `conventions.md`, `pending-questions.md`, `backlog.md`). Invoke at session start when the SessionStart hook reports pending candidates, or any time `_pending.md` has accumulated entries you want to curate. Reset the pending body after flushing.
 ---
 
+# When invoked as Phase 10.6
+
+This skill runs as **Phase 10.6** of every workflow track (intake / spec / tdd / chore), between `/archive` (Phase 10.5) and `/grant-commit` (Phase 11). The harness loop reads `.claude/memory/_pending.md` body, runs Step 0 canonical sweeps unconditionally, and on **empty pending** (zero `## CANDIDATE:` blocks) short-circuits the **fast-path**: Steps 1–5 are skipped, Step 6 emits a one-line "no pending candidates" report, and the skill returns success. This keeps the no-op cost bounded at ≤ 3 sweep.py invocations per Phase 10.6 invocation.
+
+The skill is also user-invokable outside the workflow (ad-hoc curation). When invoked ad-hoc and `_pending.md` is non-empty, the full Steps 1–5 flow runs identically. The fast-path activates per-invocation based on `_pending.md` body state, not on workflow context.
+
+`/commit` (Phase 11) refuses to proceed unless `memory-flush` is in `workflow.json → completed` (or in `exceptions`). Empty-pending fast-path still appends `"memory-flush"` to `completed` — the prereq is satisfied either way.
+
+(See "Method" below for the full Step 0 / Steps 1–5 / Step 6 flow.)
+
 # memory-flush — curate auto-extracted memory candidates
 
 The `memory_stop.sh` hook appends candidates to `.claude/memory/_pending.md` after every turn. This skill reviews them in main context (where conversation richness is preserved), commits the keepers to the right canonical file with proper metadata, and resets the pending body.
@@ -18,13 +28,13 @@ The hook is a passive collector. **You are the curator.** Discard noise, promote
   - field: value
   - field: value
   ```
-- The six canonical files at `.claude/memory/<name>.md`. Read each before deciding where a candidate lands and whether it duplicates existing content.
+- The seven canonical files at `.claude/memory/<name>.md`. Read each before deciding where a candidate lands and whether it duplicates existing content.
 
 # Method
 
 ## Step 0 — Canonical sweep (closure semantics)
 
-Before reviewing `_pending.md`, sweep the six canonical files for closed entries and stale entries. The `sweep.py` helper at `.claude/skills/memory-flush/sweep.py` is the deterministic actuator; this SOP composes the three modes.
+Before reviewing `_pending.md`, sweep the seven canonical files for closed entries and stale entries. The `sweep.py` helper at `.claude/skills/memory-flush/sweep.py` is the deterministic actuator; this SOP composes the three modes.
 
 ### Step 0a — Auto-close structured closure fields
 
@@ -55,6 +65,10 @@ For each entry without a structured closure field, the helper scans the body aga
 
 You drive this step interactively: ask the user `Close <key> from <file>? (y / n / skip)` for each entry the helper surfaces, then feed the answers to the helper one per line.
 
+### Step 0a-bis — Stamp-closure mode (invoked from /commit, not from /memory-flush)
+
+`sweep.py` also exposes a `--mode stamp-closure --backlog-keys <csv>` mode that writes `status: picked-up` + `superseded-at: <today>` to each named `backlog.md` entry. This mode is NOT invoked by `/memory-flush` Step 0; it is invoked by `/commit` Step 6 when `workflow.json → source_backlog_keys` is non-empty. The mode is idempotent (re-running on stamped entries rewrites `superseded-at:` to today; reports them under `already_closed`). The next `/memory-flush` Step 0a auto-close sweep then deletes the stamped entries per the existing `superseded-at:` closure trigger — so `/memory-flush`'s contract is unchanged; it just sees more closures in its `auto-close` step. Report shape: `{"stamped": N, "missing": [keys], "already_closed": [keys]}`.
+
 ### Step 0c — Stale sweep
 
 Only run when `memory_session_start.sh` reported stale > 0 this session, or the user asks. Invoke:
@@ -76,9 +90,11 @@ Read `_pending.md` in full. Then read the canonical file each candidate targets
 For each `## CANDIDATE:` block, decide one of:
 
 - **Promote.** The candidate is signal. Build the canonical entry shape (see `.claude/memory/README.md`) and append to the right file. If the candidate's stable key already exists in the canonical file → **replace** that entry; do not duplicate.
-- **Discard.** The candidate is noise (touched-once file with no clear role; a context7 query that resolved nothing useful; a path under generated/vendored code). No canonical write.
+- **Discard.** The candidate is noise (touched-once file with no clear role; a context7 query that resolved nothing useful; a path under generated/vendored code; an intent line that was a passing chat phrase rather than real future work). No canonical write.
 - **Defer.** Useful but you don't have enough context to write a clean entry. Move the candidate verbatim to `pending-questions.md` as a `Q-NNN` entry phrased as "Should X be a landmark?" so the next session can decide. The pending body still gets reset at the end.
 
+**Backlog candidates** (`## CANDIDATE: backlog → <slug>-<4hash>`) route to `backlog.md` with the canonical entry shape plus these fields: `status: open` (the initial state; transitions to `picked-up` or `dropped` are later edits), `raised-on: <ISO>`, `raised-in-context: <slug-or-(no active workflow)>`, the verbatim blockquote of the user/assistant intent line. Provenance is `source: user-instruction` for `role: user` candidates or `source: assistant-deferral` for `role: assistant` candidates. The verbatim is REQUIRED for both — `/memory-flush` SHALL reject promotion without it (per `.claude/memory/README.md → Source provenance`).
+
 ## Step 3 — Verify before promoting
 
 Per the project memory contract: every entry on the canonical files must have a `verified-at:` field. Verify the candidate's claim before writing:

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"