bastien
ddea411491
Every superpowers-prefixed skill call in ship-feature, init-project, tour, deploy, audit-delta, plugin-advisor and lib/analyze-before-plan now names the vendored skill directly. finishing-a-development-branch is described as the upstream skill this config does not vendor (gitflow finish is the integration path). CLAUDE.global.md Skill routing maps the four non-vendored skills the vendored text still references. settings.json loses the plugin key and its marketplace block; README, USAGE, plugin-advisor and the profile skill describe superpowers as vendored skills, always on, zero plugin cost. CHANGELOG entry with a known residual.
92 lines
4.5 KiB
Markdown
92 lines
4.5 KiB
Markdown
# CAPITALIZE-COMMIT — couple the memory commit to the dev flow
|
|
|
|
Inline snippet. Include at the END of any dev flow's CAPITALIZE step, AFTER the
|
|
approved registry / journal / TODO entries are written. It commits ONLY the
|
|
memory, surgically, so the flow never leaves an uncommitted `.claude/memory`
|
|
behind and never embarks dangling code.
|
|
|
|
This is the TAIL of capitalize, not a replacement: the SCAN + APPROVAL GATE that
|
|
decide WHAT to write are unchanged and run before this snippet. Only the COMMIT
|
|
of the already-approved entries is automated here.
|
|
|
|
## WHEN TO RUN
|
|
|
|
At the capitalize step, once the approved entries are written to
|
|
`.claude/memory/*` (and any `.claude/tasks/TODO.md` reconcile is done), with the
|
|
code already committed.
|
|
|
|
- Inline-commit flows (feat / hotfix / bugfix / commit-change): run it right
|
|
after writing the entries, on the current branch.
|
|
- Orchestrators that integrate via `gitflow finish` (the upstream
|
|
finishing-a-development-branch is not vendored; ship-feature / init-project):
|
|
run it BEFORE the FINISH step — otherwise the memory commit strands outside
|
|
the merge/PR. See ORDERING.
|
|
|
|
This snippet commits whatever is PENDING under `.claude/memory` + `.claude/tasks`;
|
|
it does NOT decide content. A flow whose gate wrote only a journal line yields a
|
|
`chore(memory): journal — …` commit (one memory commit per flow — Frame 2 / F3).
|
|
If a flow should stay fully silent on a trivial run, that is the FLOW's gate
|
|
policy (e.g. hotfix skipping the journal line), not this snippet's concern —
|
|
tune it there.
|
|
|
|
## DO
|
|
|
|
1. Compose the message from the IDs just written + the flow, matching repo style
|
|
`chore(memory): <IDs> — <flow> <short>`. Examples:
|
|
- `chore(memory): BDR-034 + LRN-051 — feat dark-mode toggle`
|
|
- `chore(memory): BLK-010 resolved — bugfix profile path`
|
|
- `chore(memory): journal — hotfix copy typo` (journal-only, nothing else)
|
|
|
|
2. Commit surgically via the helper, capturing the memory-commit hash it prints:
|
|
|
|
mem_hash=$(bash "$HOME/.claude/lib/memory-commit.sh" commit "<message>")
|
|
rc=$?
|
|
|
|
3. Report by (rc, mem_hash):
|
|
- rc 0, mem_hash non-empty → `✅ mémoire committée <mem_hash>`
|
|
- rc 0, mem_hash empty → `CAPITALIZE: rien à committer` (helper no-op)
|
|
- rc 3 → unsafe git state (detached / merge in progress);
|
|
memory stays in the working tree for a manual
|
|
commit — surface the helper's stderr.
|
|
|
|
`<mem_hash>` is the MEMORY commit (the one that ADDS the entries). It is NOT
|
|
the code-commit hash that capitalize anchored INSIDE the entries
|
|
(`Reference: commit <code-hash>`). Two commits, two hashes — never report the
|
|
code hash here.
|
|
|
|
## HARD RULE — surgical scope
|
|
|
|
The helper stages and commits ONLY `.claude/memory` + `.claude/tasks`, filtered
|
|
to paths with real changes, via pathspec — never `git add -A` / `git add .` /
|
|
`git commit -a`. Automation removes the human diff review that would catch an
|
|
accidental stage, so the scope IS the safety. Do NOT bypass the helper with a
|
|
manual `git add` / `git commit`: that reintroduces the exact risk the helper
|
|
removes (proven: dangling code, untracked or pre-staged, is never embarked; a
|
|
no-match pathspec is filtered, not fatal).
|
|
|
|
## ORDERING (orchestrators only)
|
|
|
|
`finishing-a-development-branch` (upstream superpowers skill, not vendored
|
|
here; `gitflow finish` is the only integration path) may merge-and-delete the
|
|
branch or push a PR. A memory commit created AFTER it lands outside the
|
|
integrated history — stranded on the PR path. So in ship-feature / init-project
|
|
this snippet runs BEFORE FINISH. The code commits already exist (implementation
|
|
step), so the entries' hash references are valid at this point.
|
|
|
|
## WHAT THIS DOES NOT DO
|
|
|
|
- Does NOT commit code — the code commit happened upstream (implementation step).
|
|
- Does NOT push — pushing / merging is FINISH's job, which runs AFTER this in
|
|
orchestrators.
|
|
- Does NOT decide WHAT to capitalize — the scan + approval gate upstream own
|
|
that; this only commits what was already approved and written.
|
|
- Does NOT reference or echo the code-commit hash anchored in the entries — it
|
|
reports only the memory-commit hash the helper returns.
|
|
- Does NOT run if you hand-roll `git add` / `git commit` instead of the helper —
|
|
bypassing it drops the surgical-scope guarantee. Always call the helper.
|
|
|
|
## IDEMPOTENT
|
|
|
|
Safe to run when memory is already clean: the helper no-ops (exit 0, empty
|
|
stdout, no commit). Running it twice creates at most one commit.
|