@gannonh/kata 0.1.4 → 0.2.0

package/kata/templates/config.json

@@ -1,6 +1,15 @@
 {
   "mode": "interactive",
   "depth": "standard",
+  "workflow": {
+    "research": true,
+    "plan_check": true,
+    "verifier": true
+  },
+  "planning": {
+    "commit_docs": true,
+    "search_gitignored": false
+  },
   "parallelization": {
     "enabled": true,
     "plan_level": true,

package/kata/templates/entity.md

@@ -0,0 +1,173 @@
+# Entity Template
+
+Template for `.planning/codebase/{entity-slug}.md` - file-level intelligence documentation.
+
+---
+
+## File Template
+
+```markdown
+---
+path: {path}
+type: {type}
+updated: {updated}
+status: {status}
+---
+
+# {filename}
+
+## Purpose
+
+{purpose}
+
+## Exports
+
+{exports}
+
+## Dependencies
+
+{dependencies}
+
+## Used By
+
+{used_by}
+
+## Notes
+
+{notes}
+```
+
+---
+
+## Field Reference
+
+### Frontmatter
+
+| Field | Values | Description |
+|-------|--------|-------------|
+| `path` | Absolute path | Full path to the file |
+| `type` | module, component, util, config, test, api, hook | Primary classification |
+| `updated` | YYYY-MM-DD | Last time this entity was updated |
+| `status` | active, deprecated, stub | Current state |
+
+### Sections
+
+**Purpose** (required)
+1-3 sentences covering:
+- What this file does
+- Why it exists
+- Who/what uses it (high-level)
+
+**Exports** (required for modules with exports)
+List each export with signature and description:
+```markdown
+- `functionName(arg: Type): ReturnType` - What it does
+- `ClassName` - What it represents
+- `CONSTANT_NAME` - What value it holds
+```
+
+For files without exports (config, tests), write "None" or describe what the file defines.
+
+**Dependencies** (required)
+Internal dependencies use wiki-links (slugified paths):
+```markdown
+- [[src-lib-db]] - Database client
+- [[src-types-user]] - User type definitions
+```
+
+External dependencies use plain text:
+```markdown
+- react - Component framework
+- jose - JWT handling
+```
+
+**Used By** (grows over time)
+Files that import this one, using wiki-links:
+```markdown
+- [[src-app-api-auth-route]]
+- [[src-components-dashboard]]
+```
+
+Initially may be empty or incomplete. Updated as Claude encounters imports.
+
+**Notes** (optional)
+Patterns, gotchas, or context:
+```markdown
+- Uses singleton pattern for connection pooling
+- WARNING: Must call `init()` before any other method
+- Related: See [[src-lib-cache]] for caching layer
+```
+
+---
+
+## Slug Convention
+
+Entity slugs are derived from file paths:
+- `src/lib/db.ts` becomes `src-lib-db`
+- `src/app/api/auth/route.ts` becomes `src-app-api-auth-route`
+
+Rule: Replace `/` and `.` with `-`, drop file extension.
+
+---
+
+## Example
+
+```markdown
+---
+path: /project/src/lib/auth.ts
+type: util
+updated: 2025-01-15
+status: active
+---
+
+# auth.ts
+
+## Purpose
+
+JWT token management using jose library. Handles token creation, verification, and refresh rotation. Used by all protected API routes via middleware.
+
+## Exports
+
+- `createAccessToken(userId: string): Promise<string>` - Creates 15-min access token
+- `createRefreshToken(userId: string): Promise<string>` - Creates 7-day refresh token
+- `verifyToken(token: string): Promise<TokenPayload>` - Validates and decodes token
+- `rotateRefresh(oldToken: string): Promise<TokenPair>` - Issues new token pair
+
+## Dependencies
+
+- [[src-lib-db]] - Stores refresh tokens for revocation
+- [[src-types-auth]] - TokenPayload, TokenPair types
+- jose - JWT signing and verification
+- bcrypt - Password hashing
+
+## Used By
+
+- [[src-middleware]]
+- [[src-app-api-auth-login-route]]
+- [[src-app-api-auth-logout-route]]
+- [[src-app-api-auth-refresh-route]]
+
+## Notes
+
+- Access tokens are stateless; refresh tokens stored in DB for revocation
+- Uses RS256 algorithm with keys from environment
+- WARNING: Never log token values, even in debug mode
+```
+
+---
+
+## Guidelines
+
+**When to create/update:**
+- After modifying a file during plan execution
+- When encountering a file that lacks documentation
+- When relationships change (new imports, exports)
+
+**Minimal viable entity:**
+At minimum, an entity needs frontmatter + Purpose. Other sections can be "TBD" if unknown.
+
+**Accuracy over completeness:**
+Better to have partial accurate info than complete guesses. Mark unknowns explicitly.
+
+**Link discovery:**
+The hook that processes entities extracts all `[[wiki-links]]` to build the relationship graph. Ensure links use correct slug format.

package/kata/templates/phase-prompt.md

@@ -75,33 +75,23 @@ Output: [What artifacts will be created]
   <done>[Acceptance criteria]</done>
 </task>
 
+<!-- For checkpoint task examples and patterns, see @~/.claude/kata/references/checkpoints.md -->
+<!-- Key rule: Claude starts dev server BEFORE human-verify checkpoints. User only visits URLs. -->
+
 <task type="checkpoint:decision" gate="blocking">
   <decision>[What needs deciding]</decision>
   <context>[Why this decision matters]</context>
   <options>
-    <option id="option-a">
-      <name>[Option name]</name>
-      <pros>[Benefits and advantages]</pros>
-      <cons>[Tradeoffs and limitations]</cons>
-    </option>
-    <option id="option-b">
-      <name>[Option name]</name>
-      <pros>[Benefits and advantages]</pros>
-      <cons>[Tradeoffs and limitations]</cons>
-    </option>
+    <option id="option-a"><name>[Name]</name><pros>[Benefits]</pros><cons>[Tradeoffs]</cons></option>
+    <option id="option-b"><name>[Name]</name><pros>[Benefits]</pros><cons>[Tradeoffs]</cons></option>
   </options>
-  <resume-signal>[How to indicate choice - "Select: option-a or option-b"]</resume-signal>
+  <resume-signal>Select: option-a or option-b</resume-signal>
 </task>
 
 <task type="checkpoint:human-verify" gate="blocking">
-  <what-built>[What Claude just built that needs verification]</what-built>
-  <how-to-verify>
-    1. Run: [command to start dev server/app]
-    2. Visit: [URL to check]
-    3. Test: [Specific interactions]
-    4. Confirm: [Expected behaviors]
-  </how-to-verify>
-  <resume-signal>Type "approved" to continue, or describe issues to fix</resume-signal>
+  <what-built>[What Claude built] - server running at [URL]</what-built>
+  <how-to-verify>Visit [URL] and verify: [visual checks only, NO CLI commands]</how-to-verify>
+  <resume-signal>Type "approved" or describe issues</resume-signal>
 </task>
 
 </tasks>
@@ -403,15 +393,16 @@ Output: Working dashboard component.
   <done>Dashboard renders without errors</done>
 </task>
 
+<!-- Checkpoint pattern: Claude starts server, user visits URL. See checkpoints.md for full patterns. -->
+<task type="auto">
+  <name>Start dev server</name>
+  <action>Run `npm run dev` in background, wait for ready</action>
+  <verify>curl localhost:3000 returns 200</verify>
+</task>
+
 <task type="checkpoint:human-verify" gate="blocking">
-  <what-built>Responsive dashboard with user and product sections</what-built>
-  <how-to-verify>
-    1. Run: npm run dev
-    2. Visit: http://localhost:3000/dashboard
-    3. Desktop: Verify two-column grid
-    4. Mobile: Verify stacked layout
-    5. Check: No layout shift, no scroll issues
-  </how-to-verify>
+  <what-built>Dashboard - server at http://localhost:3000</what-built>
+  <how-to-verify>Visit localhost:3000/dashboard. Check: desktop grid, mobile stack, no scroll issues.</how-to-verify>
   <resume-signal>Type "approved" or describe issues</resume-signal>
 </task>
 </tasks>

package/kata/workflows/complete-milestone.md

@@ -620,6 +620,17 @@ git push origin v[X.Y]
 
 Commit milestone completion including archive files and deletions.
 
+**Check planning config:**
+
+```bash
+COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+```
+
+**If `COMMIT_PLANNING_DOCS=false`:** Skip git operations
+
+**If `COMMIT_PLANNING_DOCS=true` (default):**
+
 ```bash
 # Stage archive files (new)
 git add .planning/milestones/v[X.Y]-ROADMAP.md

package/kata/workflows/diagnose-issues.md

@@ -156,6 +156,17 @@ For each gap in the Gaps section, add artifacts and missing fields:
 
 Update status in frontmatter to "diagnosed".
 
+**Check planning config:**
+
+```bash
+COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+```
+
+**If `COMMIT_PLANNING_DOCS=false`:** Skip git operations
+
+**If `COMMIT_PLANNING_DOCS=true` (default):**
+
 Commit the updated UAT.md:
 ```bash
 git add ".planning/phases/XX-name/{phase}-UAT.md"
@@ -169,7 +180,7 @@ git commit -m "docs({phase}): add root causes from diagnosis"
 Display:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- KATA ► DIAGNOSIS COMPLETE
+ Kata ► DIAGNOSIS COMPLETE
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 | Gap (Truth) | Root Cause | Files |

package/kata/workflows/discovery-phase.md

@@ -107,16 +107,14 @@ For: Choosing between options, new external integration.
 
 5. **Cross-verify:** Any WebSearch finding → confirm with Context7/official docs.
 
-6. **Quality check:** Before finalizing findings, consult the gsd-researcher agent's verification protocols to avoid common research gaps.
-
-7. **Create DISCOVERY.md** using ~/.claude/kata/templates/discovery.md structure:
+6. **Create DISCOVERY.md** using ~/.claude/kata/templates/discovery.md structure:
 
    - Summary with recommendation
    - Key findings per option
    - Code examples from Context7
    - Confidence level (should be MEDIUM-HIGH for Level 2)
 
-8. Return to plan-phase.md.
+7. Return to plan-phase.md.
 
 **Output:** `.planning/phases/XX-name/DISCOVERY.md`
 </step>
@@ -160,18 +158,16 @@ For: Architectural decisions, novel problems, high-risk choices.
    - Mark what's verified vs assumed
    - Flag contradictions
 
-6. **Quality check:** Before finalizing findings, consult the gsd-researcher agent's verification protocols to ensure comprehensive coverage and avoid common research gaps.
-
-7. **Create comprehensive DISCOVERY.md:**
+6. **Create comprehensive DISCOVERY.md:**
 
    - Full structure from ~/.claude/kata/templates/discovery.md
    - Quality report with source attribution
    - Confidence by finding
    - If LOW confidence on any critical finding → add validation checkpoints
 
-8. **Confidence gate:** If overall confidence is LOW, present options before proceeding.
+7. **Confidence gate:** If overall confidence is LOW, present options before proceeding.
 
-9. Return to plan-phase.md.
+8. Return to plan-phase.md.
 
 **Output:** `.planning/phases/XX-name/DISCOVERY.md` (comprehensive)
 </step>

package/kata/workflows/discuss-phase.md

@@ -393,6 +393,17 @@ Created: .planning/phases/${PADDED_PHASE}-${SLUG}/${PADDED_PHASE}-CONTEXT.md
 <step name="git_commit">
 Commit phase context:
 
+**Check planning config:**
+
+```bash
+COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+```
+
+**If `COMMIT_PLANNING_DOCS=false`:** Skip git operations
+
+**If `COMMIT_PLANNING_DOCS=true` (default):**
+
 ```bash
 git add "${PHASE_DIR}/${PADDED_PHASE}-CONTEXT.md"
 git commit -m "$(cat <<'EOF'

package/kata/workflows/execute-phase.md

@@ -8,11 +8,32 @@ The orchestrator's job is coordination, not execution. Each subagent loads the f
 
 <required_reading>
 Read STATE.md before any operation to load project context.
+Read config.json for planning behavior settings.
 </required_reading>
 
 <process>
 
-<step name="load_project_state" priority="first">
+<step name="resolve_model_profile" priority="first">
+Read model profile for agent spawning:
+
+```bash
+MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
+```
+
+Default to "balanced" if not set.
+
+**Model lookup table:**
+
+| Agent | quality | balanced | budget |
+|-------|---------|----------|--------|
+| kata-executor | opus | sonnet | sonnet |
+| kata-verifier | sonnet | sonnet | haiku |
+| general-purpose | — | — | — |
+
+Store resolved models for use in Task calls below.
+</step>
+
+<step name="load_project_state">
 Before any operation, read project state:
 
 ```bash
@@ -33,6 +54,17 @@ Options:
 ```
 
 **If .planning/ doesn't exist:** Error - project not initialized.
+
+**Load planning config:**
+
+```bash
+# Check if planning docs should be committed (default: true)
+COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+# Auto-detect gitignored (overrides config)
+git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+```
+
+Store `COMMIT_PLANNING_DOCS` for use in git operations.
 </step>
 
 <step name="validate_phase">
@@ -158,9 +190,18 @@ Execute each wave in sequence. Autonomous plans within a wave run in parallel.
    - Bad: "Executing terrain generation plan"
    - Good: "Procedural terrain generator using Perlin noise — creates height maps, biome zones, and collision meshes. Required before vehicle physics can interact with ground."
 
-2. **Spawn all autonomous agents in wave simultaneously:**
+2. **Read files and spawn all autonomous agents in wave simultaneously:**
+
+   Before spawning, read file contents. The `@` syntax does not work across Task() boundaries - content must be inlined.
+
+   ```bash
+   # Read each plan in the wave
+   PLAN_CONTENT=$(cat "{plan_path}")
+   STATE_CONTENT=$(cat .planning/STATE.md)
+   CONFIG_CONTENT=$(cat .planning/config.json 2>/dev/null)
+   ```
 
-   Use Task tool with multiple parallel calls. Each agent gets prompt from subagent-task-prompt template:
+   Use Task tool with multiple parallel calls. Each agent gets prompt with inlined content:
 
    ```
    <objective>
@@ -177,9 +218,14 @@ Execute each wave in sequence. Autonomous plans within a wave run in parallel.
    </execution_context>
 
    <context>
-   Plan: @{plan_path}
-   Project state: @.planning/STATE.md
-   Config: @.planning/config.json (if exists)
+   Plan:
+   {plan_content}
+
+   Project state:
+   {state_content}
+
+   Config (if exists):
+   {config_content}
    </context>
 
    <success_criteria>
@@ -248,7 +294,7 @@ Plans with `autonomous: false` require user interaction.
 
 1. **Spawn agent for checkpoint plan:**
    ```
-   Task(prompt="{subagent-task-prompt}", subagent_type="general-purpose")
+   Task(prompt="{subagent-task-prompt}", subagent_type="kata-executor", model="{executor_model}")
    ```
 
 2. **Agent runs until checkpoint:**
@@ -287,7 +333,8 @@ Plans with `autonomous: false` require user interaction.
    ```
    Task(
      prompt=filled_continuation_template,
-     subagent_type="general-purpose"
+     subagent_type="kata-executor",
+     model="{executor_model}"
    )
    ```
 
@@ -363,7 +410,8 @@ Phase goal: {goal from ROADMAP.md}
 
 Check must_haves against actual codebase. Create VERIFICATION.md.
 Verify what actually exists in the code.",
-  subagent_type="kata-verifier"
+  subagent_type="kata-verifier",
+  model="{verifier_model}"
 )
 ```
 
@@ -456,6 +504,17 @@ Update ROADMAP.md to reflect phase completion:
 # Update status
 ```
 
+**Check planning config:**
+
+If `COMMIT_PLANNING_DOCS=false` (set in load_project_state):
+- Skip all git operations for .planning/ files
+- Planning docs exist locally but are gitignored
+- Log: "Skipping planning docs commit (commit_docs: false)"
+- Proceed to offer_next step
+
+If `COMMIT_PLANNING_DOCS=true` (default):
+- Continue with git operations below
+
 Commit phase completion (roadmap, state, verification):
 ```bash
 git add .planning/ROADMAP.md .planning/STATE.md .planning/phases/{phase_dir}/*-VERIFICATION.md

package/kata/workflows/execute-plan.md

@@ -4,11 +4,32 @@ Execute a phase prompt (PLAN.md) and create the outcome summary (SUMMARY.md).
 
 <required_reading>
 Read STATE.md before any operation to load project context.
+Read config.json for planning behavior settings.
+
+@~/.claude/kata/references/git-integration.md
 </required_reading>
 
 <process>
 
-<step name="load_project_state" priority="first">
+<step name="resolve_model_profile" priority="first">
+Read model profile for agent spawning:
+
+```bash
+MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
+```
+
+Default to "balanced" if not set.
+
+**Model lookup table:**
+
+| Agent | quality | balanced | budget |
+|-------|---------|----------|--------|
+| kata-executor | opus | sonnet | sonnet |
+
+Store resolved model for use in Task calls below.
+</step>
+
+<step name="load_project_state">
 Before any operation, read project state:
 
 ```bash
@@ -34,6 +55,17 @@ Options:
 **If .planning/ doesn't exist:** Error - project not initialized.
 
 This ensures every execution has full project context.
+
+**Load planning config:**
+
+```bash
+# Check if planning docs should be committed (default: true)
+COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+# Auto-detect gitignored (overrides config)
+git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+```
+
+Store `COMMIT_PLANNING_DOCS` for use in git operations.
 </step>
 
 <step name="identify_plan">
@@ -205,7 +237,7 @@ No segmentation benefit - execute entirely in main
 ```
 1. Run init_agent_tracking step first (see step below)
 
-2. Use Task tool with subagent_type="kata-executor":
+2. Use Task tool with subagent_type="kata-executor" and model="{executor_model}":
 
    Prompt: "Execute plan at .planning/phases/{phase}-{plan}-PLAN.md
 
@@ -357,7 +389,7 @@ For Pattern A (fully autonomous) and Pattern C (decision-dependent), skip this s
 
    B. If routing = Subagent:
       ```
-      Spawn Task tool with subagent_type="kata-executor":
+      Spawn Task tool with subagent_type="kata-executor" and model="{executor_model}":
 
       Prompt: "Execute tasks [task numbers/names] from plan at [plan path].
 
@@ -1511,6 +1543,17 @@ Commit execution metadata (SUMMARY + STATE + ROADMAP):
 **Note:** All task code has already been committed during execution (one commit per task).
 PLAN.md was already committed during plan-phase. This final commit captures execution results only.
 
+**Check planning config:**
+
+If `COMMIT_PLANNING_DOCS=false` (set in load_project_state):
+- Skip all git operations for .planning/ files
+- Planning docs exist locally but are gitignored
+- Log: "Skipping planning docs commit (commit_docs: false)"
+- Proceed to next step
+
+If `COMMIT_PLANNING_DOCS=true` (default):
+- Continue with git operations below
+
 **1. Stage execution artifacts:**
 
 ```bash
@@ -1574,7 +1617,7 @@ lmn012o feat(08-02): create user registration endpoint
 
 Each task has its own commit, followed by one metadata commit documenting plan completion.
 
-For commit message conventions, see ~/.claude/kata/references/git-integration.md
+See `git-integration.md` (loaded via required_reading) for commit message conventions.
 </step>
 
 <step name="update_codebase_map">

package/kata/workflows/map-codebase.md

@@ -22,7 +22,25 @@ Documents are reference material for Claude when planning/executing. Always incl
 
 <process>
 
-<step name="check_existing" priority="first">
+<step name="resolve_model_profile" priority="first">
+Read model profile for agent spawning:
+
+```bash
+MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
+```
+
+Default to "balanced" if not set.
+
+**Model lookup table:**
+
+| Agent | quality | balanced | budget |
+|-------|---------|----------|--------|
+| kata-codebase-mapper | sonnet | haiku | haiku |
+
+Store resolved model for use in Task calls below.
+</step>
+
+<step name="check_existing">
 Check if .planning/codebase/ already exists:
 
 ```bash
@@ -73,7 +91,7 @@ Continue to spawn_agents.
 <step name="spawn_agents">
 Spawn 4 parallel kata-codebase-mapper agents.
 
-Use Task tool with `subagent_type="kata-codebase-mapper"` and `run_in_background=true` for parallel execution.
+Use Task tool with `subagent_type="kata-codebase-mapper"`, `model="{mapper_model}"`, and `run_in_background=true` for parallel execution.
 
 **CRITICAL:** Use the dedicated `kata-codebase-mapper` agent, NOT `Explore`. The mapper agent writes documents directly.
 
@@ -82,6 +100,7 @@ Use Task tool with `subagent_type="kata-codebase-mapper"` and `run_in_background
 Task tool parameters:
 ```
 subagent_type: "kata-codebase-mapper"
+model: "{mapper_model}"
 run_in_background: true
 description: "Map codebase tech stack"
 ```
@@ -104,6 +123,7 @@ Explore thoroughly. Write documents directly using templates. Return confirmatio
 Task tool parameters:
 ```
 subagent_type: "kata-codebase-mapper"
+model: "{mapper_model}"
 run_in_background: true
 description: "Map codebase architecture"
 ```
@@ -126,6 +146,7 @@ Explore thoroughly. Write documents directly using templates. Return confirmatio
 Task tool parameters:
 ```
 subagent_type: "kata-codebase-mapper"
+model: "{mapper_model}"
 run_in_background: true
 description: "Map codebase conventions"
 ```
@@ -148,6 +169,7 @@ Explore thoroughly. Write documents directly using templates. Return confirmatio
 Task tool parameters:
 ```
 subagent_type: "kata-codebase-mapper"
+model: "{mapper_model}"
 run_in_background: true
 description: "Map codebase concerns"
 ```
@@ -211,6 +233,17 @@ Continue to commit_codebase_map.
 <step name="commit_codebase_map">
 Commit the codebase map:
 
+**Check planning config:**
+
+```bash
+COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
+git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+```
+
+**If `COMMIT_PLANNING_DOCS=false`:** Skip git operations
+
+**If `COMMIT_PLANNING_DOCS=true` (default):**
+
 ```bash
 git add .planning/codebase/*.md
 git commit -m "$(cat <<'EOF'