tlc-claude-code 2.1.0 → 2.2.0

package/bin/install.js

@@ -72,6 +72,7 @@ const COMMANDS = [
   // Review
   'review.md',
   'review-pr.md',
+  'review-plan.md',
   // Documentation
   'docs.md',
   // Multi-Tool & Deployment
@@ -103,6 +104,13 @@ const HOOKS = [
   'tlc-capture-exchange.sh'
 ];
 
+// Claude Code agent definitions (managed by TLC — identified by '# TLC Agent:' header)
+const AGENTS = [
+  'reviewer.md',
+  'builder.md',
+  'planner.md'
+];
+
 function getGlobalDir() {
   const claudeConfig = process.env.CLAUDE_CONFIG_DIR || path.join(require('os').homedir(), '.claude');
   return path.join(claudeConfig, 'commands');
@@ -168,12 +176,28 @@ function install(targetDir, installType) {
     success(`Installed ${hooksInstalled} hooks to ${c.cyan}${path.dirname(targetDir)}/.claude/hooks/${c.reset}`);
   }
 
+  // Install agent definitions (Claude Code sub-agents)
+  const agentsInstalled = installAgents(targetDir, packageRoot);
+  if (agentsInstalled > 0) {
+    success(`Installed ${agentsInstalled} agents to ${c.cyan}${path.dirname(targetDir)}/.claude/agents/${c.reset}`);
+  }
+
   // Install settings template (with hooks wiring)
-  const settingsInstalled = installSettings(targetDir);
+  const settingsInstalled = installSettings(targetDir, installType);
   if (settingsInstalled) {
     success(`Installed settings template with hook wiring`);
   }
 
+  // Fix ownership if running under sudo
+  if (isRunningAsSudo()) {
+    const claudeDir = path.dirname(targetDir);
+    fixOwnership(commandsDir);
+    fixOwnership(path.join(claudeDir, 'hooks'));
+    fixOwnership(path.join(claudeDir, 'agents'));
+    fixOwnership(path.join(claudeDir, 'settings.json'));
+    success(`Fixed file ownership for ${c.cyan}${process.env.SUDO_USER}${c.reset}`);
+  }
+
   log('');
   log(`${c.green}Done!${c.reset} Restart Claude Code to load commands.`);
   log('');
@@ -217,12 +241,55 @@ function installHooks(targetDir, packageRoot) {
   return copied;
 }
 
-function installSettings(targetDir) {
+function installAgents(targetDir, packageRoot) {
+  // targetDir is .claude/commands (or ~/.claude/commands)
+  // agents go into the sibling .claude/agents/ directory
+  const claudeDir = path.dirname(targetDir);
+  const agentsDestDir = path.join(claudeDir, 'agents');
+  fs.mkdirSync(agentsDestDir, { recursive: true });
+
+  // Try .claude/agents/ first (npm package structure), fall back to nothing
+  const agentsSrcDir = fs.existsSync(path.join(packageRoot, '.claude', 'agents'))
+    ? path.join(packageRoot, '.claude', 'agents')
+    : null;
+
+  if (!agentsSrcDir) return 0;
+
+  const TLC_AGENT_MARKER = '# TLC Agent:';
+
+  let copied = 0;
+  for (const file of AGENTS) {
+    const src = path.join(agentsSrcDir, file);
+    const dest = path.join(agentsDestDir, file);
+    if (!fs.existsSync(src)) continue;
+
+    // Only overwrite if the destination either doesn't exist or is TLC-managed
+    if (fs.existsSync(dest)) {
+      const existing = fs.readFileSync(dest, 'utf8');
+      if (!existing.startsWith(TLC_AGENT_MARKER)) {
+        // User has customized this agent — leave it alone
+        continue;
+      }
+    }
+
+    fs.copyFileSync(src, dest);
+    copied++;
+  }
+  return copied;
+}
+
+function installSettings(targetDir, installType) {
   // For local install: .claude/commands -> go up to .claude/settings.json
   // For global install: ~/.claude/commands -> go up to ~/.claude/settings.json
   const claudeDir = path.dirname(targetDir);
   const settingsPath = path.join(claudeDir, 'settings.json');
 
+  // Global installs put hooks in ~/.claude/hooks/ (or $CLAUDE_CONFIG_DIR/hooks/ if set)
+  // Local installs put hooks in .claude/hooks/ (use $CLAUDE_PROJECT_DIR)
+  const hooksBase = installType === 'global'
+    ? '${CLAUDE_CONFIG_DIR:-$HOME/.claude}/hooks'
+    : '$CLAUDE_PROJECT_DIR/.claude/hooks';
+
   // The settings template with full hook wiring
   const settingsTemplate = {
     permissions: {
@@ -243,21 +310,21 @@ function installSettings(targetDir) {
         matcher: "EnterPlanMode|TaskCreate|TaskUpdate|TaskList|TaskGet|ExitPlanMode",
         hooks: [{
           type: "command",
-          command: "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-block-tools.sh",
+          command: `bash ${hooksBase}/tlc-block-tools.sh`,
           timeout: 5
         }]
       }],
       UserPromptSubmit: [{
         hooks: [{
           type: "command",
-          command: "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-prompt-guard.sh",
+          command: `bash ${hooksBase}/tlc-prompt-guard.sh`,
           timeout: 5
         }]
       }],
       SessionStart: [{
         hooks: [{
           type: "command",
-          command: "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-session-init.sh",
+          command: `bash ${hooksBase}/tlc-session-init.sh`,
           timeout: 5
         }]
       }],
@@ -266,7 +333,7 @@ function installSettings(targetDir) {
           matcher: "Bash",
           hooks: [{
             type: "command",
-            command: "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-post-push.sh",
+            command: `bash ${hooksBase}/tlc-post-push.sh`,
             timeout: 5
           }]
         },
@@ -274,7 +341,7 @@ function installSettings(targetDir) {
           matcher: "Skill",
           hooks: [{
             type: "command",
-            command: "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-post-build.sh",
+            command: `bash ${hooksBase}/tlc-post-build.sh`,
             timeout: 5
           }]
         }
@@ -282,7 +349,7 @@ function installSettings(targetDir) {
       Stop: [{
         hooks: [{
           type: "command",
-          command: "bash \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/tlc-capture-exchange.sh",
+          command: `bash "${hooksBase}/tlc-capture-exchange.sh"`,
           timeout: 30
         }]
       }]
@@ -319,6 +386,30 @@ function installSettings(targetDir) {
   }
 }
 
+function isRunningAsSudo() {
+  return process.getuid && process.getuid() === 0 && process.env.SUDO_USER;
+}
+
+function fixOwnership(targetPath) {
+  const sudoUid = parseInt(process.env.SUDO_UID, 10);
+  const sudoGid = parseInt(process.env.SUDO_GID, 10);
+  if (isNaN(sudoUid) || isNaN(sudoGid)) return;
+
+  try {
+    const stat = fs.statSync(targetPath);
+    if (stat.isDirectory()) {
+      fs.chownSync(targetPath, sudoUid, sudoGid);
+      for (const entry of fs.readdirSync(targetPath)) {
+        fixOwnership(path.join(targetPath, entry));
+      }
+    } else {
+      fs.chownSync(targetPath, sudoUid, sudoGid);
+    }
+  } catch (err) {
+    // Best effort
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -330,6 +421,12 @@ async function main() {
 
   printBanner();
 
+  // Warn if running under sudo — files will be owned by root
+  if (isRunningAsSudo()) {
+    log(`${c.yellow}⚠  Running under sudo — will fix file ownership for ${process.env.SUDO_USER}${c.reset}`);
+    log('');
+  }
+
   if (args.includes('--global') || args.includes('-g')) {
     info(`Installing ${c.bold}globally${c.reset} to ~/.claude/commands/tlc`);
     log('');

package/bin/postinstall.js

@@ -5,15 +5,17 @@ const path = require('path');
 const os = require('os');
 
 const packageRoot = path.join(__dirname, '..');
-const claudeHome = path.join(os.homedir(), '.claude');
+const claudeHome = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 
 // Source directories (inside npm package)
 const commandsSrcDir = path.join(packageRoot, '.claude', 'commands', 'tlc');
 const hooksSrcDir = path.join(packageRoot, '.claude', 'hooks');
+const agentsSrcDir = path.join(packageRoot, '.claude', 'agents');
 
 // Destination directories (user's home)
 const commandsDestDir = path.join(claudeHome, 'commands', 'tlc');
 const hooksDestDir = path.join(claudeHome, 'hooks');
+const agentsDestDir = path.join(claudeHome, 'agents');
 
 function ensureDir(dir) {
   if (!fs.existsSync(dir)) {
@@ -51,10 +53,56 @@ function copyHooks() {
   return copied;
 }
 
+// Copy all .md agent files (only overwrite TLC-managed ones)
+function copyAgents() {
+  if (!fs.existsSync(agentsSrcDir)) return 0;
+  ensureDir(agentsDestDir);
+
+  const files = fs.readdirSync(agentsSrcDir).filter(f => f.endsWith('.md'));
+  let copied = 0;
+  for (const file of files) {
+    const dest = path.join(agentsDestDir, file);
+    // Don't overwrite user-customized agents
+    if (fs.existsSync(dest)) {
+      const content = fs.readFileSync(dest, 'utf8');
+      if (!content.startsWith('# TLC Agent:')) continue;
+    }
+    fs.copyFileSync(path.join(agentsSrcDir, file), dest);
+    copied++;
+  }
+  return copied;
+}
+
+function isRunningAsSudo() {
+  return process.getuid && process.getuid() === 0 && process.env.SUDO_USER;
+}
+
+function fixOwnership(targetPath) {
+  // After writing files as root, fix ownership to the actual user
+  const sudoUid = parseInt(process.env.SUDO_UID, 10);
+  const sudoGid = parseInt(process.env.SUDO_GID, 10);
+  if (isNaN(sudoUid) || isNaN(sudoGid)) return;
+
+  try {
+    const stat = fs.statSync(targetPath);
+    if (stat.isDirectory()) {
+      fs.chownSync(targetPath, sudoUid, sudoGid);
+      for (const entry of fs.readdirSync(targetPath)) {
+        fixOwnership(path.join(targetPath, entry));
+      }
+    } else {
+      fs.chownSync(targetPath, sudoUid, sudoGid);
+    }
+  } catch (err) {
+    // Best effort
+  }
+}
+
 function postinstall() {
   try {
     const commands = copyCommands();
     const hooks = copyHooks();
+    const agents = copyAgents();
 
     if (commands > 0) {
       console.log(`\x1b[32m✓\x1b[0m TLC: Installed ${commands} commands to ~/.claude/commands/tlc/`);
@@ -62,6 +110,17 @@ function postinstall() {
     if (hooks > 0) {
       console.log(`\x1b[32m✓\x1b[0m TLC: Installed ${hooks} hooks to ~/.claude/hooks/`);
     }
+    if (agents > 0) {
+      console.log(`\x1b[32m✓\x1b[0m TLC: Installed ${agents} agents to ~/.claude/agents/`);
+    }
+
+    // Fix ownership if running under sudo
+    if (isRunningAsSudo()) {
+      console.log(`\x1b[33m⚠\x1b[0m TLC: Detected sudo — fixing file ownership for ${process.env.SUDO_USER}`);
+      fixOwnership(commandsDestDir);
+      fixOwnership(hooksDestDir);
+      fixOwnership(agentsDestDir);
+    }
   } catch (err) {
     // Silent fail - don't break npm install
     if (process.env.DEBUG) {

package/bin/setup-autoupdate.js

@@ -0,0 +1,206 @@
+/**
+ * TLC Auto-Update Setup
+ * Creates scheduled jobs to keep Claude Code and Codex CLI updated daily.
+ */
+
+import os from 'os';
+import path from 'path';
+
+const LAUNCH_AGENT_LABEL = 'com.tlc.autoupdate';
+const LAUNCH_AGENT_PLIST = `${os.homedir()}/Library/LaunchAgents/${LAUNCH_AGENT_LABEL}.plist`;
+const TLC_DIR = `${os.homedir()}/.tlc`;
+const SCRIPT_PATH = `${TLC_DIR}/autoupdate.sh`;
+const LOG_PATH = `${TLC_DIR}/logs/autoupdate.log`;
+const TIMESTAMP_FILE = '.last-update';
+
+/**
+ * Generates a macOS LaunchAgent plist XML string for daily auto-update.
+ * @param {string} scriptPath - Absolute path to the update shell script.
+ * @returns {string} XML plist content.
+ */
+export function generateLaunchdPlist(scriptPath) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCH_AGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>${scriptPath}</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>86400</integer>
+  <key>RunAtLoad</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_PATH}</string>
+</dict>
+</plist>
+`;
+}
+
+/**
+ * Generates a crontab entry string for daily auto-update at 4am.
+ * @param {string} scriptPath - Absolute path to the update shell script.
+ * @returns {string} A single crontab line.
+ */
+export function generateCronEntry(scriptPath) {
+  return `0 4 * * * ${scriptPath}`;
+}
+
+/**
+ * Generates a bash update script that runs `claude update` and
+ * `npm update -g @openai/codex`, logs output, and writes a timestamp.
+ * @returns {string} Bash script content.
+ */
+export function generateUpdateScript() {
+  return `#!/usr/bin/env bash
+set -euo pipefail
+
+TLC_DIR="$HOME/.tlc"
+LOG_DIR="$TLC_DIR/logs"
+LOG_FILE="$LOG_DIR/autoupdate.log"
+TIMESTAMP_FILE="$TLC_DIR/.last-update"
+
+mkdir -p "$LOG_DIR"
+
+echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) Starting TLC auto-update" >> "$LOG_FILE"
+
+# Update Claude Code
+if command -v claude &>/dev/null; then
+  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) Running: claude update" >> "$LOG_FILE"
+  claude update >> "$LOG_FILE" 2>&1 || echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) claude update failed" >> "$LOG_FILE"
+fi
+
+# Update Codex CLI
+echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) Running: npm update -g @openai/codex" >> "$LOG_FILE"
+npm update -g @openai/codex >> "$LOG_FILE" 2>&1 || echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) npm update failed" >> "$LOG_FILE"
+
+# Write timestamp
+date -u +%Y-%m-%dT%H:%M:%SZ > "$TIMESTAMP_FILE"
+
+echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) TLC auto-update complete" >> "$LOG_FILE"
+`;
+}
+
+/**
+ * Enables auto-update scheduled job for the current platform.
+ * @param {object} opts
+ * @param {string} opts.platform - 'darwin' or 'linux'
+ * @param {object} opts.fs - fs module (injected for testability)
+ * @param {Function} [opts.execSync] - child_process.execSync (injected for testability)
+ * @returns {{ type: string, scriptPath: string, jobPath?: string }}
+ */
+export function enable({ platform, fs, execSync }) {
+  // Ensure TLC directories exist
+  fs.mkdirSync(TLC_DIR, { recursive: true });
+  fs.mkdirSync(`${TLC_DIR}/logs`, { recursive: true });
+
+  // Write the update script
+  const scriptContent = generateUpdateScript();
+  fs.writeFileSync(SCRIPT_PATH, scriptContent, 'utf8');
+  fs.chmodSync(SCRIPT_PATH, 0o755);
+
+  if (platform === 'darwin') {
+    const launchAgentDir = path.dirname(LAUNCH_AGENT_PLIST);
+    fs.mkdirSync(launchAgentDir, { recursive: true });
+    const plist = generateLaunchdPlist(SCRIPT_PATH);
+    fs.writeFileSync(LAUNCH_AGENT_PLIST, plist, 'utf8');
+    return { type: 'launchd', scriptPath: SCRIPT_PATH, jobPath: LAUNCH_AGENT_PLIST };
+  }
+
+  // Linux — use cron
+  const entry = generateCronEntry(SCRIPT_PATH);
+  let existing = '';
+  try {
+    existing = execSync('crontab -l 2>/dev/null || true', { encoding: 'utf8' });
+  } catch (_) {
+    existing = '';
+  }
+  const newCrontab = existing.trimEnd() + (existing.trim() ? '\n' : '') + entry + '\n';
+  // Write via heredoc to preserve newlines correctly
+  execSync(`crontab - <<'CRONTAB_EOF'\n${newCrontab}CRONTAB_EOF`);
+
+  return { type: 'cron', scriptPath: SCRIPT_PATH };
+}
+
+/**
+ * Disables the auto-update scheduled job.
+ * @param {object} opts
+ * @param {string} opts.platform - 'darwin' or 'linux'
+ * @param {object} opts.fs - fs module (injected for testability)
+ * @param {Function} [opts.execSync] - child_process.execSync (injected for testability)
+ * @returns {{ removed: boolean }}
+ */
+export function disable({ platform, fs, execSync }) {
+  if (platform === 'darwin') {
+    if (fs.existsSync(LAUNCH_AGENT_PLIST)) {
+      fs.unlinkSync(LAUNCH_AGENT_PLIST);
+      return { removed: true };
+    }
+    return { removed: false };
+  }
+
+  // Linux — strip TLC cron entry
+  let existing = '';
+  try {
+    existing = execSync('crontab -l 2>/dev/null || true', { encoding: 'utf8' });
+  } catch (_) {
+    existing = '';
+  }
+  const filtered = existing
+    .split('\n')
+    .filter(line => !line.includes(TLC_DIR) && !line.includes('autoupdate'))
+    .join('\n');
+  const changed = filtered.trim() !== existing.trim();
+  if (changed) {
+    try {
+      const cleanCrontab = filtered.trim() + '\n';
+      execSync(`crontab - <<'CRONTAB_EOF'\n${cleanCrontab}CRONTAB_EOF`);
+    } catch (_) {
+      // best effort
+    }
+  }
+  return { removed: true };
+}
+
+/**
+ * Writes the current ISO timestamp to `{dir}/.last-update`.
+ * @param {object} opts
+ * @param {object} opts.fs - fs module
+ * @param {string} opts.dir - directory path
+ */
+export function writeTimestamp({ fs, dir }) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, TIMESTAMP_FILE), new Date().toISOString(), 'utf8');
+}
+
+/**
+ * Reads the timestamp from `{dir}/.last-update`.
+ * @param {object} opts
+ * @param {object} opts.fs - fs module
+ * @param {string} opts.dir - directory path
+ * @returns {string|null} ISO timestamp string or null if file missing
+ */
+export function readTimestamp({ fs, dir }) {
+  const filePath = path.join(dir, TIMESTAMP_FILE);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  return fs.readFileSync(filePath, 'utf8').trim();
+}
+
+/**
+ * Returns true if the timestamp is null or older than 24 hours.
+ * @param {string|null} timestamp - ISO date string or null
+ * @returns {boolean}
+ */
+export function isStale(timestamp) {
+  if (timestamp === null) return true;
+  const age = Date.now() - new Date(timestamp).getTime();
+  return age > 24 * 60 * 60 * 1000;
+}

package/bin/setup-autoupdate.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  generateLaunchdPlist,
+  generateCronEntry,
+  generateUpdateScript,
+  enable,
+  disable,
+  writeTimestamp,
+  readTimestamp,
+  isStale,
+} from './setup-autoupdate.js';
+
+describe('setup-autoupdate', () => {
+  describe('generateLaunchdPlist', () => {
+    it('returns valid XML plist with daily interval', () => {
+      const plist = generateLaunchdPlist('/path/to/update-script.sh');
+      expect(plist).toContain('<?xml');
+      expect(plist).toContain('com.tlc.autoupdate');
+      expect(plist).toContain('<integer>86400</integer>');
+      expect(plist).toContain('/path/to/update-script.sh');
+    });
+  });
+
+  describe('generateCronEntry', () => {
+    it('returns valid crontab line running at 4am daily', () => {
+      const entry = generateCronEntry('/path/to/update-script.sh');
+      expect(entry).toMatch(/^0 4 \* \* \*/);
+      expect(entry).toContain('/path/to/update-script.sh');
+    });
+  });
+
+  describe('generateUpdateScript', () => {
+    it('includes claude update command', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('claude update');
+    });
+
+    it('includes codex update command', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('npm update -g @openai/codex');
+    });
+
+    it('logs to autoupdate.log', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('autoupdate.log');
+    });
+
+    it('writes timestamp to .last-update', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('.last-update');
+    });
+  });
+
+  describe('enable', () => {
+    it('creates launchd plist on macOS', () => {
+      const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn(), existsSync: vi.fn(() => false), chmodSync: vi.fn() };
+      const result = enable({ platform: 'darwin', fs });
+      expect(result.type).toBe('launchd');
+      expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+
+    it('creates cron entry on Linux', () => {
+      const execSync = vi.fn(() => '');
+      const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn(), existsSync: vi.fn(() => false), chmodSync: vi.fn() };
+      const result = enable({ platform: 'linux', fs, execSync });
+      expect(result.type).toBe('cron');
+    });
+  });
+
+  describe('disable', () => {
+    it('removes launchd plist on macOS', () => {
+      const fs = { unlinkSync: vi.fn(), existsSync: vi.fn(() => true) };
+      const result = disable({ platform: 'darwin', fs });
+      expect(result.removed).toBe(true);
+      expect(fs.unlinkSync).toHaveBeenCalled();
+    });
+
+    it('removes cron entry on Linux', () => {
+      const execSync = vi.fn(() => '0 4 * * * /path/to/script\nother job');
+      const fs = { existsSync: vi.fn(() => false) };
+      const result = disable({ platform: 'linux', fs, execSync });
+      expect(result.removed).toBe(true);
+    });
+  });
+
+  describe('writeTimestamp / readTimestamp', () => {
+    it('writes ISO timestamp to .last-update', () => {
+      const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn() };
+      writeTimestamp({ fs, dir: '/tmp/tlc' });
+      const args = fs.writeFileSync.mock.calls[0];
+      expect(args[0]).toContain('.last-update');
+      expect(args[1]).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+
+    it('reads timestamp from .last-update', () => {
+      const now = new Date().toISOString();
+      const fs = { readFileSync: vi.fn(() => now), existsSync: vi.fn(() => true) };
+      const ts = readTimestamp({ fs, dir: '/tmp/tlc' });
+      expect(ts).toBe(now);
+    });
+
+    it('returns null when file missing', () => {
+      const fs = { existsSync: vi.fn(() => false) };
+      const ts = readTimestamp({ fs, dir: '/tmp/tlc' });
+      expect(ts).toBeNull();
+    });
+  });
+
+  describe('isStale', () => {
+    it('returns false for fresh timestamp (<24h)', () => {
+      const recent = new Date(Date.now() - 3600_000).toISOString(); // 1h ago
+      expect(isStale(recent)).toBe(false);
+    });
+
+    it('returns true for stale timestamp (>24h)', () => {
+      const old = new Date(Date.now() - 90_000_000).toISOString(); // 25h ago
+      expect(isStale(old)).toBe(true);
+    });
+
+    it('returns true for null timestamp', () => {
+      expect(isStale(null)).toBe(true);
+    });
+  });
+});

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "tlc-claude-code",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
-    "tlc": "./bin/tlc.js",
     "tlc-claude-code": "./bin/install.js",
     "tlc-docs": "./scripts/project-docs.js"
   },
   "files": [
     "bin/",
+    ".claude/agents/",
     ".claude/commands/",
     ".claude/hooks/",
     "dashboard/dist/",

package/scripts/project-docs.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * Project Documentation Maintenance
  *