tlc-claude-code 2.6.1 → 2.8.0

package/.claude/commands/tlc/audit.md

@@ -22,7 +22,24 @@ Run a comprehensive audit of the codebase against TLC coding standards.
 /tlc:audit
 ```
 
-## Process
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Use the broadest CodeDB query that covers the audit pass before reading files manually.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_tree` | Analyze folder structure, including file counts per folder and nesting depth. |
+| `codedb_search` | Scan for violation patterns such as hardcoded URLs `https?://`, magic strings, and `process.env` usage outside config. |
+| `codedb_symbol` | Check JSDoc coverage on exported functions before doing line-by-line review. |
+| `codedb_bundle` | Batch the audit checks into one call to reduce repeated repository scans. |
+
+Use CodeDB results to narrow any follow-up reads to the specific files or folders with likely violations.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+## Process
 
 ### Step 1: Load Audit Module
 

package/.claude/commands/tlc/autofix.md

@@ -145,7 +145,23 @@ The existing autofix instructions below are the Inline Mode instructions and sho
 /tlc:autofix
 ```
 
-## Process
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Use CodeDB to narrow the failing area before opening files or proposing a fix.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_symbol` | Find test function definitions quickly for the failing cases. |
+| `codedb_deps` | Trace imports and dependents of the broken module before editing. |
+| `codedb_hot` | Focus repair work on recently modified files that likely caused the failure. |
+
+Use these results to choose the smallest verified fix path before rerunning tests.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+## Process
 
 ### Step 1: Run Tests
 

package/.claude/commands/tlc/build.md

@@ -117,7 +117,7 @@ Claude is the **project manager**. Claude reads the plan, breaks tasks into smal
 
 ### Step O1: Read the Plan
 
-Read `.planning/phases/{N}-PLAN.md`. Extract each task's goal, files, acceptance criteria, and test cases.
+Read `.planning/phases/{PHASE_ID}-PLAN.md`, falling back to legacy `.planning/phases/{N}-PLAN.md` when no prefixed file exists. Extract each task's goal, files, acceptance criteria, and test cases.
 
 ### Step O2: Check Orchestrator Health
 
@@ -395,6 +395,36 @@ This is the core TLC command. Tests before code, one task at a time.
 /tlc:build <phase_number> --agents 5        # Limit parallel agents to 5
 ```
 
+## Phase Resolution
+
+Before loading plans, normalize the phase argument:
+
+1. If the argument is prefixed, such as `CORE-3`, discover the workspace manifest with `server/lib/workspace-manifest.js`, resolve the prefix to a repo, and run the build in that repo directory (for example `../tlc-core`).
+2. If the argument is unprefixed, such as `108`, resolve it to the current repo prefix when the workspace manifest exists, producing `TLC-108` in this repo.
+3. If the prefix is unknown, stop with:
+   `Unknown prefix FOO. Known: TLC, CORE, SA`
+4. If no workspace manifest exists:
+   - Prefixed cross-repo IDs return an error
+   - Unprefixed IDs still work in the current repo for backward compatibility
+
+Use `{PHASE_ID}` for artifact lookup and keep `{phase_number}` as the numeric/local branch component when needed.
+
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Use CodeDB to inspect nearby code and conventions before creating files or implementing the next step.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_outline` | Inspect files adjacent to the task area for existing patterns, exports, and interfaces. |
+| `codedb_search` | Find similar implementations to follow as the reference path for new work. |
+| `codedb_tree` | Verify the target directory structure before creating or moving files. |
+
+Use these queries to keep new work aligned with surrounding modules and repository layout.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
 ## Process
 
 ### Step 0: Create Phase Branch (Mandatory)
@@ -427,7 +457,12 @@ fi
 
 ### Step 1: Load Plans
 
-Read all `.planning/phases/{phase}-*-PLAN.md` files for this phase.
+Read the phase plan using prefixed matching first:
+
+- Preferred: `.planning/phases/{PREFIX}-{N}-PLAN.md`
+- Backward-compatible fallback: `.planning/phases/{N}-PLAN.md`
+
+Do not use the old ambiguous glob `.planning/phases/{phase}-*-PLAN.md` for primary lookup.
 
 ### Step 1a: Auto-Parallel Detection
 

package/.claude/commands/tlc/coverage.md

@@ -138,6 +138,22 @@ The existing coverage instructions below are the Inline Mode instructions and sh
 - When joining a project to understand test gaps
 - After "vibe coding" a feature without tests
 
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Prefer a single batched pass to map source files, test files, and exported surfaces before deeper inspection.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_tree` | Identify all source files and test files across the repository. |
+| `codedb_outline` | Find exported functions and signatures per file to compare against existing tests. |
+| `codedb_bundle` | Batch the tree and outline queries into one call for faster coverage mapping. |
+
+Use the returned file and symbol lists to focus manual review on untested or high-risk modules.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
 ## Process
 
 ### 1. Detect Test Framework

package/.claude/commands/tlc/discuss.md

@@ -149,6 +149,21 @@ This command is not a blank-page brainstorming prompt. The agent should do the i
 
 If no phase number, auto-detect current phase from `.planning/ROADMAP.md`.
 
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Use structure and module outlines to ground the discussion in the code that the current phase actually touches.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_outline` | Inspect modules relevant to the phase being discussed, including exports and interfaces. |
+| `codedb_tree` | Understand folder organization in the affected area before making recommendations. |
+
+Use CodeDB output to support tradeoff analysis and keep the discussion tied to concrete files.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
 ## Process
 
 ### Step 1: Scan Context First

package/.claude/commands/tlc/init.md

@@ -166,6 +166,25 @@ After observability scaffolding, inspect the project's CI/CD posture:
    - Report: `"CI/CD OK"`
    - Include detected platform and workflow file paths in the summary
 
+### 6b. Register CodeDB MCP Server
+
+If `codedb` is installed (`command -v codedb`), create `.mcp.json` in the project root (if it doesn't already exist):
+
+```json
+{
+  "mcpServers": {
+    "codedb": {
+      "command": "codedb",
+      "args": ["mcp", "."]
+    }
+  }
+}
+```
+
+This gives Claude Code sub-millisecond code search, symbol lookup, and project tree — 1600x fewer tokens than grep/read.
+
+If `codedb` is not installed, skip silently (it's optional infrastructure from tlc-core).
+
 ### 7. If Tests Already Exist
 
 - Skip framework setup

package/.claude/commands/tlc/plan.md

@@ -173,13 +173,42 @@ The existing planning instructions below are the Inline Mode instructions and sh
 
 If no phase number, auto-detect current phase from ROADMAP.md.
 
+## Phase Resolution
+
+Before reading or writing phase artifacts, normalize the requested phase argument:
+
+1. If the user passes a prefixed ID such as `CORE-3`, discover the workspace manifest via `server/lib/workspace-manifest.js` and resolve the target repo from the prefix.
+2. If the user passes an unprefixed ID such as `108`, resolve it to the current repo prefix when the workspace manifest is available, producing `TLC-108` in this repo.
+3. If the user passes an unknown prefix, stop with:
+   `Unknown prefix FOO. Known: TLC, CORE, SA`
+4. If no workspace manifest exists:
+   - Prefixed cross-repo IDs return an error because repo resolution is unavailable
+   - Unprefixed IDs still work in the current repo for backward compatibility
+
+When a prefixed ID resolves to another repo, operate in that repo's directory (for example `CORE-3` resolves via the manifest and runs against `../tlc-core`).
+
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Start with structure and interface discovery before breaking work into tasks or estimating scope.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_tree` | Understand the project structure before creating the task breakdown. |
+| `codedb_outline` | Inspect key modules for existing patterns, exports, and interfaces to follow. |
+
+Use the CodeDB snapshot to anchor the plan in the actual repository layout instead of assumptions.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
 ## Process
 
 ### Step 1: Load Context
 
 Read:
 - `.planning/ROADMAP.md` - phase goal
-- `.planning/phases/{N}-DISCUSSION.md` - implementation preferences
+- `.planning/phases/{PHASE_ID}-DISCUSSION.md` - implementation preferences
 - `PROJECT.md` - tech stack, constraints
 
 ### Step 2: Research (if needed)
@@ -189,7 +218,7 @@ For phases requiring external knowledge:
 - Check best practices
 - Identify patterns
 
-Create `.planning/phases/{N}-RESEARCH.md` with findings.
+Create `.planning/phases/{PHASE_ID}-RESEARCH.md` with findings.
 
 ### Step 3: Break Into Tasks
 
@@ -255,10 +284,10 @@ Use `/tlc:claim` to claim a task, `/tlc:release` to release one.
 
 ### Step 4: Create Plan File
 
-Create `.planning/phases/{N}-PLAN.md`:
+Create `.planning/phases/{PHASE_ID}-PLAN.md` using the repo prefix when available, for example `TLC-{N}-PLAN.md`. If no workspace manifest or prefixed artifacts exist, fall back to legacy `{N}-PLAN.md`.
 
 ```markdown
-# Phase {N}: {Name} - Plan
+# Phase {PHASE_ID}: {Name} - Plan
 
 ## Overview
 
@@ -365,7 +394,7 @@ If the result is `true`:
      fs
    });
    console.log(JSON.stringify(r));
-   " ".planning/phases/{N}-PLAN.md" 2>/dev/null
+   " ".planning/phases/{PHASE_ID}-PLAN.md" 2>/dev/null
    ```
 2. Report results: "GitHub: Created N issues, updated M, linked to project board"
 3. If sync fails, warn but do not block: "GitHub sync failed: [reason]. Plan saved locally. Run `/tlc:issues sync` to retry."
@@ -398,7 +427,7 @@ Allow refinement if needed.
 ### Step 6: Save and Continue
 
 ```
-Plan saved to .planning/phases/{N}-PLAN.md
+Plan saved to .planning/phases/{PHASE_ID}-PLAN.md
 
 Ready to build?
 1) Yes, run /tlc:build (writes tests first)

package/.claude/commands/tlc/preflight.md

@@ -15,6 +15,22 @@ It also runs:
 - After any multi-file change
 - Before recommending a commit or push
 
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Use dependency and recency data first so the completeness check covers the full blast radius of recent edits.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_deps` | Find all files that import or otherwise reference the changed modules. |
+| `codedb_hot` | Identify recently changed files that should be treated as the primary focus area. |
+| `codedb_search` | Verify registration patterns such as command arrays, route tables, and exports. |
+
+Use the results to confirm registry updates, parallel-system changes, and downstream references before declaring done.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
 ## Process
 
 ### Step 1: Inventory What Was Changed

package/.claude/commands/tlc/progress.md

@@ -31,26 +31,40 @@ No project found.
 Run /tlc:new-project to start, or /tlc:init to add TLC to existing code.
 ```
 
-### Step 2: Parse Roadmap
+### Step 2: Detect Workspace Scope
 
-Read `.planning/ROADMAP.md` and identify:
+Try to discover a workspace manifest via `server/lib/workspace-manifest.js`.
+
+- If a manifest exists, switch to workspace-wide progress mode
+- Use the manifest `workspace` name in the header
+- Iterate all repos declared in the manifest, listing the current repo first
+- Repos whose paths do not exist on disk must be shown as `[not cloned]`
+- If no manifest exists, fall back to single-repo mode
+
+### Step 3: Parse Roadmap
+
+In single-repo mode, read `.planning/ROADMAP.md` and identify:
 - Total phases
 - Completed phases (marked `[x]` or `[completed]`)
 - Current phase (marked `[>]` or `[current]`)
 - Pending phases
 
-### Step 3: Check Current Phase State
+In workspace-wide mode, do the same per repo and produce a compact repo summary such as:
+
+`TLC: Phase TLC-108 (3/10) | CORE: Phase CORE-1b (idle) | SA: Phase SA-105f (complete)`
+
+### Step 4: Check Current Phase State
 
 For the current/next phase, check what exists:
 
 | File | Meaning |
 |------|---------|
-| `{N}-DISCUSSION.md` | Discussed |
-| `{N}-PLAN.md` | Planned |
-| `{N}-TESTS.md` | Tests written |
-| `{N}-VERIFIED.md` | Human verified |
+| `{PREFIX}-{N}-DISCUSSION.md` or `{N}-DISCUSSION.md` | Discussed |
+| `{PREFIX}-{N}-PLAN.md` or `{N}-PLAN.md` | Planned |
+| `{PREFIX}-{N}-TESTS.md` or `{N}-TESTS.md` | Tests written |
+| `{PREFIX}-{N}-VERIFIED.md` or `{N}-VERIFIED.md` | Human verified |
 
-### Step 4: Run Tests
+### Step 5: Run Tests
 
 Execute test suite and capture:
 - Total tests
@@ -58,7 +72,7 @@ Execute test suite and capture:
 - Failing
 - Skipped
 
-### Step 5: Present Status
+### Step 6: Present Status
 
 ```
 Project: My App
@@ -82,6 +96,18 @@ Tests: 47 total | 45 passing | 2 failing
 Suggested: /tlc:build 4
 ```
 
+When workspace-wide mode is active, prefer a compact workspace summary:
+
+```
+Workspace: tlc-platform
+
+TLC: Phase TLC-108 (3/10) | CORE: Phase CORE-1b (idle) | SA: Phase SA-105f (complete)
+
+[TLC] Tests: 142 total | [CORE] Tests: 38 total | [SA] Tests: 67 total
+
+Next: /tlc in the active repo, or /tlc:build TLC-108
+```
+
 ### Step 5b: Team Status (Multi-User)
 
 If task markers (`[>@user]`, `[x@user]`) exist in PLAN.md, show team activity:
@@ -99,17 +125,17 @@ Parse `[>@user]` and `[x@user]` markers from current phase PLAN.md to build this
 
 If no markers exist, skip this section (single-user mode).
 
-### Step 6: Suggest Next Action
+### Step 7: Suggest Next Action
 
 Based on state:
 
 | State | Suggestion |
 |-------|------------|
-| No discussion | `/tlc:discuss {N}` |
-| Discussed, no plan | `/tlc:plan {N}` |
-| Planned, no tests | `/tlc:build {N}` |
-| Tests failing | Fix failures, then `/tlc:build {N}` |
-| Tests passing, not verified | `/tlc:verify {N}` |
+| No discussion | `/tlc:discuss {PHASE_ID}` |
+| Discussed, no plan | `/tlc:plan {PHASE_ID}` |
+| Planned, no tests | `/tlc:build {PHASE_ID}` |
+| Tests failing | Fix failures, then `/tlc:build {PHASE_ID}` |
+| Tests passing, not verified | `/tlc:verify {PHASE_ID}` |
 | Verified | Move to next phase |
 | All phases done | `/tlc:complete` |
 

package/.claude/commands/tlc/refactor.md

@@ -17,7 +17,23 @@ Same fixes as `/tlc:cleanup` but:
 /tlc:refactor
 ```
 
-## Process
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Use symbol, usage, and dependency lookups before editing so each refactor step accounts for its full impact.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_symbol` | Find all definitions of the symbols being refactored. |
+| `codedb_word` | Find all usages of identifiers across the codebase before renaming or extracting them. |
+| `codedb_deps` | Trace the file-level impact of moves so imports and references stay consistent. |
+
+Use the CodeDB output to build safer preview steps and reduce missed follow-up edits.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+## Process
 
 ### Step 1: Create or Resume Session
 

package/.claude/commands/tlc/review-pr.md

@@ -72,16 +72,25 @@ Same checks as `/tlc:review`:
 *Automated review by [TLC](https://github.com/jurgencalleja/TLC)*
 ```
 
-### Step 5: Post Review
-
-```bash
-# Post as PR comment
-gh pr comment <number> --body "<review_markdown>"
-
-# Or submit as review
-gh pr review <number> --approve --body "<review_markdown>"
-gh pr review <number> --request-changes --body "<review_markdown>"
-```
+### Step 5: Post Review
+
+```bash
+# Submit approval review first
+if ! gh pr review <number> --approve --body "<review_markdown>" 2>/tmp/pr-review-err; then
+  if grep -q "Can not approve your own pull request" /tmp/pr-review-err; then
+    gh pr comment <number> --body "<review_markdown>"
+    echo "Posted as comment (self-owned PR — GitHub blocks self-approval)"
+  else
+    cat /tmp/pr-review-err
+  fi
+fi
+
+# Post as PR comment directly when comment-only mode is needed
+gh pr comment <number> --body "<review_markdown>"
+
+# Or request changes as a formal review
+gh pr review <number> --request-changes --body "<review_markdown>"
+```
 
 ## Example Output
 

package/.claude/commands/tlc/review.md

@@ -174,6 +174,22 @@ TLC automatically uses ALL providers configured for the `review` capability in `
 /tlc:review --base dev   # Review vs different base branch
 ```
 
+## CodeDB Acceleration
+
+When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
+Run the security and change-impact queries early so the manual review starts from the highest-risk files.
+
+| Tool | Usage |
+|------|-------|
+| `codedb_search` | Scan for security patterns such as credentials, SQL injection, XSS, and `eval`. |
+| `codedb_deps` | Check whether changed files have unreviewed dependents elsewhere in the codebase. |
+| `codedb_hot` | Identify recently changed files that deserve extra review focus. |
+
+Use these results to prioritize findings, coverage checks, and any follow-up file reads.
+
+If CodeDB is unavailable, fall back to Grep/Glob/Read.
+
 ## Process
 
 ### Step 1: Load Router State (Persistent)

package/.claude/commands/tlc/status.md

@@ -12,9 +12,20 @@ If no phase specified, shows overall test status.
 
 ## Process
 
-1. **Detect test framework** (Vitest, Jest, pytest, etc.)
-2. **Run the test suite**
-3. **Report results** with next action
+1. **Detect workspace scope**
+   - Try `server/lib/workspace-manifest.js`
+   - If a workspace manifest exists, gather test status for every repo in the manifest with the current repo listed first
+   - Repos missing on disk show `[not cloned]`
+   - If no manifest exists, fall back to current-repo-only status
+2. **Detect test framework** (Vitest, Jest, pytest, etc.)
+3. **Run the test suite**
+4. **Report results** with next action
+
+When workspace mode is active, include a one-line summary such as:
+
+```text
+[TLC] 142 tests | [CORE] 38 tests | [SA] 67 tests
+```
 
 ## Output Examples
 
@@ -27,6 +38,15 @@ Test Status
 Ready for: /tlc:verify
 ```
 
+**Workspace-wide:**
+```
+Test Status
+───────────
+[TLC] 142 tests | [CORE] 38 tests | [SA] 67 tests
+
+Ready for: /tlc:verify in the active repo
+```
+
 **Some failing:**
 ```
 Test Status

package/.claude/commands/tlc/tlc.md

@@ -198,6 +198,14 @@ If no roadmap exists:
 
 ### Step 2: Find The Active Phase
 
+Before matching phase artifacts, determine the current repo prefix:
+
+1. Try workspace-aware discovery first:
+   - Load `/workspace/Tools/.tlc-workspace.json` when available, or discover the nearest manifest via `server/lib/workspace-manifest.js`
+   - Use the current repo path plus the manifest to resolve the repo prefix (`TLC`, `CORE`, `SA`, etc.)
+2. If no manifest is available, scan `.planning/phases/` for existing prefixed artifacts such as `TLC-108-PLAN.md` and infer the current repo prefix from those filenames
+3. If neither manifest nor prefixed files are available, fall back to legacy unprefixed detection
+
 From the roadmap, identify:
 
 - The current phase marked as in progress, current, or active
@@ -206,18 +214,22 @@ From the roadmap, identify:
 
 Extract:
 
-- Phase number
+- Phase number / phase ID
 - Phase name
 - Task count if the roadmap or plan exposes it
 - Completed task count if available
 
 ### Step 3: Check Artifacts In The Same Pass
 
-For the active phase `N`, check:
+For the active phase, build the preferred prefixed ID `{PREFIX}-{N}` when a prefix is known. Check artifacts in this order:
 
-- Discussion: `.planning/phases/{N}-DISCUSSION.md`
-- Plan: `.planning/phases/{N}-PLAN.md`
-- Verification: `.planning/phases/{N}-VERIFIED.md`
+- Discussion: `.planning/phases/{PREFIX}-{N}-DISCUSSION.md`, then legacy `.planning/phases/{N}-DISCUSSION.md`
+- Plan: `.planning/phases/{PREFIX}-{N}-PLAN.md`, then legacy `.planning/phases/{N}-PLAN.md`
+- Verification: `.planning/phases/{PREFIX}-{N}-VERIFIED.md`, then legacy `.planning/phases/{N}-VERIFIED.md`
+
+Phase file pattern matching must accept both:
+- Prefixed: `{PREFIX}-{N}-PLAN.md`, `{PREFIX}-{N}-DISCUSSION.md`, `{PREFIX}-{N}-VERIFIED.md`
+- Legacy: `{N}-PLAN.md`, `{N}-DISCUSSION.md`, `{N}-VERIFIED.md`
 
 If the plan exists, inspect it to determine build state:
 
@@ -228,16 +240,20 @@ If the plan exists, inspect it to determine build state:
 Use these state rules:
 
 1. No discussion file:
-   Run `/tlc:discuss {N}`
+   Run `/tlc:discuss {PHASE_ID}`
 2. Discussion exists, no plan:
-   Run `/tlc:plan {N}`
+   Run `/tlc:plan {PHASE_ID}`
 3. Plan exists and phase is not fully built:
-   Run `/tlc:build {N}`
+   Run `/tlc:build {PHASE_ID}`
 4. Build complete, no verification file:
-   Run `/tlc:verify {N}`
+   Run `/tlc:verify {PHASE_ID}`
 5. Verification exists or all phases are complete:
    Suggest release, but do not auto-run it
 
+Backward compatibility:
+- If prefixed artifacts exist, prefer them everywhere in status output and auto-run commands
+- If no prefixed artifacts exist and no workspace manifest is found, continue using legacy unprefixed phase IDs
+
 ## Output Format
 
 Normal output must stay within 3-5 lines.
@@ -245,9 +261,9 @@ Normal output must stay within 3-5 lines.
 Use this pattern:
 
 ```text
-TLC v{version} | Phase {N}: {Name} | {done}/{total} tasks done
+TLC v{version} | Phase {PHASE_ID}: {Name} | {done}/{total} tasks done
 Next: {action summary}
-Running /tlc:{command} {N}...
+Running /tlc:{command} {PHASE_ID}...
 ```
 
 If there is nothing safe to auto-run:
@@ -288,7 +304,7 @@ Auto-run:
 Auto-run:
 
 ```text
-/tlc:plan {N}
+/tlc:plan {PHASE_ID}
 ```
 
 ### Planned, Not Built
@@ -296,7 +312,7 @@ Auto-run:
 Auto-run:
 
 ```text
-/tlc:build {N}
+/tlc:build {PHASE_ID}
 ```
 
 Use the next incomplete task from the plan in the status line when available.
@@ -306,7 +322,7 @@ Use the next incomplete task from the plan in the status line when available.
 Auto-run:
 
 ```text
-/tlc:verify {N}
+/tlc:verify {PHASE_ID}
 ```
 
 ### All Complete
@@ -322,9 +338,9 @@ Run /tlc:complete or /tlc:new-milestone
 ## Example
 
 ```text
-TLC v2.4.2 | Phase 8: Auth System | 3/5 tasks done
+TLC v2.4.2 | Phase TLC-8: Auth System | 3/5 tasks done
 Next: build task 4 (JWT middleware)
-Running /tlc:build 8...
+Running /tlc:build TLC-8...
 ```
 
 ## Summary

package/.claude/hooks/tlc-session-init.sh

@@ -72,6 +72,30 @@ else
   fi
 fi
 
+# ─── CodeDB (codebase awareness) ─────────────────────
+if command -v codedb >/dev/null 2>&1; then
+  if curl -sf --max-time 1 "http://localhost:7719/health" > /dev/null 2>&1; then
+    echo "codedb: running"
+  else
+    codedb serve "$PROJECT_DIR" > /dev/null 2>&1 &
+    echo "codedb: started indexing $PROJECT_DIR"
+  fi
+  # Ensure .mcp.json exists for Claude Code MCP discovery
+  if [ ! -f "$PROJECT_DIR/.mcp.json" ]; then
+    cat > "$PROJECT_DIR/.mcp.json" <<'MCPEOF'
+{
+  "mcpServers": {
+    "codedb": {
+      "command": "codedb",
+      "args": ["mcp", "."]
+    }
+  }
+}
+MCPEOF
+    echo "codedb: created .mcp.json"
+  fi
+fi
+
 # ─── Memory System Init ─────────────────────────────
 mkdir -p "$PROJECT_DIR/.tlc/memory/team/decisions" \
          "$PROJECT_DIR/.tlc/memory/team/gotchas" \