@thebassclef/lite 1.0.4 → 1.1.1

package/dist/lite/.claude/rules/pr-strategy.md

@@ -0,0 +1,142 @@
+---
+tier: lite
+description: "The default PR strategy for any multi-issue iteration is stacked atomic branches: one branch per issue, one PR per branch, each independently reviewable and revertable."
+---
+
+# PR Strategy — Stacked Default (Mechanically Enforced)
+
+The default PR strategy for any multi-issue iteration is **stacked atomic
+branches**: one branch per issue, one PR per branch, each independently
+reviewable and revertable. Bundling multiple issues into a single PR is
+the **explicit override**, requested via `bundle: true` in the iteration
+goal's frontmatter (or operator statement) at iteration scaffold time.
+
+This rule was methodology-only in v0. **As of Phase II Trim the Fat
+(2026-05-07), it is mechanically enforced** by the `atomic-pr-check.sh`
+hook, which fires on `git push` and BLOCKs branches with multiple WU-N
+tags in commit messages unless a matching iteration goal declares
+`bundle: true` in frontmatter.
+
+INSTEAD of relying on agent self-discipline: the hook reads the branch's
+commits, counts distinct WU-N tags, and either passes (≤1 distinct tag)
+or BLOCKs with a structured remediation message (multi-step without
+`bundle: true`).
+
+## Default behavior
+
+When `/autonomous start` enters Construction with N≥2 issues in scope:
+
+- Each issue → its own branch (`feature/ISSUE-NNN-stack-N-slug`)
+- Each branch → its own PR
+- Per `standards/branch-stacking.md`: independence is designed in,
+  graceful unwind is mechanical, manifest declares dependencies
+- Boot sequence does NOT ask "stacked or bundled?" — assumes stacked
+
+## Override: `bundle` flag
+
+To collapse a multi-issue iteration into a single PR, the operator
+supplies `bundle` at boot:
+
+```
+/autonomous start orchestrator-gated bundle
+/autonomous start operator-gated sequential bundle
+```
+
+Or states it conversationally during scope confirmation. The default
+short-circuits unless the override is present.
+
+## When bundling IS acceptable
+
+Use `bundle` when ALL of these hold:
+
+1. **Single logical concern** — all changes serve one decision; splitting
+   would be artificial (e.g., a tightly-coupled rename across N files
+   that doesn't compile in isolation).
+2. **Tight coupling that breaks atomic verification** — branch N can't
+   pass `/verify` without branch M's changes (decomposition gap, not a
+   feature).
+3. **Emergency hotfix** — staging delay between PRs would compound the
+   incident; one PR + one merge gets fixes to prod faster.
+4. **Operator explicitly requests** — `bundle` flag or verbatim
+   instruction.
+
+If only #4 holds without #1-3, push back: "stacked is default; what
+about this scope makes bundling correct?"
+
+## When stacking is mandatory
+
+Stack regardless of operator preference when:
+
+- **Mix of skill + rule + hook changes** — different review surfaces;
+  reviewer needs to evaluate each independently
+- **Mix of new files + existing-file edits** — independent revert paths
+- **Different blast radii** — high-radius changes (hooks, schemas)
+  shouldn't ride with low-radius (doc edits) in one PR
+- **Multi-WS iteration goal** — workstreams are separate intents by
+  definition
+
+## Enforcement
+
+- **Hook (mechanical)**: `.claude/hooks/atomic-pr-check.sh` fires on
+  Bash tool calls matching `git push`. Counts distinct WU-N tags in
+  branch commits. BLOCKs multi-step branches without `bundle: true` in
+  a matching iteration goal's frontmatter. Phase II Trim the Fat
+  shipped this as the v1 mechanical-enforcement layer.
+- **Boot sequence** (`strategy/autonomous-boot-sequence.md` Step 4):
+  scaffold prompt skips PR-strategy question unless `bundle: true`
+  supplied
+- **Skill args** (`.claude/skills/autonomous/SKILL.md`): `bundle` listed
+  in args reference table
+- **Standard** (`standards/branch-stacking.md`): declares stacked as
+  default at the top
+- **Methodology**: agent self-checks before pushing; the hook is the
+  backstop, not the only line of defense
+
+INSTEAD of methodology-only enforcement: the hook fires automatically
+on every `git push`. Bypass with `SKIP_ATOMIC_PR_CHECK=1` (logged via
+trace-helper) only for genuine bypass cases.
+
+## Override path
+
+`bundle` at boot. No mid-session switch — once a stack manifest is
+written, the strategy is locked for that bet (changing mid-flight would
+require re-decomposing scope).
+
+## Merge protocol — MUST read before merging any stacked PR
+
+When merging stacked PRs with declared dependencies (Graphite-style:
+dependent PR's `baseRefName` is another feature branch, not `main`),
+**read `standards/branch-stacking.md` §"Squash merge — two protocols"
+BEFORE the first merge in the stack**.
+
+Two protocols exist; picking one is mandatory:
+
+1. **Retarget-before-merge** (preferred) — retarget dependents to
+   `main` via `gh pr edit <PR> --base main` before merging the parent.
+   Dependents survive the cascade.
+2. **Rebase-after-merge** (fallback) — only if auto-close already
+   fired. Per-PR rebase + re-create. Costs 3-8 turns per stack.
+
+Helper: `scripts/check-stack-dependents.sh <PR-N>` lists PRs that
+will auto-close when PR N merges with `--delete-branch`.
+
+**Why this rule repeats what the standard says**: agents load the
+`.claude/rules/` directory automatically. Standards live in
+`standards/` and are referenced by path. Moving the ceremony-layer
+pointer into the rule means an agent that reads `pr-strategy.md`
+at merge-time is told to go read the protocol — closes the
+"standard exists but agent didn't read it before acting" gap
+observed 2026-04-22 (#245 auto-closed on #244 merge because the
+retarget protocol wasn't consulted).
+
+## Relationship to other rules
+
+- `branching.md` — trunk-based + squash merge (governs all branches)
+- `iteration-bet-brief-completeness.md` — Orchestrator transmits
+  manifest to Builder; manifest carries the strategy decision
+- `commit-conventions.md` — PR titles per format regardless of strategy
+- `bassclef-workflow-parity.md` — sibling-grep discipline applies per
+  PR, not per strategy
+- `standards/branch-stacking.md` §"Squash merge — two protocols" —
+  merge-time recovery protocols; MUST read before first merge in any
+  stack

package/dist/lite/.claude/rules/pr-title-shape.md

@@ -0,0 +1,90 @@
+---
+tier: lite
+description: Sister rule to pr-body-shape.md. Encodes authoring-time discipline for the PR title surface. Titles show in gh pr list, GitHub search, and mobile views — they are the…
+---
+
+# PR Title Shape Contract
+
+Sister rule to `pr-body-shape.md`. Encodes authoring-time discipline for the PR title surface. Titles show in `gh pr list`, GitHub search, and mobile views — they are the highest-visibility surface in the PR-authoring stack.
+
+## When this rule fires
+
+Any time a PR title is being written via:
+
+- `gh pr create --title ...`
+- `gh pr edit <N> --title ...`
+- Direct REST `curl POST /repos/<o>/<r>/pulls` with a `title` field
+- GitHub web UI (manual operator authoring)
+
+## Format contract
+
+Every PR title is:
+
+- **≤72 characters** (mobile views truncate; squash-merge commit messages prefer short)
+- **One conventional-commit prefix** per `commit-conventions.md` — `feat:`, `fix:`, `docs:`, `refactor:`, `test:`, `ci:`, `chore:`, `security:`
+- **One primary change** — sub-concepts go in the body Summary, not the title
+- **Bet/WU reference** as `(WU-N)` only when present; bet ref belongs in body Refs
+
+Recommended shape: `<type>(<scope>): <verb> <object> (<optional WU-N>)`
+
+Examples (all ≤72 chars):
+
+- `feat(#1241): document the pseudonym registry file (WU-4)`
+- `fix(bassclef#1125): jq+set -e fail-soft fix in 2 hooks (WU-8)`
+- `chore: update whereami; close bet 2026-06-19b (WU-5)`
+
+## DON'T / INSTEAD catalog
+
+### Length and structure
+
+| Don't | INSTEAD |
+|---|---|
+| Exceed 72 chars (mobile truncates; squash commit messages prefer short) | Keep under 72; cut to one concept |
+| Stack multiple concepts with `+` or `—` (`carry-forward + housekeeping + roadmap-reconcile`) | Name the ONE primary change; sub-concepts go in body Summary |
+| `(WU-N of bet YYYY-MM-DDx)` suffix bloat | Either drop entirely or `(WU-N)` alone — bet ref belongs in body Refs |
+| Ticket-ref bloat with verbose body (`chore(bassclef#1031): document operator-private-pseudonyms.json registry shape`) | Either prefix `(#NNNN)` OR a full descriptive body — not both |
+
+### Conventional-commit prefix
+
+| Don't | INSTEAD |
+|---|---|
+| Conventional-commit prefix mismatch (`chore` for substantive features) | Match prefix to actual change type per `commit-conventions.md` |
+| Invent bassclef-internal prefixes (`substrate-defect:`, `bet:`, `closeout:` outside of `chore(closeout)`) | Use the 8 standard types only; substrate bugs are `fix:` |
+| Process narration as title (`/longrun pre-flight`, `/session-end for X`) | Name the artifact change (`prep goal doc`, `update whereami`) |
+
+### Plain English
+
+| Don't | INSTEAD |
+|---|---|
+| Bassclef-internal compound verbs/nouns (`Pattern-B mv`, `review-file pass`, `registry shape`) | Plain verb + object (`move`, `run`, `document the file schema`) |
+| Uncommon hyphenated prose compounds (`carry-forward`, `pre-flight` as title prose) | Plain words (`continued`, `prep`); literal filenames + CLI flags + script names preserve as code identifiers |
+| Buzz adjectives in titles (`substantive`, `comprehensive`, `robust`) | Concrete verb + concrete object |
+| Bassclef-internal verbs (`flip`, `Pattern-B'd`, `seed` as noun) | Plain verbs (`update`, `move`, `set up`) |
+
+### Cross-surface consistency
+
+| Don't | INSTEAD |
+|---|---|
+| Repeat literal filenames in both title and body Summary | Plain title; filenames in body where they're grep-anchored to the actual change |
+| Mix `skillname` and `/skillname` for the same skill across titles | Use `/skillname` consistently when referencing the skill; plain filename when referencing the file (e.g., `docs/whereami.md`) |
+
+## Mechanical enforcement
+
+Wordlist BLOCK terms are caught by `pre-gh-pr-title-scrub.sh` at write time. This rule covers everything else as methodology. Hook extension to catch the additional catalog rows is sibling work tracked at bassclef#1241.
+
+## Override path
+
+`SKIP_PR_TITLE_SHAPE=1 <command>` — logged via trace-helper. Use rarely:
+
+- Quoting an exact phrase from a memory file or external doc that requires verbatim retention
+- One-off automated dispatch where the title is generated by a third-party tool
+
+## Composes with
+
+- `.claude/rules/pr-body-shape.md` — sister rule at the body surface
+- `.claude/rules/commit-conventions.md` — conventional-commit format
+- `.claude/rules/plain-english-discipline.md` — master plain-English rule
+- `.claude/rules/operator-facing-prose.md` — gloss + /kiss meta-discipline
+- `.claude/rules/context-engineering.md` — INSTEAD-block discipline (foundational)
+- `standards/bassclef-internal-jargon.md` — wordlist driving BLOCK substitutions
+- `.claude/hooks/pre-gh-pr-title-scrub.sh` — mechanical floor

package/dist/lite/.claude/rules/prototype-workflow.md

@@ -0,0 +1,53 @@
+---
+tier: lite
+description: "Design prototypes (artifacts under docs/prototypes/**) are visual statements to Reviewer (\"this is what we want built\")."
+---
+
+# Prototype Workflow — Visual Confirm Before Commit
+
+Design prototypes (artifacts under `docs/prototypes/**`) are visual
+statements to Reviewer ("this is what we want built"). They MUST NOT
+enter git history until the operator has confirmed the rendered output.
+
+## Protocol for prototype edits
+
+When modifying a file under `docs/prototypes/**/*.{html,css,tsx,jsx}`:
+
+1. **Render** — open the prototype locally (dev server, Playwright MCP, or direct file)
+2. **Screenshot** — save to `.playwright-mcp/prototype-render-<branch>.png` or equivalent
+3. **Share with operator** — show rendered output, wait for explicit confirmation
+4. **Then commit** — only after confirmation
+
+Committing first and sharing after inverts the gate: git history now
+holds unapproved state, and any revert has to serve only as a rule-
+violation record.
+
+## Distinction from production-UI visual review
+
+- **Production UI** (per usability rule #7): Reviewer diffs built surface
+  against prototype before merge
+- **Prototype edits** (this rule): agent confirms rendered prototype
+  against operator intent before commit
+
+The two gates are complementary. Production gate catches drift from
+prototype; this gate catches drift from operator intent.
+
+## When this rule does NOT fire
+
+- Non-visual edits to prototype directory (README, notes, data fixtures)
+- Branch explicitly scoped to "prototype cleanup / lint / formatting"
+  with no visual change (agent must assert no-visual-change)
+
+## Relationship to other rules
+
+- `usability.md` #7 — production UI visual review; this rule's upstream
+- `design-direction.md` — prototype approvals are load-bearing once
+  given; this rule governs HOW to get them
+- `sdlc-gates.md` — post-build gates; prototype confirmation is a
+  pre-commit gate
+
+## Enforcement
+
+Methodology-level today. Future mechanical backstop (proposed): pre-commit
+hook checks paths matching `docs/prototypes/**/*.{html,css}` and requires
+a render artifact newer than the edit plus an operator-confirmation marker.

package/dist/lite/.claude/rules/reserved-skill-names.md

@@ -0,0 +1,103 @@
+---
+tier: lite
+description: "Bassclef MUST NOT create a skill (.claude/skills/<name>/SKILL.md) with a name Claude Code's harness already claims."
+---
+
+# Reserved Skill Names
+
+Bassclef MUST NOT create a skill (`.claude/skills/<name>/SKILL.md`)
+with a name Claude Code's harness already claims. Collisions are
+silent and behavioral: operator types `/<name>` expecting bassclef's
+skill; harness resolves the built-in first and returns something else.
+
+The authoritative list lives in `standards/reserved-skill-names.md`.
+This file is the **rule** — semantics, enforcement, override path.
+
+## When this rule fires
+
+On any commit (or PR) that stages a new `.claude/skills/<name>/SKILL.md`
+where `<name>` appears in the `standards/reserved-skill-names.md` list.
+
+Does NOT fire on:
+- Edits to existing skill files (only NEW skill directories)
+- Files outside `.claude/skills/`
+- Skills whose name includes a prefix/suffix avoiding collision
+  (e.g., `/docs-generator`, `/review-pr`)
+
+## Enforcement
+
+### Mechanical — pre-commit hook
+
+`.claude/hooks/pre-commit-gate.sh` checks staged skill directories
+against the reserved list. On collision, emits:
+
+```
+BLOCKED: reserved skill name — `<name>` collides with a Claude Code
+built-in. See standards/reserved-skill-names.md. Rename or override
+with SKIP_RESERVED_NAMES=1.
+```
+
+Blocks the commit. Per `blocked-items.md`, the block must be resolved
+(rename) or explicitly deferred (override with rationale) — silence
+is not deferral.
+
+### Methodology — agent self-check
+
+When drafting a new skill, the agent MUST:
+
+1. Read `standards/reserved-skill-names.md` before proposing a skill name
+2. If the proposed name matches, either:
+   - Pick a different name
+   - Justify the override (see Override path below)
+3. Cite the check in the PR body ("Reserved-names check: [name] — no
+   collision" or "collision — override justified by X")
+
+The "Sources read" block per `artifact-ingestion.md` covers this
+citation automatically when a new-skill PR references the standards list.
+
+## Override path
+
+Rare case — bassclef wants to deliberately shadow a harness built-in:
+
+1. Add a note to the skill's SKILL.md frontmatter:
+   `reserved_name_override: "<name> — rationale"`
+2. Commit with `SKIP_RESERVED_NAMES=1 git commit ...`
+3. Call out the override in the PR body
+
+The override exists because rules should be judgeable. But the friction
+is deliberately high — bypassing the hook requires conscious intent.
+
+## What counts as a "collision"
+
+Exact string match, case-insensitive, against the `Name` column of
+`standards/reserved-skill-names.md`. The skill directory name (not the
+slash-command alias, not the frontmatter `name:` field) is what the
+harness resolves; the directory name is what the hook checks.
+
+Prefixes and suffixes break collision:
+
+| Reserved | Bassclef skill | Collides? |
+|----------|----------------|-----------|
+| `docs` | `docs-generator` | No |
+| `docs` | `docs` | **Yes** |
+| `init` | `init-repo` | No |
+| `review` | `review` | **Yes** |
+| `review` | `pr-review` | No |
+
+## How the list gets updated
+
+Process lives in `standards/reserved-skill-names.md` ("Updating this
+list" section). Key constraint: if the list addition would collide
+with an existing bassclef skill, that skill MUST be renamed before
+the list addition merges. No silent shadow.
+
+## Relationship to other rules
+
+- `blocked-items.md` — the hook emits `BLOCKED: reserved skill name`;
+  this rule's semantics slot into the blocked-items protocol
+- `artifact-ingestion.md` — new-skill PRs read the standards list;
+  "Sources read" block cites it
+- `commit-conventions.md` — override commits include `SKIP_RESERVED_NAMES=1`;
+  rationale in body
+- `sdlc-gates.md` — collision check fires at pre-commit, before
+  bassclef-evolution check

package/dist/lite/.claude/rules/schema-management.md

@@ -0,0 +1,42 @@
+---
+tier: lite
+globs: ["prisma/**", "**/schema.prisma", "**/migration*", "alembic/**", "db/migrate/**", "migrations/**", "**/migrations/**"]
+description: Schema management — never apply schema changes without a migration; loads per-ORM sibling
+---
+
+# Schema Management
+
+Universal principle: **never apply schema changes without a migration file**. Schema drift between local and prod is a load-bearing failure mode for every ORM. When local is reset (rebuild, fresh clone, CI runner spin-up), unmigrated changes vanish silently and prod diverges from local. The failure surfaces hours or days later as a runtime crash with no obvious cause.
+
+The discipline holds across ORMs; the specifics differ. Bassclef's loader reads `tech_stack.orm:` from `.claude/bassclef-configs.jsonc` and loads the matching sibling under `standards/migration-discipline/` for ORM-specific guidance.
+
+## Universal commitments (every ORM)
+
+1. **Never use auto-apply / push tools** that bypass migration files (Prisma `db push`, GORM `AutoMigrate` in production, Django `--fake`, etc.). They feel fast but ship drift.
+2. **Always create a migration file** when changing the schema. The migration is the audit trail; missing migration = missing audit.
+3. **Commit the migration with the schema change.** Splitting them across commits is how reviewers miss the migration entirely.
+4. **Run migrate-deploy in CI**, not `dev` / autogen. Production migrations are explicit, reviewed, and reversible.
+5. **After merging a schema change**, regenerate the client / model bindings + restart the dev process. Cached clients don't know about new fields.
+6. **Migration files are immutable once shipped**. Editing a merged migration corrupts history for every other developer.
+
+## Per-ORM siblings
+
+| Adopter's `tech_stack.orm` | Sibling loaded |
+|---|---|
+| `prisma` | `standards/migration-discipline/prisma.md` |
+| `sqlalchemy` | `standards/migration-discipline/sqlalchemy.md` (Alembic via SQLAlchemy autogen) |
+| `alembic` | `standards/migration-discipline/alembic.md` (standalone Alembic, non-SQLAlchemy) |
+| `gorm` | `standards/migration-discipline/gorm.md` |
+| `active-record` | `standards/migration-discipline/active-record.md` (Rails migrations) |
+| `drizzle` | `standards/migration-discipline/drizzle.md` *(future — file `/promote` to author)* |
+| `none` or unset | Universal commitments only |
+
+When the matching sibling does not exist, the rule fires the universal commitments only and surfaces a `/promote` candidate for the missing sibling.
+
+## Session-start drift check
+
+Each ORM's sibling describes its drift-detection mechanism. The session-start hook reads the adopter's `tech_stack.orm:` and runs the matching check. If drift is detected, the agent creates the missing migration before writing any code.
+
+## Tech stack vocabulary
+
+The loader reads `tech_stack.orm` shipped in bassclef#1127 (WU-2 of bet 2026-06-18a). Adopters set the value at `/onboard-repo` Phase 2.x. When `tech_stack:` block is absent, the universal commitments still apply; ORM-specific guidance is skipped until the operator declares the stack.

package/dist/lite/.claude/rules/sdlc-gates.md

@@ -0,0 +1,149 @@
+---
+tier: lite
+description: Universal SDLC gates — pre-build temperance + diagnose, post-build /verify, observed-failure chain. Stack-specific globs live in per-language siblings under standards/sdlc-gates/.
+---
+
+# SDLC Gates
+
+Universal SDLC discipline applicable to any stack. The temperance + diagnose + verify chain is language-agnostic; the specific globs that scope the rule to source files live in per-language siblings under `standards/sdlc-gates/`. The loader (future ticket) reads adopter's `tech_stack.lang` from `.claude/bassclef-configs.jsonc` and applies the matching sibling's globs in addition to this rule.
+
+When no sibling exists for the adopter's language, the universal gates below still apply — the rule fires methodologically even without glob-based file scoping.
+
+## Per-stack siblings
+
+| Adopter's `tech_stack.lang` | Sibling loaded |
+|---|---|
+| `typescript` | `standards/sdlc-gates/typescript.md` |
+| `python` | `standards/sdlc-gates/python.md` *(future — file `/promote` to author)* |
+| `ruby` | `standards/sdlc-gates/ruby.md` *(future)* |
+| `go` | `standards/sdlc-gates/go.md` *(future)* |
+| `none` or unset | universal gates only; no glob-based scoping |
+
+When the matching sibling does not exist, the universal gates below apply; sibling-specific globs are skipped until the operator declares the stack and a sibling ships.
+
+## Pre-Build (before writing code) — HOOK ENFORCED (BLOCKING)
+
+The `pre-build-gate.sh` hook enforces these as hard blocks (exit 2)
+on PreToolUse Edit / Write / MultiEdit. Per bassclef#1060 the gate
+flipped from advisory (banner + exit 0) to blocking after an audit
+showed 0 of 15 PRs had temperance markers. Methodology-only failed.
+
+Override paths per gate: `SKIP_TEMPERANCE=1` and `SKIP_DIAGNOSE=1`
+(logged via trace-helper).
+
+1. **Temperance** — fires at **scope-decision boundaries**, not
+   per-branch. You must state your approach before the gate clears.
+   BLOCKS first edit on non-stacked branches until a marker exists
+   at `state/markers/temperance/<branch-slug>.marker`. Stacked
+   branches auto-suppress (the scope decision was made at
+   manifest-write time).
+
+   Scope-decision boundaries (where the gate IS load-bearing):
+   - Session kickoff (autonomous or `/longrun` start)
+   - Phase boundary (last WS in a phase transitions to merged →
+     next phase's premise re-engaged)
+   - Post-compaction recovery (context just compacted; have I drifted?)
+   - Scope-drift detection (a WS exceeds time budget × 1.5 → pause and
+     re-anchor)
+   - First edit per branch IF branch is NOT declared in any stack
+     manifest (non-stacked work fallback)
+
+   When the current branch IS declared in a `docs/stacks/*.md` or
+   `docs/branch-stacks/*.md` manifest, per-branch temperance is
+   **suppressed** — the scope decision was made at manifest-write
+   time. Phase-level firings cover the actual decision points.
+   Per bassclef#272.
+
+   Auto-fire mechanisms (session-kickoff, phase-boundary,
+   post-compaction, scope-drift detection) ship with the `/longrun`
+   skill (bassclef#274). Until then, the operator + agent fire
+   temperance manually at those boundaries.
+2. **Diagnosis** — fires on ALL fix/ branches. You must run /diagnose
+   (Is/Is Not + Five Whys + Hypothesis) before writing any fix code.
+   The hook blocks until diagnosis evidence exists.
+3. SDLC checkpoint — spec current? diagrams need updating?
+4. Requirements → tickets — log before coding
+
+## Observed failure → temperance → diagnose (MANDATORY)
+
+Any time you observe a failure — regardless of source — fire this chain:
+
+1. Temperance (pause before reacting):
+   - Is this expected? Is this worth investigating?
+   - Am I about to brute-force a retry instead of understanding?
+
+2. Diagnose (if the failure is real):
+   - Is / Is Not
+   - Five Whys to root cause
+   - Hypothesis + test plan
+   - THEN fix
+
+This applies to ALL failure sources:
+- Tool output (CI logs, tsc errors, test failures, deploy logs)
+- Failures you caused (pushed code → CI broke → fix before moving on)
+- User-reported failures (text, screenshots, logs)
+- Server logs you read
+
+Do NOT rely on hooks alone. You are responsible for recognizing failures
+in all forms and firing the temperance → diagnose chain yourself.
+
+## Post-Build (before committing — EACH task, not batched)
+
+Run /verify for the change type. Do not batch-build then batch-verify.
+
+Before committing, ask yourself:
+- Did I add or modify an exported function? → It needs a test.
+- Did I change query logic or selection behavior? → Test it.
+- Can I extract the logic into a pure function? → Do it, then test it.
+
+"I'll add tests later" is never acceptable.
+
+INSTEAD: tests ship with the code in the same commit. If the test is
+hard to write, that's a signal the implementation needs decomposing —
+fix the design first, then the test follows naturally.
+
+## Bassclef Evolution Check (non-bassclef repos only)
+
+Before committing **any methodology or configuration change** in an app repo,
+ask: "Is this local or global?"
+
+### What triggers the check
+
+Not just `.claude/` — any change that establishes a pattern other repos
+might need:
+
+| Change | Examples | Why it matters |
+|--------|----------|---------------|
+| `.claude/` files | skills, rules, hooks, agents | Direct substrate changes |
+| `settings.json` | model routing, permission defaults, hook config | Global agent behavior |
+| `package.json` scripts | new dev commands, lint configs, build patterns | Workflow conventions |
+| Hook scripts | pre-commit, pre-push, CI scripts | Process enforcement |
+| Config files | `.eslintrc`, `tsconfig`, `prettier`, `.env.example` | Standards compliance |
+| New workflow patterns | testing approaches, deployment scripts, seed patterns | Methodology evolution |
+
+### The check
+
+1. Is this general (applies to any project) or app-specific?
+2. If general → run `/promote` to create a `bassclef-evolution` issue
+3. Log the promotion and continue with current work.
+
+   INSTEAD of waiting for promotion to merge: file the issue and
+   keep moving. Promotion lands on its own cadence; current work
+   doesn't block on it.
+
+4. If unsure → promote. It's cheaper to reject a promotion than to
+   rediscover the pattern later in another repo.
+
+### Common miss: settings.json
+
+Settings changes are the most commonly missed. When an app repo modifies
+agent behavior, model routing, permission patterns, or hook configuration
+in `settings.json`, that's almost always a global decision wearing local
+clothes. The pre-commit hook flags these.
+
+INSTEAD of dismissing the warning: read the flagged change, decide
+local-vs-global, run /promote if global. Warnings are signal, not noise.
+
+## Architect Review
+
+Run /architect-review every 10 commits or before any launch.

package/dist/lite/.claude/rules/security.md

@@ -0,0 +1,37 @@
+---
+tier: lite
+globs: ["**/*.ts", "**/*.tsx", "**/*.json", ".env*", "Dockerfile*", "docker-compose*"]
+description: Security scanning — loads when touching source, config, or infra files
+---
+
+Three-layer security pipeline. All block merge on failure.
+
+Pipeline order: push → secret scan → lint → typecheck → SAST → dependency audit → test → build → deploy
+
+Layer 1 — Secret Detection (gitleaks):
+  Pre-commit hook + CI. Catches API keys, OAuth tokens, AWS creds, private keys.
+  Never commit .env files, credentials, or API keys.
+
+Layer 2 — Dependency Vulnerabilities (npm audit):
+  CI blocks on high-severity CVEs. Uses audit-ci for strict enforcement.
+
+Layer 3 — SAST (ESLint security plugins + TypeScript compiler):
+  eslint-plugin-security, @typescript-eslint, eslint-plugin-no-secrets.
+  Optional: Semgrep for deeper analysis as complexity grows.
+
+Rules:
+- No secrets in code or logs — use environment variables
+- Validate all user input at system boundaries
+- Use parameterized queries (Prisma handles this)
+- OWASP top 10 awareness: XSS, injection, broken auth, SSRF
+
+Auth matrix (define per project):
+- List every route and its required auth level
+- Protected routes must check session/token
+- Public routes must be explicitly marked as intentionally public
+- API routes that modify data require auth — no exceptions
+
+Tenant isolation (if multi-tenant):
+- Every query on tenant-scoped models must include tenant context
+- No hardcoded tenant IDs, financial thresholds, or tenant-specific logic
+- Tenant context resolved at middleware/boundary, passed through