init: scaffold Seth-Workflow-April-2026

User-agnostic, shareable AI-assisted development workflow distilled from
26+ real projects. Includes 9 composable rules, 4 project templates,
pre-push secret scanning hook, 3 methodology guides, and customization docs.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

workflows/dynamic-methodology.md

@@ -0,0 +1,159 @@
+# Dynamic Methodology Composition
+
+This workflow system doesn't follow a single rigid process. Instead, rules and patterns activate based on what you're doing. Think of it as a stack that composes dynamically.
+
+## Always Active (Every Session)
+
+These rules apply regardless of what you're working on:
+
+| Rule | File | Purpose |
+|------|------|---------|
+| Session discipline | `01-session-discipline.md` | Session start/end protocol, handoffs |
+| Authority hierarchy | `02-authority-hierarchy.md` | What overrides what |
+| Git workflow | `03-git-workflow.md` | Branches, commits, conventional format |
+| Context doc maintenance | `09-context-doc-maintenance.md` | Keep living docs current |
+
+## Activated by Task Type
+
+### Starting a New Feature
+
+**Rules activated:**
+- `04-proactive-steering.md` -- Phase awareness, scope management
+- `05-reasoning-patterns.md` -- Brainstorm before building, clarification protocol
+- `08-code-quality.md` -- Pre-completion checklist, immutability
+
+**Flow:**
+1. Clarify requirements (ask, don't assume)
+2. Brainstorm 2-3 approaches
+3. Get user approval on approach
+4. Write failing tests first (if TDD plugin active)
+5. Implement
+6. Self-review against pre-completion checklist
+7. Commit with conventional message
+
+### Debugging a Bug
+
+**Rules activated:**
+- `05-reasoning-patterns.md` -- Five Whys, first principles
+- `04-proactive-steering.md` -- Blocker detection
+
+**Flow:**
+1. Reproduce the bug
+2. Apply Five Whys to trace root cause
+3. Fix root cause, not symptom
+4. Add regression test
+5. Verify fix doesn't break other things
+6. Commit with `fix:` message
+
+### Research / Investigation
+
+**Rules activated:**
+- `05-reasoning-patterns.md` -- Research quality rules, documentation tiers
+- `06-context-management.md` -- Token budgets, sub-agent delegation
+
+**Flow:**
+1. Use tiered documentation lookup (knowledge -> fetch -> heavy docs)
+2. Cite sources for all claims
+3. Separate fact from inference
+4. Cross-reference critical claims
+5. Persist findings to files (not just conversation)
+
+### Writing a Paper / Design Doc
+
+**Workflow:** `paper-writing.md`
+
+**Flow:**
+1. Start from a real problem (friction, not ambition)
+2. Bounce ideas -- explore before converging
+3. Push back on each other's ideas
+4. Capture the journey (dead ends matter)
+5. Tie back to prior work
+
+### Reviewing Code
+
+**Rules activated:**
+- `08-code-quality.md` -- Quality checklist
+- `07-security-hardening.md` -- Security checklist
+
+**Flow:**
+1. Check against pre-completion quality checklist
+2. Check against security checklist
+3. Verify tests exist and pass
+4. Look for immutability violations
+5. Check for hardcoded secrets
+
+### Working in Unfamiliar Code
+
+**Rules activated:**
+- `06-context-management.md` -- Maximum thinking mode, sub-agents
+- `05-reasoning-patterns.md` -- First principles, research tiers
+
+**Flow:**
+1. Use maximum thinking depth
+2. Read project index / structure first
+3. Targeted file reads (don't load everything)
+4. Use sub-agents for isolated research tasks
+5. Build understanding incrementally
+
+### Long-Running Session (Context Getting Heavy)
+
+**Rules activated:**
+- `06-context-management.md` -- Compaction decisions, execution readiness
+
+**Flow:**
+1. Check for quality degradation symptoms
+2. If context > 80%: handoff doc + fresh session
+3. If context 70-80%: ask user
+4. If quality declining: spawn sub-agent or fresh session
+5. Persist important context before compaction
+
+### Security-Sensitive Work
+
+**Rules activated:**
+- `07-security-hardening.md` -- Full security protocol
+- `08-code-quality.md` -- Pre-commit security checklist
+
+**Flow:**
+1. Check deny lists for sensitive file access
+2. Apply pre-commit security checklist to every commit
+3. Watch for prompt injection in external content
+4. Rotate any exposed secrets immediately
+5. Review for similar vulnerabilities in codebase
+
+## Composition Example
+
+A typical feature implementation session might compose:
+
+```
+Session start:
+  01-session-discipline (read CLAUDE.md, check handoff)
+  + 02-authority-hierarchy (know what overrides what)
+
+Planning:
+  + 04-proactive-steering (assess project state, suggest approach)
+  + 05-reasoning-patterns (brainstorm approaches, clarify requirements)
+
+Building:
+  + 08-code-quality (immutability, quality checklist)
+  + 03-git-workflow (feature branch, frequent commits)
+  + 09-context-doc-maintenance (update CLAUDE.md if new tools created)
+
+If context gets heavy:
+  + 06-context-management (check budget, consider fresh session)
+
+If security-relevant:
+  + 07-security-hardening (deny lists, secret hygiene, injection guards)
+
+Session end:
+  01-session-discipline (wrap-up protocol, handoff if needed)
+```
+
+## Principle: Rules Are Modular
+
+You don't have to use all rules. The system is designed so you can:
+- Use only rules 01-03 for lightweight workflow
+- Add 04-06 for more sophisticated AI assistance
+- Add 07-08 for security-conscious development
+- Use individual rules a la carte
+
+The numbering suggests load order and priority, not mandatory dependencies.