@friedbotstudio/create-baseline 0.2.1 → 0.3.0

package/obj/template/.claude/hooks/tests/memory_session_start_test.sh

@@ -223,11 +223,15 @@ test_when_audit_runs_against_changed_repo_then_exit_0() {
 
 test_when_hook_runs_unchanged_tree_then_header_and_table_byte_equal() {
   # Run hook against the real repo memory tree and compare header+table to
-  # the captured pre-spec reference.
+  # the captured pre-spec reference. The fixture's HEAD field is the literal
+  # sentinel `n/a` (see fixtures/regenerate-ac008.sh); the test normalizes
+  # any captured `HEAD: \`<short-sha>\`` to `HEAD: \`n/a\`` before comparing
+  # so the test is byte-stable across commits.
   local out; out="$(run_hook "$REPO_ROOT")"
   local actual_block
   actual_block="$(printf '%s\n' "$out" | python3 -c '
-import sys
+import re, sys
+HEAD_RE = re.compile(r"^(HEAD:\s*`)[^`]+(`)")
 lines = sys.stdin.read().split("\n")
 started = False
 out = []
@@ -236,7 +240,7 @@ for ln in lines:
         started = True
     if not started:
         continue
-    out.append(ln)
+    out.append(HEAD_RE.sub(r"\1n/a\2", ln))
     if ln.startswith("| `pending-questions.md`"):
         break
 sys.stdout.write("\n".join(out) + "\n")

package/obj/template/.claude/hooks/tests/memory_stop_intent_test.sh

@@ -0,0 +1,329 @@
+#!/usr/bin/env bash
+# Fixture-based integration tests for memory_stop.sh intent-extraction surface.
+# Covers AC-001..AC-004, AC-010, AC-012 from docs/specs/backlog-memory-bucket.md
+#
+# Each test builds a synthetic transcript JSONL under a tempdir + project root,
+# invokes the real hook with CLAUDE_PROJECT_DIR redirected at the tempdir, and
+# asserts on the resulting _pending.md body. The hook is a passive collector —
+# tests assert on what it APPENDED, not on side effects elsewhere.
+#
+# All tests in this file start RED until the implement worker:
+#   (a) captures the no-intent baseline fixture at
+#       .claude/hooks/tests/fixtures/memory_stop_landmark_baseline.txt
+#       by running the CURRENT (pre-extension) hook against the AC-004 input;
+#   (b) extends memory_stop.sh with the intent-extraction surface;
+#   (c) re-runs this file — AC-001/2/3/10 should now PASS (extension added)
+#       and AC-004/12 should stay PASS (baseline still matches because the
+#       no-intent path is byte-stable).
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$HERE/../../.." && pwd)"
+HOOK="$REPO_ROOT/.claude/hooks/memory_stop.sh"
+FIXTURES="$HERE/fixtures"
+LANDMARK_BASELINE="$FIXTURES/memory_stop_landmark_baseline.txt"
+
+PASS=0; FAIL=0; FAILED=()
+
+# --- assertion helpers (Foundation) ------------------------------------------
+
+fail() { echo "  FAIL: $*"; return 1; }
+
+assert_file_contains() {
+  local path="$1" needle="$2" msg="$3"
+  if grep -qF -- "$needle" "$path" 2>/dev/null; then return 0; fi
+  fail "$msg :: $path missing literal: $needle"
+}
+
+assert_file_not_contains() {
+  local path="$1" needle="$2" msg="$3"
+  if grep -qF -- "$needle" "$path" 2>/dev/null; then
+    fail "$msg :: $path should NOT contain literal: $needle"
+    return 1
+  fi
+}
+
+assert_grep_count() {
+  local path="$1" pattern="$2" expected="$3" msg="$4"
+  local got
+  got="$(grep -cE "$pattern" "$path" 2>/dev/null || true)"
+  [ -z "$got" ] && got=0
+  if [ "$got" -eq "$expected" ]; then return 0; fi
+  fail "$msg :: pattern /$pattern/ count expected=$expected got=$got"
+}
+
+# --- transcript builders (Foundation) ----------------------------------------
+
+# Each builder appends one JSONL event. Event shape matches what Claude Code
+# writes to a real transcript: {"message": {"role": ..., "content": [...]}}.
+
+append_text_event() {
+  local path="$1" role="$2" text="$3"
+  python3 - "$path" "$role" "$text" <<'PY'
+import json, sys
+path, role, text = sys.argv[1], sys.argv[2], sys.argv[3]
+event = {"message": {"role": role, "content": [{"type": "text", "text": text}]}}
+with open(path, "a", encoding="utf-8") as f:
+    f.write(json.dumps(event) + "\n")
+PY
+}
+
+append_tool_use_event() {
+  local path="$1" tool="$2" file_path="$3"
+  python3 - "$path" "$tool" "$file_path" <<'PY'
+import json, sys
+path, tool, fp = sys.argv[1], sys.argv[2], sys.argv[3]
+event = {"message": {"role": "assistant",
+  "content": [{"type": "tool_use", "name": tool, "input": {"file_path": fp}}]}}
+with open(path, "a", encoding="utf-8") as f:
+    f.write(json.dumps(event) + "\n")
+PY
+}
+
+# --- project root setup (Foundation) -----------------------------------------
+
+# Seed a tempdir with the layout memory_stop.sh expects:
+#   <root>/.claude/hooks/lib/      symlink to the real lib (for common.sh)
+#   <root>/.claude/memory/_pending.md   skeleton body
+#   <root>/.claude/state/logs/     empty (log_line writes here)
+# Prints the root path on stdout.
+seed_project() {
+  local root; root="$(mktemp -d)"
+  mkdir -p "$root/.claude/memory" "$root/.claude/state/logs" "$root/.claude/hooks"
+  ln -s "$REPO_ROOT/.claude/hooks/lib" "$root/.claude/hooks/lib"
+  cat > "$root/.claude/memory/_pending.md" <<'EOF'
+---
+owners: [memory_stop.sh writes; /memory-flush clears]
+category: auto-extracted candidates awaiting curation
+verifies-against: none
+---
+
+# Pending memory candidates
+
+---
+EOF
+  printf '%s' "$root"
+}
+
+# Invoke the hook against $1 = project root, $2 = transcript path.
+# The hook is invoked exactly as Claude Code invokes it — JSON payload on
+# stdin, project dir via env. Output to stdout/stderr is suppressed; tests
+# inspect _pending.md afterward.
+run_hook() {
+  local root="$1" transcript="$2"
+  printf '%s' "{\"transcript_path\":\"$transcript\"}" \
+    | CLAUDE_PROJECT_DIR="$root" bash "$HOOK" >/dev/null 2>&1 || true
+}
+
+# Helper: read the pending file path for a given project root.
+pending_path() {
+  printf '%s' "$1/.claude/memory/_pending.md"
+}
+
+# Strip lines that legitimately vary between runs (session timestamps + edit
+# timestamps), so byte-parity comparisons are stable across invocations.
+canonicalize_pending() {
+  grep -vE '^<!-- session [0-9TZ:-]+ -->$|^- Source: file written/edited at ' "$1"
+}
+
+run() {
+  local name="$1"
+  echo "RUN  $name"
+  if "$name"; then
+    PASS=$((PASS+1)); echo "PASS $name"
+  else
+    FAIL=$((FAIL+1)); FAILED+=("$name"); echo "FAIL $name"
+  fi
+}
+
+# --- AC-001: user-prompt anchored TODO emits backlog candidate ---------------
+
+test_when_user_prompt_has_anchored_todo_then_backlog_candidate_emitted() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  append_text_event "$tx" "user" "TODO: add retry to webhook worker"
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 1 "AC-001 expected exactly 1 backlog CANDIDATE" || return 1
+  assert_file_contains "$pf" "- Role: user" "AC-001 role=user missing" || return 1
+  assert_file_contains "$pf" "- Source: user-instruction" "AC-001 source=user-instruction missing" || return 1
+  assert_file_contains "$pf" "TODO: add retry to webhook worker" "AC-001 verbatim missing" || return 1
+
+  # Key shape: <slug>-<4-char-hash>
+  local key
+  key="$(grep -oE '^## CANDIDATE: backlog → \S+' "$pf" | head -1 | sed 's|^## CANDIDATE: backlog → ||')"
+  echo "$key" | grep -qE -- '-[0-9a-f]{4}$' || { fail "AC-001 key '$key' missing 4-char hash suffix"; return 1; }
+}
+
+# --- AC-002: assistant-text anchored intent emits candidate with distinct source ---
+
+test_when_assistant_text_has_anchored_lets_also_then_backlog_candidate_with_assistant_deferral_source() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  append_text_event "$tx" "assistant" "Let's also test the empty-state flow"
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 1 "AC-002 expected exactly 1 backlog CANDIDATE" || return 1
+  assert_file_contains "$pf" "- Role: assistant" "AC-002 role=assistant missing" || return 1
+  assert_file_contains "$pf" "- Source: assistant-deferral" "AC-002 source=assistant-deferral missing" || return 1
+  assert_file_contains "$pf" "Let's also test the empty-state flow" "AC-002 verbatim missing" || return 1
+}
+
+# --- AC-003: mid-sentence trigger MUST NOT emit ------------------------------
+
+test_when_intent_mid_sentence_then_no_backlog_candidate() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  append_text_event "$tx" "user" "we discussed the next section of the document is here and TODO appears mid-line"
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 0 "AC-003 mid-sentence MUST NOT emit candidate" || return 1
+}
+
+# --- AC-003 noise filter: system-reminder block suppressed -------------------
+
+test_when_intent_in_system_reminder_block_then_no_backlog_candidate() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  append_text_event "$tx" "user" $'<system-reminder>\nTODO: should be filtered\n</system-reminder>'
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 0 "AC-003 system-reminder block MUST be filtered" || return 1
+}
+
+# --- AC-001 bullet anchor: indented bullet emits -----------------------------
+
+test_when_intent_at_indented_bullet_then_candidate_emitted() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  append_text_event "$tx" "user" $'Some intro line.\n  - TODO: handle the empty-state case'
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 1 "AC-001 bullet-anchored intent should emit 1" || return 1
+  assert_file_contains "$pf" "TODO: handle the empty-state case" "AC-001 bullet verbatim missing" || return 1
+}
+
+# --- AC-001 zero-content guard: empty intent after trigger strip -------------
+
+test_when_intent_text_empty_after_trigger_strip_then_no_candidate() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  append_text_event "$tx" "user" "TODO:"
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 0 "AC-001 zero-content intent MUST NOT emit" || return 1
+}
+
+# --- AC-010: same 8-word prefix → distinct keys via hash suffix --------------
+
+test_when_two_intents_same_8word_prefix_then_distinct_keys() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  append_text_event "$tx" "user" "next we should add retry logic"
+  append_text_event "$tx" "user" "next we should add retry tests"
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 2 "AC-010 expected 2 distinct backlog candidates" || return 1
+
+  # Both keys present and distinct
+  local keys
+  keys="$(grep -oE '^## CANDIDATE: backlog → \S+' "$pf" | sort -u)"
+  local count; count="$(printf '%s\n' "$keys" | wc -l | tr -d ' ')"
+  [ "$count" -eq 2 ] || { fail "AC-010 expected 2 distinct keys; got $count :: $keys"; return 1; }
+}
+
+# --- AC-001/AC-002 dedup: same intent repeated in turn -----------------------
+
+test_when_same_intent_repeated_in_turn_then_within_session_dedup_holds() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  # Same intent: 2 user events + 1 assistant event = 2 distinct candidates
+  # (one per role-source combination).
+  append_text_event "$tx" "user" "TODO: dedup me please"
+  append_text_event "$tx" "user" "TODO: dedup me please"
+  append_text_event "$tx" "assistant" "TODO: dedup me please"
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 2 "expected 2 (one per role); got drift" || return 1
+  assert_grep_count "$pf" '^- Source: user-instruction' 1 "expected 1 user-instruction candidate" || return 1
+  assert_grep_count "$pf" '^- Source: assistant-deferral' 1 "expected 1 assistant-deferral candidate" || return 1
+}
+
+# --- AC-004 byte-parity: file-touch path unchanged ---------------------------
+
+test_when_turn_edits_files_no_intent_then_landmark_candidates_byte_identical() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  # Three file-touch events, zero intent text. The shape that produces the
+  # captured baseline fixture.
+  append_tool_use_event "$tx" "Edit" "src/foo.py"
+  append_tool_use_event "$tx" "Edit" "src/bar.py"
+  append_tool_use_event "$tx" "Edit" "src/foo.py"
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  if [ ! -f "$LANDMARK_BASELINE" ]; then
+    fail "AC-004 baseline fixture missing at $LANDMARK_BASELINE — implement worker must capture pre-extension output before adding intent extraction"
+    return 1
+  fi
+
+  # Backlog section MUST be empty for this input (no intent text)
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 0 "AC-004 no-intent input must produce zero backlog candidates" || return 1
+
+  # Canonicalized (timestamp-stripped) output MUST byte-match the baseline.
+  local actual_canon expected_canon
+  actual_canon="$(canonicalize_pending "$pf")"
+  expected_canon="$(canonicalize_pending "$LANDMARK_BASELINE")"
+  if [ "$actual_canon" = "$expected_canon" ]; then return 0; fi
+  fail "AC-004 landmark output diverged from baseline (canonicalized diff below)"
+  diff <(printf '%s' "$expected_canon") <(printf '%s' "$actual_canon") | head -30
+  return 1
+}
+
+# --- AC-012 regression trap: no-intent leaves backlog section unchanged ------
+
+test_when_no_intent_text_in_turn_then_backlog_section_byte_identical_to_pre_change() {
+  local root; root="$(seed_project)"; trap "rm -rf $root" RETURN
+  local tx="$root/transcript.jsonl"
+  # Pure text content, no intent triggers. Hook should produce ZERO backlog
+  # candidates and leave the rest of _pending.md byte-stable.
+  append_text_event "$tx" "user" "general question about how the system works"
+  append_text_event "$tx" "assistant" "Here is a long explanation with no future-intent triggers in it."
+  run_hook "$root" "$tx"
+  local pf; pf="$(pending_path "$root")"
+
+  assert_grep_count "$pf" '^## CANDIDATE: backlog → ' 0 "AC-012 no-intent input must produce zero backlog candidates" || return 1
+  # Body below the front-matter separator should remain the skeleton form
+  # (no CANDIDATE blocks of any kind, since there are no file edits either).
+  assert_grep_count "$pf" '^## CANDIDATE:' 0 "AC-012 expected zero CANDIDATE blocks for pure text/no-edits turn" || return 1
+}
+
+# --- runner ------------------------------------------------------------------
+
+run test_when_user_prompt_has_anchored_todo_then_backlog_candidate_emitted
+run test_when_assistant_text_has_anchored_lets_also_then_backlog_candidate_with_assistant_deferral_source
+run test_when_intent_mid_sentence_then_no_backlog_candidate
+run test_when_intent_in_system_reminder_block_then_no_backlog_candidate
+run test_when_intent_at_indented_bullet_then_candidate_emitted
+run test_when_intent_text_empty_after_trigger_strip_then_no_candidate
+run test_when_two_intents_same_8word_prefix_then_distinct_keys
+run test_when_same_intent_repeated_in_turn_then_within_session_dedup_holds
+run test_when_turn_edits_files_no_intent_then_landmark_candidates_byte_identical
+run test_when_no_intent_text_in_turn_then_backlog_section_byte_identical_to_pre_change
+
+echo "----"
+echo "Passed: $PASS  Failed: $FAIL"
+if [ "$FAIL" -gt 0 ]; then
+  echo "Failed tests:"
+  for t in "${FAILED[@]}"; do echo "  - $t"; done
+fi
+exit $((FAIL > 0))

package/obj/template/.claude/hooks/tests/regenerate_ac008_test.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# Integration test for the regenerate-ac008.sh helper.
+# Covers AC-001 from docs/specs/workflow-loop-closing-hygiene.md.
+#
+# Contract: bash .claude/hooks/tests/fixtures/regenerate-ac008.sh overwrites
+# .claude/hooks/tests/fixtures/ac008_byte_equal_reference.txt with the live
+# memory_session_start.sh output (header + table block through pending-questions.md),
+# with HEAD normalized to the `n/a` sentinel. After regen, the AC-008 byte-equality
+# test inside memory_session_start_test.sh exits PASS.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$HERE/../../.." && pwd)"
+HELPER="$REPO_ROOT/.claude/hooks/tests/fixtures/regenerate-ac008.sh"
+FIXTURE="$REPO_ROOT/.claude/hooks/tests/fixtures/ac008_byte_equal_reference.txt"
+TEST_RUNNER="$REPO_ROOT/.claude/hooks/tests/memory_session_start_test.sh"
+
+PASS=0; FAIL=0; FAILED=()
+
+fail() { echo "  FAIL: $*"; return 1; }
+
+run() {
+  local name="$1"
+  echo "RUN  $name"
+  if "$name"; then
+    PASS=$((PASS+1)); echo "PASS $name"
+  else
+    FAIL=$((FAIL+1)); FAILED+=("$name"); echo "FAIL $name"
+  fi
+}
+
+# --- tests --------------------------------------------------------------------
+
+test_when_regenerate_ac008_runs_then_existing_ac008_test_passes() {
+  if [ ! -f "$HELPER" ]; then
+    fail "AC-001 helper not found at $HELPER"
+    return 1
+  fi
+  if [ ! -x "$HELPER" ] && ! head -1 "$HELPER" | grep -q '^#!'; then
+    fail "AC-001 helper $HELPER is not executable and has no shebang"
+    return 1
+  fi
+  # Stash the existing fixture so we can restore it if the test fails mid-flow.
+  local stash; stash="$(mktemp)"
+  cp "$FIXTURE" "$stash" 2>/dev/null || true
+  # Run the regenerator; the fixture is overwritten with normalized capture.
+  ( cd "$REPO_ROOT" && bash "$HELPER" ) >/dev/null 2>&1 \
+    || { fail "AC-001 regenerate helper exited non-zero"; cp "$stash" "$FIXTURE" 2>/dev/null; rm -f "$stash"; return 1; }
+  # The AC-008 byte-equal test must now pass against the freshly regenerated fixture.
+  ( cd "$REPO_ROOT" && bash "$TEST_RUNNER" >/dev/null 2>&1 ) \
+    || { fail "AC-001 memory_session_start_test.sh exited non-zero after regen"; cp "$stash" "$FIXTURE" 2>/dev/null; rm -f "$stash"; return 1; }
+  rm -f "$stash"
+  return 0
+}
+
+test_when_regenerate_ac008_runs_twice_then_fixture_is_byte_identical() {
+  if [ ! -f "$HELPER" ]; then
+    fail "AC-001 helper not found at $HELPER"
+    return 1
+  fi
+  local first second
+  ( cd "$REPO_ROOT" && bash "$HELPER" ) >/dev/null 2>&1 \
+    || { fail "AC-001 first regen exited non-zero"; return 1; }
+  first="$(sha256sum "$FIXTURE" 2>/dev/null | awk '{print $1}')"
+  ( cd "$REPO_ROOT" && bash "$HELPER" ) >/dev/null 2>&1 \
+    || { fail "AC-001 second regen exited non-zero"; return 1; }
+  second="$(sha256sum "$FIXTURE" 2>/dev/null | awk '{print $1}')"
+  if [ "$first" = "$second" ]; then return 0; fi
+  fail "AC-001 fixture not byte-identical across two regens ($first vs $second)"
+  return 1
+}
+
+test_when_regenerate_ac008_runs_then_fixture_head_line_is_n_a_sentinel() {
+  if [ ! -f "$HELPER" ]; then
+    fail "AC-001 helper not found at $HELPER"
+    return 1
+  fi
+  ( cd "$REPO_ROOT" && bash "$HELPER" ) >/dev/null 2>&1 \
+    || { fail "AC-001 regen exited non-zero"; return 1; }
+  if grep -qE '^HEAD: `n/a`' "$FIXTURE"; then return 0; fi
+  fail "AC-001 fixture HEAD line is not the n/a sentinel"
+  grep -E '^HEAD:' "$FIXTURE" || true
+  return 1
+}
+
+# --- runner -------------------------------------------------------------------
+
+run test_when_regenerate_ac008_runs_then_existing_ac008_test_passes
+run test_when_regenerate_ac008_runs_twice_then_fixture_is_byte_identical
+run test_when_regenerate_ac008_runs_then_fixture_head_line_is_n_a_sentinel
+
+echo "----"
+echo "Passed: $PASS  Failed: $FAIL"
+if [ "$FAIL" -gt 0 ]; then
+  echo "Failed tests:"
+  for t in "${FAILED[@]}"; do echo "  - $t"; done
+fi
+exit $((FAIL > 0))

package/obj/template/.claude/memory/README.md

@@ -12,6 +12,7 @@ Persistent project knowledge that travels with the repo. Loaded into Claude's co
 | `landmines.md` | `security`, `integrate`, `scout` | Gotchas: "do not edit X without also editing Y" |
 | `conventions.md` | `scenario`, `implement` | Repo-specific test/code idioms (fixture patterns, naming, layout) |
 | `pending-questions.md` | any phase | Open questions the current session couldn't resolve |
+| `backlog.md` | `/memory-flush` | Future-work intent captured automatically by `memory_stop.sh` (intent-line extraction from user prompts and assistant text). Stale-exempt. |
 | `_pending.md` | `memory_stop.sh` (writes), `/memory-flush` (clears) | Auto-extracted candidates awaiting curation. **Content gitignored**; the file structure is committed. |
 | `_resume.md` | `memory_pre_compact.sh` + `memory_stop.sh` (write), `memory_session_start.sh` (reads), `harness` (reads) | **Continuity** snapshot — last completed phase, next phase due, in-flight files, recent user prompts. Refreshed every turn-end and again before compaction. Re-injected at every session start (compact / clear / resume / startup). **Gitignored** — pure session state, not project knowledge. |
 
@@ -23,6 +24,7 @@ Every entry MUST carry a `source:` field declaring how the rule was learned. All
 |---|---|---|
 | `user-instruction` | The user stated a rule or directive in conversation | **Required** |
 | `user-feedback` | The user corrected behavior or affirmed a non-obvious approach | **Required** |
+| `assistant-deferral` | Claude verbalized a deferred follow-up during conversation (captured by `memory_stop.sh` intent extraction into `backlog.md`) | **Required** (Claude's own sentence as verbatim) |
 | `incident` | Recovered from an actual failure or near-miss in this session | Recommended (incident-report quote) |
 | `inferred-from-code` | Derived by reading the codebase | Not applicable |
 | `library-pinned` | Came from a `context7` lookup | Not applicable (cited URL/version is the source) |
@@ -32,7 +34,7 @@ For `source: user-instruction` and `source: user-feedback`, the entry MUST inclu
 
 The verbatim is not a summary, not a paraphrase, and not in Claude's voice. It is the user's words. If the original turn is no longer available, the entry's source is `unrecorded` and the curator MUST flag it for the user to confirm or restate at the next opportunity.
 
-`/memory-flush` SHALL reject any candidate promotion to a canonical file when `source` is `user-instruction` or `user-feedback` and `verbatim:` is missing or empty.
+`/memory-flush` SHALL reject any candidate promotion to a canonical file when `source` is `user-instruction`, `user-feedback`, or `assistant-deferral` and `verbatim:` is missing or empty.
 
 ## Per-entry shape (canonical files)
 
@@ -61,6 +63,7 @@ Multiple verbatim blocks are allowed (and encouraged) when the user clarifies or
 | `landmines.md` | `path:line` or short description slug |
 | `conventions.md` | short slug |
 | `pending-questions.md` | auto-numbered `Q-NNN` |
+| `backlog.md` | `<8-word-kebab-slug>-<4-char-sha256>` (derived by `memory_stop.sh` from the intent verbatim) |
 
 ## Self-healing rules
 
@@ -78,7 +81,7 @@ Two optional, register-specific closure fields cause `/memory-flush` Step 0 to d
 | File | Field | Semantics |
 |---|---|---|
 | `pending-questions.md` | `resolved-at: <ISO date>` | The question has been answered; entry is closed. |
-| `landmarks.md`, `libraries.md`, `decisions.md`, `landmines.md`, `conventions.md` | `superseded-at: <ISO date>` | The fact is no longer true; entry is closed. |
+| `landmarks.md`, `libraries.md`, `decisions.md`, `landmines.md`, `conventions.md`, `backlog.md` | `superseded-at: <ISO date>` | The fact (or, for `backlog.md`, the open intent) is no longer current; entry is closed. On `backlog.md` the body `status:` field (`picked-up` / `dropped`) disambiguates which transition triggered the close. |
 
 **Per-file invariant**: on `pending-questions.md`, `superseded-at:` MUST NOT appear; on the other five canonical files, `resolved-at:` MUST NOT appear. Mutually exclusive at the file level. Not enforced by audit — documented invariant only. The `/memory-flush` Step 0a sweep flags violations in its report rather than deleting.
 
@@ -92,6 +95,8 @@ A match without a corresponding structured closure field causes `/memory-flush`
 
 **Closure short-circuits decay (AC-005).** `memory_session_start.sh` excludes any entry carrying a closure field from the stale count. `stale` ≠ `closed`: a stale entry is *unverified*; closure is a separate, deliberate signal that the entry is no longer load-bearing.
 
+**Automated closure-stamp on backlog pickup.** When `/triage` records a workflow that picks up a backlog entry (the `workflow.json → source_backlog_keys` array carries the entry's stable key), `/commit` Step 6 invokes `python3 .claude/skills/memory-flush/sweep.py --mode stamp-closure --memory-dir .claude/memory --backlog-keys <csv>` after `git commit` succeeds. The mode writes `status: picked-up` + `superseded-at: <today>` to each named entry; the next `/memory-flush` Step 0a auto-deletes them. `/commit` is the only caller of this mode; `sweep.py` is the only writer to `backlog.md` during closure-stamping — the curator-not-writer pattern is preserved through the actuator boundary.
+
 ## How memory gets updated
 
 Two paths:
@@ -105,4 +110,4 @@ Two paths:
 
 ## Continuity vs knowledge
 
-Six canonical files plus `_pending.md` hold **project knowledge** — facts about the codebase that survive multiple sessions and get re-verified on every cite. `_resume.md` is different: it's a **continuity snapshot** describing the *current session* — what we just touched, what the user just asked, what phase we're on. It's overwritten each turn and gitignored. The split keeps long-term knowledge clean of session-state noise.
+Seven canonical files plus `_pending.md` hold **project knowledge** — facts about the codebase that survive multiple sessions and get re-verified on every cite. `_resume.md` is different: it's a **continuity snapshot** describing the *current session* — what we just touched, what the user just asked, what phase we're on. It's overwritten each turn and gitignored. The split keeps long-term knowledge clean of session-state noise.

package/obj/template/.claude/memory/backlog.md

@@ -0,0 +1,12 @@
+---
+owners: [/memory-flush]
+category: future-work intent
+size-cap: 500
+key: <slug>-<4char-hash>
+verifies-against: none
+stale-exempt: true
+---
+
+# Backlog
+
+(populated by /memory-flush from auto-extracted candidates)

package/obj/template/.claude/project.json

@@ -185,7 +185,12 @@
   },
   "consent": {
     "commit_ttl_seconds": 300,
-    "gate_marker_ttl_seconds": 120
+    "gate_marker_ttl_seconds": 120,
+    "push_ttl_seconds": 300
+  },
+  "git": {
+    "protected_branches": null,
+    "branch_pattern": null
   },
   "swarm": {
     "max_parallel": 4,

package/obj/template/.claude/settings.json

@@ -7,7 +7,7 @@
         "matcher": "Bash",
         "hooks": [
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/destructive_cmd_guard.sh" },
-          { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/git_commit_guard.sh" },
+          { "type": "command", "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/git_commit_guard.mjs" },
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/process_lifecycle_guard.sh" }
         ]
       },
@@ -18,7 +18,7 @@
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/env_guard.sh" },
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/spec_approval_guard.sh" },
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/swarm_approval_guard.sh" },
-          { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/git_commit_guard.sh" },
+          { "type": "command", "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/git_commit_guard.mjs" },
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/verify_pass_guard.sh" },
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/track_guard.sh" },
           { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/artifact_template_guard.sh" },
@@ -38,7 +38,7 @@
     "UserPromptSubmit": [
       {
         "hooks": [
-          { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/consent_gate_grant.sh" }
+          { "type": "command", "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/consent_gate_grant.mjs" }
         ]
       }
     ],
@@ -90,7 +90,6 @@
       "Bash(git blame:*)"
     ],
     "deny": [
-      "Bash(git push:*)",
       "Bash(git commit --amend:*)",
       "Bash(git reset --hard:*)",
       "Bash(git clean -f:*)",