tlc-claude-code 2.6.1 → 2.8.0

package/CLAUDE.md

@@ -11,6 +11,20 @@
 5. **No Co-Authored-By in commits.** The user is the author. Claude is a tool.
 6. **Ask before `git push`.** Never push without explicit approval.
 
+## CodeDB
+
+When `.mcp.json` contains a `codedb` server entry, prefer CodeDB MCP tools over built-in equivalents:
+
+| Prefer | Instead of | Use for |
+|--------|------------|---------|
+| `codedb_tree` | Glob | file/folder discovery |
+| `codedb_search` / `codedb_word` | Grep | text/identifier search |
+| `codedb_outline` | Read | understanding file structure (symbols, exports) |
+| `codedb_deps` | manual import tracing | reverse dependency analysis |
+| `codedb_bundle` | multiple separate calls | batch multiple queries into one call (up to 20 ops) |
+
+If CodeDB MCP tools are not available (no `.mcp.json` or server unreachable), fall back to built-in Grep/Glob/Read.
+
 ## Command Dispatch
 
 When the user says X → invoke `Skill(skill="tlc:...")`:

package/bin/install.js

@@ -190,6 +190,9 @@ function install(targetDir, installType) {
     success(`Installed settings template with hook wiring`);
   }
 
+  // Install CodeDB (codebase awareness — sub-ms code search, 1600x token reduction)
+  installCodedb();
+
   // Fix ownership if running under sudo
   if (isRunningAsSudo()) {
     const claudeDir = path.dirname(targetDir);
@@ -215,6 +218,69 @@ function install(targetDir, installType) {
   log('');
 }
 
+function installCodedb() {
+  const { execSync } = require('child_process');
+
+  // Check if already installed
+  try {
+    const version = execSync('codedb --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
+    success(`CodeDB already installed: ${c.cyan}${version}${c.reset}`);
+    return;
+  } catch {
+    // Not installed — continue
+  }
+
+  log(`Installing ${c.cyan}CodeDB${c.reset} (codebase awareness)...`);
+
+  const platform = process.platform;
+  const arch = process.arch;
+
+  let asset;
+  if (platform === 'darwin' && arch === 'arm64') {
+    asset = 'codedb-darwin-arm64';
+  } else if (platform === 'linux' && arch === 'x64') {
+    asset = 'codedb-linux-x86_64';
+  } else {
+    log(`${c.yellow}CodeDB: no binary for ${platform}-${arch}. Skipping.${c.reset}`);
+    return;
+  }
+
+  const url = `https://github.com/justrach/codedb/releases/download/v0.2.4/${asset}`;
+
+  // Find writable bin directory
+  const binDirs = [
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+    path.join(process.env.HOME || '/root', '.local', 'bin'),
+  ];
+
+  let targetBin;
+  for (const dir of binDirs) {
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      fs.accessSync(dir, fs.constants.W_OK);
+      targetBin = path.join(dir, 'codedb');
+      break;
+    } catch {
+      continue;
+    }
+  }
+
+  if (!targetBin) {
+    log(`${c.yellow}CodeDB: no writable bin directory found. Install manually: curl -fsSL https://codedb.codegraff.com/install.sh | sh${c.reset}`);
+    return;
+  }
+
+  try {
+    execSync(`curl -fsSL -o "${targetBin}" "${url}"`, { stdio: 'pipe' });
+    fs.chmodSync(targetBin, 0o755);
+    const version = execSync(`"${targetBin}" --version`, { encoding: 'utf8', stdio: 'pipe' }).trim();
+    success(`CodeDB installed: ${c.cyan}${version}${c.reset} at ${c.dim}${targetBin}${c.reset}`);
+  } catch (err) {
+    log(`${c.yellow}CodeDB: install failed (${err.message}). Install manually: curl -fsSL https://codedb.codegraff.com/install.sh | sh${c.reset}`);
+  }
+}
+
 function installHooks(targetDir, packageRoot) {
   // For local install: .claude/commands -> go up to .claude/hooks
   // For global install: ~/.claude/commands -> go up to ~/.claude/hooks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "2.6.1",
+  "version": "2.8.0",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc-claude-code": "./bin/install.js",

package/scripts/renumber-phases.js

@@ -0,0 +1,283 @@
+const fs = require('fs');
+const path = require('path');
+
+const ALLOWED_SUFFIXES = new Set([
+  'PLAN',
+  'DISCUSSION',
+  'TESTS',
+  'VERIFIED',
+  'TEST-PLAN',
+  'ARCHITECTURE',
+  'COMPLETION-PLAN',
+  'NOTE',
+  'AUDIT-REPORT',
+  'RESEARCH',
+  'DISCUSSION-addendum',
+]);
+
+const PHASE_FILE_PATTERN = /^([A-Za-z0-9]+)-([A-Za-z-]+)\.md(\.superseded)?$/;
+
+function printUsage(stream = process.stderr) {
+  stream.write(
+    'Usage: node scripts/renumber-phases.js --repo-path <path> --prefix <PREFIX> [--dry-run]\n'
+  );
+}
+
+function parseArgs(argv) {
+  const options = {
+    dryRun: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (arg === '--repo-path' || arg === '--prefix') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+
+      if (arg === '--repo-path') {
+        options.repoPath = value;
+      } else {
+        options.prefix = value;
+      }
+
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  if (!options.repoPath || !options.prefix) {
+    throw new Error('Missing required arguments');
+  }
+
+  return options;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function createPhaseReferenceRegex(prefix) {
+  return new RegExp(`\\bPhase\\s+(${escapeRegExp(prefix)}-)?(\\d+[A-Za-z]?)\\b`, 'g');
+}
+
+function updatePhaseReferences(content, prefix) {
+  const regex = createPhaseReferenceRegex(prefix);
+  let replacements = 0;
+
+  const updated = content.replace(regex, (match, existingPrefix, phaseId) => {
+    if (existingPrefix) {
+      return match;
+    }
+
+    replacements += 1;
+    return `Phase ${prefix}-${phaseId}`;
+  });
+
+  return {
+    content: updated,
+    replacements,
+  };
+}
+
+function isEligiblePhaseFile(name, prefix) {
+  const match = name.match(PHASE_FILE_PATTERN);
+  if (!match) {
+    return null;
+  }
+
+  const [, phaseId, suffix, supersededExtension = ''] = match;
+
+  if (phaseId.startsWith(`${prefix}-`)) {
+    return null;
+  }
+
+  if (!/^\d+[A-Za-z]?$/.test(phaseId)) {
+    return null;
+  }
+
+  if (!ALLOWED_SUFFIXES.has(suffix)) {
+    return null;
+  }
+
+  return {
+    phaseId,
+    suffix,
+    supersededExtension,
+  };
+}
+
+function collectOperations(repoPath, prefix) {
+  const phasesDir = path.join(repoPath, '.planning', 'phases');
+  if (!fs.existsSync(phasesDir) || !fs.statSync(phasesDir).isDirectory()) {
+    throw new Error(`Missing phases directory: ${phasesDir}`);
+  }
+
+  const roadmapPath = path.join(repoPath, '.planning', 'ROADMAP.md');
+  const operations = [];
+  const errors = [];
+
+  for (const entry of fs.readdirSync(phasesDir, { withFileTypes: true })) {
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const fileInfo = isEligiblePhaseFile(entry.name, prefix);
+    if (!fileInfo) {
+      continue;
+    }
+
+    const nextName = `${prefix}-${fileInfo.phaseId}-${fileInfo.suffix}.md${fileInfo.supersededExtension}`;
+    operations.push({
+      type: 'rename-file',
+      from: path.join(phasesDir, entry.name),
+      to: path.join(phasesDir, nextName),
+      phaseId: fileInfo.phaseId,
+    });
+  }
+
+  if (fs.existsSync(roadmapPath)) {
+    const roadmapContent = fs.readFileSync(roadmapPath, 'utf8');
+    const updatedRoadmap = updatePhaseReferences(roadmapContent, prefix);
+
+    if (updatedRoadmap.replacements > 0) {
+      operations.push({
+        type: 'update-file',
+        target: roadmapPath,
+        nextContent: updatedRoadmap.content,
+        replacements: updatedRoadmap.replacements,
+      });
+    }
+  }
+
+  for (const renameOperation of operations.filter((operation) => operation.type === 'rename-file')) {
+    const content = fs.readFileSync(renameOperation.from, 'utf8');
+    const updated = updatePhaseReferences(content, prefix);
+
+    if (updated.replacements > 0) {
+      operations.push({
+        type: 'update-renamed-file',
+        target: renameOperation.to,
+        sourcePath: renameOperation.from,
+        nextContent: updated.content,
+        replacements: updated.replacements,
+      });
+    }
+  }
+
+  for (const renameOperation of operations.filter((operation) => operation.type === 'rename-file')) {
+    if (!fs.existsSync(renameOperation.to)) {
+      continue;
+    }
+
+    errors.push(
+      `Cannot rename ${path.basename(renameOperation.from)} because ${path.basename(renameOperation.to)} already exists`
+    );
+  }
+
+  return {
+    operations,
+    errors,
+  };
+}
+
+function applyOperations(operations, dryRun) {
+  const summary = {
+    renamed: 0,
+    updated: 0,
+  };
+
+  for (const operation of operations) {
+    if (operation.type === 'rename-file') {
+      if (dryRun) {
+        console.log(`DRY-RUN rename ${operation.from} -> ${operation.to}`);
+      } else {
+        fs.renameSync(operation.from, operation.to);
+      }
+
+      summary.renamed += 1;
+      continue;
+    }
+
+    if (operation.type === 'update-file' || operation.type === 'update-renamed-file') {
+      if (dryRun) {
+        console.log(`DRY-RUN update ${operation.target} (${operation.replacements} references)`);
+      } else {
+        fs.writeFileSync(operation.target, operation.nextContent);
+      }
+
+      summary.updated += operation.replacements;
+    }
+  }
+
+  return summary;
+}
+
+function renumberPhases({ repoPath, prefix, dryRun = false }) {
+  const resolvedRepoPath = path.resolve(repoPath);
+  const trimmedPrefix = prefix.trim();
+
+  if (!trimmedPrefix) {
+    throw new Error('Prefix must not be empty');
+  }
+
+  const { operations, errors } = collectOperations(resolvedRepoPath, trimmedPrefix);
+  const summary = applyOperations(operations, dryRun);
+
+  for (const error of errors) {
+    console.error(error);
+  }
+
+  const finalSummary = {
+    renamed: summary.renamed,
+    updated: summary.updated,
+    errors: errors.length,
+  };
+
+  console.log(
+    `Renamed: ${finalSummary.renamed} files, Updated: ${finalSummary.updated} references, Errors: ${finalSummary.errors}`
+  );
+
+  return finalSummary;
+}
+
+function main(argv = process.argv.slice(2)) {
+  try {
+    const options = parseArgs(argv);
+    renumberPhases(options);
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+
+    if (message.startsWith('Missing required arguments') || message.startsWith('Missing value for')) {
+      printUsage(process.stderr);
+    }
+
+    console.error(message);
+    return 1;
+  }
+}
+
+if (require.main === module) {
+  process.exit(main());
+}
+
+module.exports = {
+  ALLOWED_SUFFIXES,
+  PHASE_FILE_PATTERN,
+  collectOperations,
+  main,
+  parseArgs,
+  printUsage,
+  renumberPhases,
+  updatePhaseReferences,
+};

package/scripts/renumber-phases.test.js

@@ -0,0 +1,305 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import renumberModule from './renumber-phases.js';
+
+const { main, parseArgs, renumberPhases, updatePhaseReferences } = renumberModule;
+
+const SCRIPT_PATH = path.join(process.cwd(), 'scripts', 'renumber-phases.js');
+const tempDirs = [];
+
+function createTempRepo(structure = {}) {
+  const repoPath = fs.mkdtempSync(path.join(os.tmpdir(), 'renumber-phases-'));
+  tempDirs.push(repoPath);
+
+  for (const [relativePath, content] of Object.entries(structure)) {
+    const filePath = path.join(repoPath, relativePath);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+  }
+
+  return repoPath;
+}
+
+function readFile(repoPath, relativePath) {
+  return fs.readFileSync(path.join(repoPath, relativePath), 'utf8');
+}
+
+function fileExists(repoPath, relativePath) {
+  return fs.existsSync(path.join(repoPath, relativePath));
+}
+
+function createPlanningRepo() {
+  return createTempRepo({
+    '.planning/ROADMAP.md': [
+      '# Roadmap',
+      '### Phase 108: Build the tool',
+      'Depends on Phase 107 and Phase 101b.',
+      'Already migrated: Phase TLC-999.',
+      '',
+    ].join('\n'),
+    '.planning/phases/108-PLAN.md': [
+      '# Phase 108',
+      'Depends on Phase 107.',
+      'Review Phase 101b before release.',
+      'Already references Phase TLC-105 correctly.',
+      '',
+    ].join('\n'),
+    '.planning/phases/108-DISCUSSION.md': 'Phase 108 requires context from Phase 107.\n',
+    '.planning/phases/101b-RESEARCH.md': 'Research for Phase 101b.\n',
+    '.planning/phases/108-PLAN.md.superseded': 'Superseded Phase 108 draft.\n',
+    '.planning/phases/TLC-105-PLAN.md': 'Already migrated.\n',
+    '.planning/phases/77-OldPLAN.md': 'Should be ignored.\n',
+    '.planning/phases/77-PLAN.md.md': 'Should be ignored.\n',
+    '.planning/phases/notes.txt': 'Should be ignored.\n',
+  });
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('updatePhaseReferences', () => {
+  it('adds the prefix to bare phase references and leaves prefixed ones unchanged', () => {
+    const source = 'Phase 108 follows Phase 101b. Phase TLC-42 stays as-is.';
+
+    const result = updatePhaseReferences(source, 'TLC');
+
+    expect(result.content).toBe(
+      'Phase TLC-108 follows Phase TLC-101b. Phase TLC-42 stays as-is.'
+    );
+    expect(result.replacements).toBe(2);
+  });
+});
+
+describe('parseArgs', () => {
+  it('parses repo path, prefix, and dry-run', () => {
+    expect(
+      parseArgs(['--repo-path', '/tmp/repo', '--prefix', 'TLC', '--dry-run'])
+    ).toEqual({
+      dryRun: true,
+      repoPath: '/tmp/repo',
+      prefix: 'TLC',
+    });
+  });
+
+  it('throws when required arguments are missing', () => {
+    expect(() => parseArgs(['--prefix', 'TLC'])).toThrow('Missing required arguments');
+    expect(() => parseArgs(['--repo-path', '/tmp/repo'])).toThrow('Missing required arguments');
+  });
+});
+
+describe('renumberPhases', () => {
+  it('renames matching files, updates roadmap references, and preserves ignored files', () => {
+    const repoPath = createPlanningRepo();
+    const stdout = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const stderr = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const summary = renumberPhases({
+      repoPath,
+      prefix: 'TLC',
+    });
+
+    expect(summary).toEqual({
+      renamed: 4,
+      updated: 10,
+      errors: 0,
+    });
+
+    expect(fileExists(repoPath, '.planning/phases/TLC-108-PLAN.md')).toBe(true);
+    expect(fileExists(repoPath, '.planning/phases/TLC-108-DISCUSSION.md')).toBe(true);
+    expect(fileExists(repoPath, '.planning/phases/TLC-101b-RESEARCH.md')).toBe(true);
+    expect(fileExists(repoPath, '.planning/phases/TLC-108-PLAN.md.superseded')).toBe(true);
+
+    expect(fileExists(repoPath, '.planning/phases/108-PLAN.md')).toBe(false);
+    expect(fileExists(repoPath, '.planning/phases/108-DISCUSSION.md')).toBe(false);
+    expect(fileExists(repoPath, '.planning/phases/101b-RESEARCH.md')).toBe(false);
+    expect(fileExists(repoPath, '.planning/phases/108-PLAN.md.superseded')).toBe(false);
+
+    expect(fileExists(repoPath, '.planning/phases/TLC-105-PLAN.md')).toBe(true);
+    expect(fileExists(repoPath, '.planning/phases/77-OldPLAN.md')).toBe(true);
+    expect(fileExists(repoPath, '.planning/phases/77-PLAN.md.md')).toBe(true);
+
+    expect(readFile(repoPath, '.planning/ROADMAP.md')).toContain('### Phase TLC-108: Build the tool');
+    expect(readFile(repoPath, '.planning/ROADMAP.md')).toContain('Depends on Phase TLC-107 and Phase TLC-101b.');
+    expect(readFile(repoPath, '.planning/ROADMAP.md')).toContain('Already migrated: Phase TLC-999.');
+
+    expect(readFile(repoPath, '.planning/phases/TLC-108-PLAN.md')).toContain('Depends on Phase TLC-107.');
+    expect(readFile(repoPath, '.planning/phases/TLC-108-PLAN.md')).toContain(
+      'Review Phase TLC-101b before release.'
+    );
+    expect(readFile(repoPath, '.planning/phases/TLC-108-PLAN.md')).toContain(
+      'Already references Phase TLC-105 correctly.'
+    );
+    expect(readFile(repoPath, '.planning/phases/TLC-108-DISCUSSION.md')).toContain(
+      'Phase TLC-108 requires context from Phase TLC-107.'
+    );
+    expect(readFile(repoPath, '.planning/phases/TLC-108-PLAN.md.superseded')).toContain(
+      'Superseded Phase TLC-108 draft.'
+    );
+
+    expect(stdout).toHaveBeenLastCalledWith('Renamed: 4 files, Updated: 10 references, Errors: 0');
+    expect(stderr).not.toHaveBeenCalled();
+  });
+
+  it('supports dry-run without modifying files', () => {
+    const repoPath = createPlanningRepo();
+    const originalRoadmap = readFile(repoPath, '.planning/ROADMAP.md');
+    const originalPlan = readFile(repoPath, '.planning/phases/108-PLAN.md');
+    const stdout = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const summary = renumberPhases({
+      repoPath,
+      prefix: 'TLC',
+      dryRun: true,
+    });
+
+    expect(summary).toEqual({
+      renamed: 4,
+      updated: 10,
+      errors: 0,
+    });
+
+    expect(fileExists(repoPath, '.planning/phases/108-PLAN.md')).toBe(true);
+    expect(fileExists(repoPath, '.planning/phases/TLC-108-PLAN.md')).toBe(false);
+    expect(readFile(repoPath, '.planning/ROADMAP.md')).toBe(originalRoadmap);
+    expect(readFile(repoPath, '.planning/phases/108-PLAN.md')).toBe(originalPlan);
+
+    expect(stdout.mock.calls).toEqual(
+      expect.arrayContaining([
+        [expect.stringContaining('DRY-RUN rename')],
+        [expect.stringContaining('DRY-RUN update')],
+        ['Renamed: 4 files, Updated: 10 references, Errors: 0'],
+      ])
+    );
+  });
+
+  it('is idempotent when run again on already-prefixed files', () => {
+    const repoPath = createPlanningRepo();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const firstSummary = renumberPhases({
+      repoPath,
+      prefix: 'TLC',
+    });
+
+    const secondSummary = renumberPhases({
+      repoPath,
+      prefix: 'TLC',
+    });
+
+    expect(firstSummary).toEqual({
+      renamed: 4,
+      updated: 10,
+      errors: 0,
+    });
+    expect(secondSummary).toEqual({
+      renamed: 0,
+      updated: 0,
+      errors: 0,
+    });
+
+    expect(fileExists(repoPath, '.planning/phases/TLC-108-PLAN.md')).toBe(true);
+    expect(readFile(repoPath, '.planning/ROADMAP.md')).toContain('### Phase TLC-108: Build the tool');
+  });
+
+  it('reports rename collisions as errors without overwriting files', () => {
+    const repoPath = createTempRepo({
+      '.planning/ROADMAP.md': '### Phase 108: Collision case\nPhase 108 only.\n',
+      '.planning/phases/108-PLAN.md': 'Phase 108.\n',
+      '.planning/phases/TLC-108-PLAN.md': 'Existing target.\n',
+    });
+    const stdout = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const stderr = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const summary = renumberPhases({
+      repoPath,
+      prefix: 'TLC',
+      dryRun: true,
+    });
+
+    expect(summary).toEqual({
+      renamed: 1,
+      updated: 3,
+      errors: 1,
+    });
+    expect(stderr).toHaveBeenCalledWith(
+      'Cannot rename 108-PLAN.md because TLC-108-PLAN.md already exists'
+    );
+    expect(stdout).toHaveBeenLastCalledWith('Renamed: 1 files, Updated: 3 references, Errors: 1');
+  });
+
+  it('throws when the phases directory is missing', () => {
+    const repoPath = createTempRepo({
+      '.planning/ROADMAP.md': '### Phase 1: Missing phases dir\n',
+    });
+
+    expect(() =>
+      renumberPhases({
+        repoPath,
+        prefix: 'TLC',
+      })
+    ).toThrow(`Missing phases directory: ${path.join(repoPath, '.planning', 'phases')}`);
+  });
+});
+
+describe('main', () => {
+  it('returns 1 and prints usage for missing repo-path', () => {
+    const stdout = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const exitCode = main(['--prefix', 'TLC']);
+
+    expect(exitCode).toBe(1);
+    expect(stdout).not.toHaveBeenCalled();
+    expect(stderr).toHaveBeenCalledWith(
+      'Usage: node scripts/renumber-phases.js --repo-path <path> --prefix <PREFIX> [--dry-run]\n'
+    );
+    expect(consoleError).toHaveBeenCalledWith('Missing required arguments');
+  });
+
+  it('returns 1 when the phases directory does not exist', () => {
+    const repoPath = createTempRepo({
+      '.planning/ROADMAP.md': '### Phase 1: Missing phases dir\n',
+    });
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const exitCode = main(['--repo-path', repoPath, '--prefix', 'TLC']);
+
+    expect(exitCode).toBe(1);
+    expect(consoleError).toHaveBeenCalledWith(
+      `Missing phases directory: ${path.join(repoPath, '.planning', 'phases')}`
+    );
+  });
+
+  it('works from the real CLI entry point', () => {
+    const repoPath = createTempRepo({
+      '.planning/ROADMAP.md': '### Phase 12: CLI check\nPhase 12 is ready.\n',
+      '.planning/phases/12-PLAN.md': 'Phase 12 is ready.\n',
+    });
+
+    const result = spawnSync(
+      process.execPath,
+      [SCRIPT_PATH, '--repo-path', repoPath, '--prefix', 'TLC'],
+      {
+        encoding: 'utf8',
+      }
+    );
+
+    expect(result.status).toBe(0);
+    expect(result.stderr).toBe('');
+    expect(result.stdout).toContain('Renamed: 1 files, Updated: 3 references, Errors: 0');
+    expect(fileExists(repoPath, '.planning/phases/TLC-12-PLAN.md')).toBe(true);
+    expect(readFile(repoPath, '.planning/ROADMAP.md')).toContain('### Phase TLC-12: CLI check');
+  });
+});