chore(ai): archive session record, regen lint follow-ups, fix dangling todo link

The claude-memory clone was removed this session, so the todo entry's file: link to it would dangle — switched to plain text.

3 files changed, 190 insertions, 1 deletions

diff --git a/.ai/sessions/2026-05-24-03-10-spec-workflows-memory-sync-and-ai-kb-reviews.org b/.ai/sessions/2026-05-24-03-10-spec-workflows-memory-sync-and-ai-kb-reviews.org
new file mode 100644
index 0000000..fff561b
--- /dev/null
+++ b/.ai/sessions/2026-05-24-03-10-spec-workflows-memory-sync-and-ai-kb-reviews.org
@@ -0,0 +1,184 @@
+#+TITLE: Session — review spec-review/spec-response workflows before install
+#+AUTHOR: Craig Jennings & Claude
+#+DATE: 2026-05-23
+
+* Summary
+
+** Active Goal
+
+A multi-strand session. Started as a clarity+completeness review of the two linear-emacs spec workflows before installing them; grew into (1) installing the spec-review/spec-response pair into canonical templates, (2) the memory-sync task — prototyping a dedicated claude-memory.git repo then reversing it at Craig's call, (3) diagnosing and fixing a per-push password prompt (velox gpg-agent), and (4) two rounds of spec-review on .emacs.d's ai-kb.org (the org-roam agent-memory store), done cross-project from here.
+
+** Decisions
+
+- *Spec workflows install:* folded in research-backed fixes before shipping (gate now covers security/observability; Phase 1 fast-triage vs Phase 3 authoritative gate; severity↔blocking; reviewer-disagreement principle; explicit cycle termination), then installed both + INDEX entries.
+- *Memory storage — dedicated repo, then reversed.* Worked dotfiles → rulesets → dedicated repo (rulesets rejected: it's pulled first every session, so memory edits would dirty its tree and skip the startup pull). Built claude-memory.git, then Craig reversed it: general lessons belong in the rulesets rules layer (loaded everywhere natively), project memory under each project's .ai/. Brainstorm cancelled before implementing; idea captured for later.
+- *Storage-unification vs recall-scoping are orthogonal* — unify storage, keep recall per-project (relevance, index cost, disclosure-via-recall). Not implemented; recorded for the future two-tier design.
+- *ai-kb verdict:* round 1 Not-ready (4 blockers); after the spec was revised (reviews 1-3 incorporated) round 4 = Ready-with-caveats, two write-loop caveats remain (push-failure behavior, index.org regeneration).
+
+** Data Collected / Findings
+
+- Claude Code memory: per-project only, no native global tier; the cross-project mechanism is ~/.claude/CLAUDE.md or ~/.claude/rules/*.md (loaded full every session — which rulesets already distributes). autoMemoryDirectory exists but flattens isolation.
+- Memory inventory: 228K, 54 files across 6 projects (work 40); ~/.claude/projects is 321M of mostly .jsonl transcripts (must not sync).
+- SSH/git auth routes through gpg-agent; same ED25519 key on disk + in agent; empty agent → passphrase prompt every push. ratio loaded (silent); velox had no loaded identity → fixed with ssh-add (Craig entered passphrase on velox's display). Saved as reference memory.
+- ~/sync/org is Syncthing-only, not git — the load-bearing fact behind ai-kb's version-control gap.
+- emacs.md rule was committed but never make-install'd on ratio — linked it; doctor 41 ok / 0 / 0.
+
+** Files Modified
+
+Rulesets (all pushed): 7f2aea1 spec-workflow pair + INDEX; 3f802eb mirror resync; 0f4d1f8 then 349a8c7 (memory-sync task closed then reopened-parked after the reversal); 2956066 inbox lint clear. System-side: emacs.md rule symlinked (make install); velox gpg-agent key loaded.
+.emacs.d (cross-project, Craig's "do it from here" — left for the .emacs.d session to commit): docs/design/ai-kb-review.org, ai-kb-review4.org, and two inbox handoffs.
+Memory: added reference_ssh_auth_gpg_agent + feedback_no_inline_code_markup, updated feedback_never_guess + MEMORY.md (all preserved through the migration reversal).
+
+** Next Steps
+
+- Two-tier shared-memory design (rulesets rules-layer lessons file + per-project .ai/memory) is captured if Craig revisits it; memory-sync task is parked at [#C].
+- .emacs.d session: commit the ai-kb review files, process the two inbox handoffs, run spec-response on review4 to clear the two caveats, then build ai-kb.
+- velox: if a fresh boot ever shows the empty-agent prompt again, re-run ssh-add; the emacs.md rule likely needs make install on velox too.
+
+* Session Log
+
+** Startup + inbox triage
+
+Clean startup (no prior session-context). Rulesets Phase A.0 pull hit the transient git@cjennings.net access-rights error; templates synced from local working tree as-is. Task-review nudge: 10 tasks >7 days unreviewed.
+
+Inbox held 6 new files + recurring lint-followups.org. Three clusters: (1) the spec-review/spec-response workflow pair from linear-emacs (4 files: 2 drafts + 2 handoffs), validated by a real 2026-05-23 run; (2) two dotfiles-repo reference notes from archsetup that unblock the held memory-sync [#A] VERIFY (dotfiles split has settled — target is now common/.claude/projects/ in the standalone dotfiles repo); (3) lint-followups.org recurring noise.
+
+Confirmed neither spec workflow exists yet in claude-templates/.ai/workflows/ and INDEX.org has no spec entries.
+
+** Reviewing the spec workflows (in progress)
+
+Craig asked for a clarity + completeness review of both workflows before install, with online research to validate accuracy/completeness/clarity, and specifically to check the "implementation-ready spec" definition is strong enough. Dispatched 3 parallel research subagents (Definition-of-Ready/INVEST, requirements-quality standards IEEE 830 / ISO 29148, design-review + disposition-tracking practice) while I close-read both drafts.
+
+Research synthesis (all 3 returned clean):
+- *DoR/design-doc rubrics:* my 11-item readiness gate maps cleanly to INVEST + Scrum DoR + Google/Uber design-doc rubrics. Standard gaps in the GATE: security/privacy, observability/monitoring, success metrics, rollback. (Sources: Atlassian DoR, Scrum Inc, Pragmatic Engineer RFC roundup.)
+- *Requirements quality (IEEE 830 / ISO 29148):* my 13 dimensions are topic-buckets; standard attributes are properties. verifiable/traceable well covered (dim #3 + #12). Not covered: prioritization/ranking, set-level consistency, modifiability, singularity — mostly low-value for single-dev tools; set-level consistency is the useful one.
+- *Disposition tracking:* accept/modify/reject + document-the-no's is well-grounded (peer-review response letters, Fagan inspection). Biggest gap: reviewer/author disagreement resolution — author can reject unilaterally; mature processes (Google eng-practices, IETF RFC 7282) require a reasoned explanation back to the reviewer + escalation path. Also missing: explicit cycle-termination and a "verify dispositions landed" step.
+
+My own close-read findings:
+- spec-review Phase 1 (readiness gate) vs Phase 3 (re-run gate) ordering tension: several gate items (architecture-fit, API-verified) require the Phase 2 code read, so Phase 1 can't fully evaluate them. Needs framing as fast-triage (P1) vs authoritative gate (P3).
+- Gate (11 items) omits security + observability, but they ARE Phase 4 dimensions (#10, #13). Inconsistency — a spec could pass the gate with undefined security/observability. Confirmed by research.
+- high/medium finding severity not explicitly tied to blocking power.
+- spec-response Overview doesn't name spec-review as the review-file producer (handoff asked for the cross-link).
+
+Verdict pending Craig's call on which fixes to fold in before install. The "implementation-ready" definition is genuinely strong (gate + rubric, two complementary places, more concrete than most real DoR) — main improvements are closing the gate/dimensions security+observability gap and the P1/P3 triage-vs-gate clarity.
+
+** Applied fixes + installed the pair
+
+Craig chose option 1 (fold the high-value fixes, then install). Applied to canonical claude-templates/.ai/workflows/ then rsynced to the .ai/workflows/ mirror (identical, verified):
+- spec-review: Phase 1 reframed as fast triage with Phase 3 the authoritative gate after the code read; added security/privacy + observability to the 11-item gate (now 13, each with an escape hatch for trivial features); added severity↔blocking mapping in Phase 6 (high blocks Ready, medium is author discretion).
+- spec-response: Overview now names spec-review as the review-file producer; new "A reject goes back to the reviewer" principle (Google eng-practices / IETF RFC 7282); "Converge to implementation-ready" now states the loop's termination condition.
+- INDEX.org: new "Specs and design" section with both entries + trigger phrases, cross-linked as a pair.
+
+Publish flow: /review-code --staged inline → Approve (prose docs, no Critical/Important; one Minor noting linear-emacs/Codex provenance, conscious-choice). /voice personal 39 patterns (fired #37 fragments, #27/#32 first-person, #35 split). Committed 7f2aea1 feat(workflows): add spec-review and spec-response workflow pair (6 files, +706), authored Craig, 1 ahead of origin/main (push pending separate confirmation).
+
+Deleted the 4 absorbed spec inbox files (2 drafts + 2 handoffs).
+
+Pre-existing mirror drift left UNSTAGED and unaddressed (startup rsync surfaced it, unrelated to this task): .ai/workflows/task-audit.org, task-review.org, triage-intake.org modified + untracked .ai/scripts/screenshot.py + tests/test_screenshot.py — committed canonicals are ahead of committed mirror. Candidate for a separate chore(ai) resync commit.
+
+** Pushed both commits
+
+Committed 3f802eb chore(ai): resync workflow and script mirror with canonical (mechanical — 5 mirror files verified byte-identical to already-committed canonical, no new logic; /review-code Phase-0 skip, /voice skipped per mechanical-chore exception). Pushed 2d34e9a..3f802eb to origin/main (clean ff, fetch worked without the startup access error). Both this and 7f2aea1 now on origin/main, 0/0 in sync.
+
+** memory-sync — design decided: dedicated private repo
+
+Investigated current state: memory is tiny (228K, 54 .md files across 6 projects — work 40, rulesets 4, home 3, jr-estate 3, archsetup 2, .emacs.d 2). ~/.claude/projects/ as a whole is 321M (mostly .jsonl transcripts — must NOT sync those). ~/.dotfiles cloned, no .claude tree. Encoded project dir names are portable across machines (consistent ~/code, ~/projects paths).
+
+Design discussion with Craig worked through dotfiles → rulesets → dedicated repo:
+- Dropped dotfiles: it's machine config, different cadence; the task's "via dotfiles" scope was inherited, not principled.
+- Dropped rulesets: rulesets is pulled first in EVERY session of every project, so memory edits (tracked-file changes) dirty its working tree and the startup git pull --ff-only skips. That's a rulesets-specific hot-path problem; dotfiles and a dedicated repo both avoid it.
+- Storage-unification vs recall-scoping are orthogonal: one private repo unifies storage; recall stays per-project (keyed by encoded-cwd subdir) for relevance, index cost, and disclosure-via-recall guardrails. Don't merge the recall pools.
+
+DECISION: dedicated private repo claude-memory.git on cjennings.net (private by virtue of the server, never GitHub — work memory holds DeepSat-private content). Mechanism: folded dir-symlinks from each ~/.claude/projects/<enc>/memory into a local clone (~/.claude-memory/<enc>/memory); new memory auto-lands in the clone working tree, commit+push syncs. Idempotent link-claude-memory.sh recreates symlinks on a new machine after clone.
+
+Plan: (1) bare repo on server, (2) clone to ~/.claude-memory, (3) move the 6 memory dirs in + symlink, (4) linker script + README, (5) commit+push, (6) resolve todo VERIFY + mark DOING done, (7) handle the 2 dotfiles inbox notes.
+
+** memory-sync — shipped
+
+Executed the dedicated-repo plan. SSH to cjennings.net works non-interactively (passwordless sudo confirmed); the startup access-rights error was transient. Steps done:
+- Created bare git@cjennings.net:claude-memory.git (sudo git init --bare, chown git:git, mirrors dotfiles.git layout).
+- Cloned to ~/.claude-memory (origin set, Craig identity).
+- Moved all 7 per-project memory/ dirs into the clone (54 .md files; work 40, rulesets 4, home 3, jr-estate 3, archsetup 2, .emacs.d 2, linear-emacs 0) and replaced each ~/.claude/projects/<enc>/memory with a folded dir-symlink. Verified all 7 symlinks resolve, this session's own rulesets memory reachable, no real dirs left behind, no .jsonl transcripts pulled in.
+- Wrote link-claude-memory.sh (idempotent, shellcheck-clean — re-run reports 7 already-linked, 0 conflicts) + README.org (privacy note: never GitHub).
+- Initial import committed f496370 and pushed to origin/main (upstream set, 0/0).
+
+todo.org: flipped the ** DOING memory-sync task to DONE [#A] + CLOSED [2026-05-23]; rewrote the stow VERIFY into two dated entries (decision + shipped). Committed 0f4d1f8 chore(todo): close cross-machine memory sync via dedicated repo — rulesets ahead 1, UNPUSHED (push pending confirmation).
+
+Inbox: deleted the 2 dotfiles reference notes (purpose served, decision went to a dedicated repo). lint-followups.org remains (recurring noise).
+
+** Closed out — both commits pushed, inbox empty
+
+Pushed 0f4d1f8 (todo closure). lint-followups.org was tracked → git rm + 2956066 chore(inbox): clear recurring lint follow-ups. Pushed both (3f802eb..2956066), rulesets 0/0. Inbox now empty (just .gitkeep).
+
+** git-push password prompt — diagnosed + fixed velox
+
+Craig asked why git push prompts for a password each time. Diagnosed by sshing into the machines directly (Craig nudged: I have ssh access, use it rather than ask for pasted output — reinforced in [[feedback_never_guess]], added reference memory reference_ssh_auth_gpg_agent). Findings:
+- This machine is ratio. SSH/git auth routes through gpg-agent (dotfiles .zshenv line 9 sets SSH_AUTH_SOCK to the gpg-agent ssh socket). One ED25519 key (SHA256:c592Qs...) is both on disk (~/.ssh/id_ed25519, passphrase-protected) and in gpg-agent. Reach the agent → silent (cached ~400 days); miss it → ssh falls back to the on-disk key → passphrase prompt every push.
+- ratio: agent loaded, works (why my pushes are silent). velox: routing + key on disk present, but gpg-agent had NO loaded identity (sshcontrol keygrip without key material) → prompt every push.
+
+Fixed velox from here: ssh velox 'ssh-add ~/.ssh/id_ed25519' loaded the key; first git use triggered pinentry-fuzzel on velox's display and Craig entered the passphrase → now cached ~400 days. Verified: ssh-to-git exit 0 + git ls-remote returns refs/heads/main silently from velox.
+- Bonus: claude-memory.git bare HEAD pointed at master (content is on main) — repointed via sudo git symbolic-ref so fresh clones check out main. Confirmed ls-remote HEAD now resolves.
+
+Memory writes this turn (feedback update + new reference_ssh_auth_gpg_agent + MEMORY.md) landed in ~/.claude-memory via the new symlinks — the sync mechanism works end to end. That repo now has uncommitted memory changes to push.
+
+** /brainstorm — memory architecture redesign (reframes the dedicated-repo decision)
+
+Craig invoked /brainstorm on "the claude rulesets memory situation and enhancements." His requirements, ranked:
+1. *(main)* Cross-project sharing of GENERAL memories. ~10-20% of memories are general lessons valuable everywhere, but each project re-learns them. He's been leaning on workflows as a workaround (asked whether that's appropriate — my take: workflows are for procedures, memory for facts/lessons; the right fix is a shared-memory tier, not converting lessons to workflows). Sharing criterion: general lesson applicable anywhere → share; project-specific → don't; unsure → ask.
+2. Fewer repos. Dislikes tracking many. Wants GENERAL/shared memory tracked in the RULESETS repo (inherited by all projects). Wants PROJECT memory moved back to each project (committed in the project's own repo where appropriate, or accepted as at-risk/backup-only), then DELETE the dedicated claude-memory repo. (This reverses today's dedicated-repo decision — fine, now that the real goal is cross-project sharing + repo consolidation.)
+3. Staleness/duplication worry — wants a curation solution (asked me to propose one).
+
+Implication: claude-memory.git (created earlier today) becomes transitional — likely deleted once the two-tier design lands. Note before deleting: it currently holds the only synced copy of all project memory + the 3 diagnosis memories.
+
+Load-bearing fact to verify before Phase 2: does Claude Code natively support a global/user-level memory tier loaded into every project, or must shared memory be physically present in each project's memory recall path? Dispatching claude-code-guide.
+
+** Brainstorm cancelled + migration fully reversed
+
+Craig cancelled the brainstorm (no design doc was written — nothing to clean up) and asked to undo the claude-memory migration back to pre-migration state. Done safely:
+- Reversed all 7 symlinks by moving the real memory dirs back to ~/.claude/projects/<enc>/memory/ (content-first, so nothing lost — rulesets has its 6 files incl. this session's 2 new ones; work's 40 intact; linear-emacs came back with 2).
+- Deleted the local clone ~/.claude-memory.
+- Deleted the bare repo /var/git/claude-memory.git on cjennings.net (sudo rm -rf).
+State is now exactly pre-migration: plain per-project memory dirs at the harness location, no clone, no repo. The session's diagnosis memories (reference_ssh_auth_gpg_agent, feedback_no_inline_code_markup, updated feedback_never_guess + MEMORY.md) are preserved in the live rulesets memory dir.
+
+The two-tier design idea is captured above (shared general lessons → a rulesets-tracked file symlinked into ~/.claude/rules/ loaded everywhere natively; project memory under each project's .ai/memory/) if Craig revisits it later — but it was NOT implemented; brainstorm cancelled.
+
+** STALE: todo.org memory-sync task
+
+todo.org still has the memory-sync task marked DONE [#A] (commit 0f4d1f8, pushed) with dated "Decided: dedicated repo" + "Shipped: claude-memory.git" entries — now FALSE, since the repo is deleted and memory is back to unmanaged. Needs correction: reopen (DONE→DOING), drop the CLOSED line, add a dated "Reversed" entry. Pending Craig's call on reopen-vs-rescope-vs-defer.
+
+** Reopened task (parked) + startup-style sync
+
+Craig chose option 3: reopened the memory-sync task as TODO [#C] (parked), dropped the CLOSED line, added a dated "Reversed the migration" entry capturing the undo + the two-tier idea for later. Committed 349a8c7 (unpushed, rulesets ahead 1).
+
+Then ran a startup-style sync ("as if just starting"):
+- Phase A.0 fetch: 0 behind, 1 ahead (the reopen) — nothing upstream to pull.
+- Phase A rsyncs (protocols.org, workflows/, scripts/ from canonical → .ai/): clean no-op, mirror already matched canonical.
+- sync-language-bundle.sh: silent (rulesets has no bundle).
+- make doctor found 1 failure: claude-rules/emacs.md (Craig's committed live-reload rule, 1d4f6fb) was never make-install'd on this machine (ratio) — no symlink in ~/.claude/rules/. Ran make install (idempotent) to link it. Re-ran doctor: 41 ok / 0 warnings / 0 failures.
+
+** Cross-project: spec-review on .emacs.d ai-kb.org (Craig: do it from here)
+
+Craig asked to run spec-review on ~/.emacs.d/docs/design/ai-kb.org from this rulesets session. Flagged the cross-project boundary; he chose "do it from here" → will write ai-kb-review.org into .emacs.d and drop a handoff into .emacs.d/inbox/.
+
+The spec (ai-kb): a SECOND org-roam database at ~/sync/org/ai-kb/ as the agent's global/durable/linked long-term memory, separate from personal roam. Files are source of truth; agent reads/writes via file tools + grep (no DB needed for links); Emacs browsing via a switch command that rebinds org-roam-directory/db + runs db-sync. Global rule at rulesets claude-rules/ai-kb.md loads into every project (the cross-project sanction). Step 1 = store + rule + provisioning (make ai-kb-init/setup-ai-kb.sh); Step 2 = Emacs layer in org-roam-config.el; Step 3 (migrate .ai/sessions+workflows) deferred.
+
+Craig's review asks to fold in: confirm it can be the org-roam storage for memories; project-awareness (project tags — spec only has TYPE tags, gap); Claude-Code startup access (rule loads but nodes are grep-on-demand, not auto-loaded — assess); automatic agent-driven version control (is ~/sync/org git? — must verify); fresh-machine setup straightforward; my own added ideas; a vNext section (token-efficient, fully recoverable).
+
+Dispatched an explore subagent for .emacs.d org-roam config + ~/sync/org git/sync state + Makefile/scripts + agentic-knowledgebase.org + related todo/ERT facts.
+
+** ai-kb spec-review — done (cross-project, artifacts in .emacs.d)
+
+Ran spec-review on ~/.emacs.d/docs/design/ai-kb.org. Verdict: Not ready → Ready-with-caveats once 4 decisions land (version control + recovery — ~/sync/org is Syncthing-only, not git; guard the org-roam switch against global autosync + completed-task hook misrouting; active startup surface via a small index node; project-awareness via a :project: tag). Medium: add a curation workflow (task-review-for-memory), argue org-roam over a flat shared file, name the 3 provisioning homes, define the conflict model.
+
+Artifacts written into .emacs.d (Craig's "do it from here"): docs/design/ai-kb-review.org (full review) + inbox/2026-05-24-0210-from-rulesets-ai-kb-spec-review.org (handoff carrying verdict + proposed [#B]/[#D] tasks for the .emacs.d session to file). Did NOT edit .emacs.d todo.org from outside — routed via the handoff. Details live in those files, not here (cross-project boundary).
+
+** Next Steps
+
+- Pushed 349a8c7 (task reopen) → rulesets 0/0 in sync. Working tree clean except untracked session-context.org.
+- (.emacs.d session) file the proposed ai-kb tasks from the inbox handoff; resolve the 4 blocking decisions before building.
+
+** ai-kb re-review (round 4)
+
+Craig asked for a re-review of the revised ai-kb.org (244 lines — reviews 1-3 incorporated via spec-response, incl. a Codex review2 + a review3). Verdict: Ready with caveats (matches its claimed status) — all 4 of my prior blockers genuinely resolved. Two remaining caveats, both in the write loop: (1) push-failure/offline behavior undefined (auto-commit-push on every write would error/hang when offline or the gpg-agent key isn't loaded — needs commit-local-always, push-best-effort); (2) index.org generation/refresh undefined (needs a regen script or it drifts and defeats the startup surface). Minors: org-lint error-vs-warning gating, soft "read index" trigger, MEMORY.md→ai-kb dangling pointers, switch guard under abnormal exit, one-time server bare-repo bootstrap. Wrote docs/design/ai-kb-review4.org (named 4 per Craig; review3 already existed) + inbox handoff 2026-05-24-0259-from-rulesets-ai-kb-review4.org in .emacs.d.
+- New-machine TODO: after cloning rulesets + claude-memory, run ~/.claude-memory/link-claude-memory.sh.
+- Optional: auto-commit hook on ~/.claude-memory if manual push becomes friction.
+- Carryover [#C]: create-documentation skill, /update-skills skill.
diff --git a/inbox/lint-followups.org b/inbox/lint-followups.org
new file mode 100644
index 0000000..183b27d
--- /dev/null
+++ b/inbox/lint-followups.org
@@ -0,0 +1,5 @@
+
+* 2026-05-24 lint-org follow-ups — todo.org
+** TODO line 1460 — misplaced-heading — Possibly misplaced heading line
+
+* 2026-05-24 Sun — Task-review health: 10 top-level [#A]/[#B]/[#C] tasks unreviewed for >30 days (daily review may have slipped)
diff --git a/todo.org b/todo.org
index 8c2ed04..4e810da 100644
--- a/todo.org
+++ b/todo.org
@@ -43,7 +43,7 @@ picks up the same memory tree.
 Worked through dotfiles → rulesets → dedicated repo. Dropped stow/dotfiles (machine config, wrong cadence) and rulesets (it's pulled first in every session, so memory edits would dirty its tree and skip the startup =git pull --ff-only=). Chose a dedicated private repo on cjennings.net: storage is unified there while recall stays per-project (the encoded-cwd subdirs), since pooling recall would hurt relevance and risk work-private facts surfacing in personal-project artifacts.
 
 *** 2026-05-23 Sat @ 16:12:48 -0500 Shipped: claude-memory.git + folded symlinks
-Created bare =git@cjennings.net:claude-memory.git=, cloned to [[file:/home/cjennings/.claude-memory/][~/.claude-memory]], moved all 7 per-project =memory/= dirs in (54 files; work has 40) and replaced each live =~/.claude/projects/<enc>/memory= with a folded dir-symlink so new memory lands in the clone and a push syncs it. Added =link-claude-memory.sh= (idempotent — recreates the symlinks on a new machine after clone) + README. Private repo, never GitHub (carries work/DeepSat memory). Initial import pushed (=f496370=).
+Created bare =git@cjennings.net:claude-memory.git=, cloned to =~/.claude-memory= (later deleted in the reversal below), moved all 7 per-project =memory/= dirs in (54 files; work has 40) and replaced each live =~/.claude/projects/<enc>/memory= with a folded dir-symlink so new memory lands in the clone and a push syncs it. Added =link-claude-memory.sh= (idempotent — recreates the symlinks on a new machine after clone) + README. Private repo, never GitHub (carries work/DeepSat memory). Initial import pushed (=f496370=).
 
 *** 2026-05-24 Sun @ 01:53:35 -0500 Reversed the migration — back to unmanaged per-project memory
 Cancelled the follow-up brainstorm and undid the dedicated-repo migration at Craig's call. Moved all 7 memory dirs back to =~/.claude/projects/<enc>/memory/= (content preserved), deleted the =~/.claude-memory= clone, and deleted the bare =claude-memory.git= on the server. Memory is back to its original at-risk state, so the task reopens at [#C] pending a direction. The brainstorm landed on a two-tier idea for whenever this resumes: promote general lessons into a rulesets-tracked file symlinked into =~/.claude/rules/= (loaded into every project natively, one repo), and keep project-specific memory under each project's own =.ai/memory/= (committed where =.ai/= is tracked, at-risk where it's gitignored). Not implemented.