lean-spec 0.2.0 → 0.2.1

package/dist/{chunk-J7ZSZ5VJ.js → chunk-ER23B6KS.js}

@@ -1,23 +1,24 @@
-import {
-  getSpecFile,
-  matchesFilter,
-  normalizeDateFields,
-  parseFrontmatter,
-  updateFrontmatter
-} from "./chunk-S4YNQ5KE.js";
+import { normalizeDateFields, getSpecFile, updateFrontmatter, parseFrontmatter, matchesFilter } from './chunk-LVD7ZAVZ.js';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import * as fs9 from 'fs/promises';
+import * as path2 from 'path';
+import { dirname, join } from 'path';
+import chalk16 from 'chalk';
+import matter from 'gray-matter';
+import yaml from 'js-yaml';
+import { spawn, execSync } from 'child_process';
+import ora from 'ora';
+import stripAnsi from 'strip-ansi';
+import { fileURLToPath } from 'url';
+import { select } from '@inquirer/prompts';
+import { ComplexityValidator, TokenCounter, countTokens } from '@leanspec/core';
+import dayjs2 from 'dayjs';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { readFileSync } from 'fs';
 
-// src/mcp-server.ts
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport as StdioServerTransport2 } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// src/spec-loader.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
-
-// src/config.ts
-import * as fs from "fs/promises";
-import * as path from "path";
 var DEFAULT_CONFIG = {
   template: "spec-template.md",
   templates: {
@@ -39,9 +40,9 @@ var DEFAULT_CONFIG = {
   }
 };
 async function loadConfig(cwd = process.cwd()) {
-  const configPath = path.join(cwd, ".lean-spec", "config.json");
+  const configPath = path2.join(cwd, ".lean-spec", "config.json");
   try {
-    const content = await fs.readFile(configPath, "utf-8");
+    const content = await fs9.readFile(configPath, "utf-8");
     const userConfig = JSON.parse(content);
     const merged = { ...DEFAULT_CONFIG, ...userConfig };
     normalizeLegacyPattern(merged);
@@ -51,10 +52,10 @@ async function loadConfig(cwd = process.cwd()) {
   }
 }
 async function saveConfig(config, cwd = process.cwd()) {
-  const configDir = path.join(cwd, ".lean-spec");
-  const configPath = path.join(configDir, "config.json");
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+  const configDir = path2.join(cwd, ".lean-spec");
+  const configPath = path2.join(configDir, "config.json");
+  await fs9.mkdir(configDir, { recursive: true });
+  await fs9.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
 }
 function getToday(format = "YYYYMMDD") {
   const now = /* @__PURE__ */ new Date();
@@ -136,12 +137,12 @@ function extractGroup(extractor, dateFormat = "YYYYMMDD", fields, fallback) {
 async function loadSubFiles(specDir, options = {}) {
   const subFiles = [];
   try {
-    const entries = await fs2.readdir(specDir, { withFileTypes: true });
+    const entries = await fs9.readdir(specDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === "README.md") continue;
       if (entry.isDirectory()) continue;
       const filePath = path2.join(specDir, entry.name);
-      const stat5 = await fs2.stat(filePath);
+      const stat5 = await fs9.stat(filePath);
       const ext = path2.extname(entry.name).toLowerCase();
       const isDocument = ext === ".md";
       const subFile = {
@@ -151,7 +152,7 @@ async function loadSubFiles(specDir, options = {}) {
         type: isDocument ? "document" : "asset"
       };
       if (isDocument && options.includeContent) {
-        subFile.content = await fs2.readFile(filePath, "utf-8");
+        subFile.content = await fs9.readFile(filePath, "utf-8");
       }
       subFiles.push(subFile);
     }
@@ -171,14 +172,14 @@ async function loadAllSpecs(options = {}) {
   const specsDir = path2.join(cwd, config.specsDir);
   const specs = [];
   try {
-    await fs2.access(specsDir);
+    await fs9.access(specsDir);
   } catch {
     return [];
   }
   const specPattern = /^(\d{2,})-/;
   async function loadSpecsFromDir(dir, relativePath = "") {
     try {
-      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      const entries = await fs9.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name === "archived" && relativePath === "") continue;
@@ -212,7 +213,7 @@ async function loadAllSpecs(options = {}) {
                 frontmatter
               };
               if (options.includeContent) {
-                specInfo.content = await fs2.readFile(specFile, "utf-8");
+                specInfo.content = await fs9.readFile(specFile, "utf-8");
               }
               if (options.includeSubFiles) {
                 specInfo.subFiles = await loadSubFiles(entryPath, {
@@ -287,7 +288,7 @@ async function getSpec(specPath) {
     fullPath = path2.join(specsDir, specPath);
   }
   try {
-    await fs2.access(fullPath);
+    await fs9.access(fullPath);
   } catch {
     return null;
   }
@@ -295,7 +296,7 @@ async function getSpec(specPath) {
   if (!specFile) return null;
   const frontmatter = await parseFrontmatter(specFile, config);
   if (!frontmatter) return null;
-  const content = await fs2.readFile(specFile, "utf-8");
+  const content = await fs9.readFile(specFile, "utf-8");
   const relativePath = path2.relative(specsDir, fullPath);
   const parts = relativePath.split(path2.sep);
   const date = parts[0] === "archived" ? parts[1] : parts[0];
@@ -310,17 +311,6 @@ async function getSpec(specPath) {
     content
   };
 }
-
-// src/commands/create.ts
-import * as fs5 from "fs/promises";
-import * as path6 from "path";
-import chalk4 from "chalk";
-import matter from "gray-matter";
-import yaml from "js-yaml";
-
-// src/utils/path-helpers.ts
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
 function createSpecDirPattern() {
   return /(?:^|\D)(\d{2,4})-[a-z]/i;
 }
@@ -330,7 +320,7 @@ async function getGlobalNextSeq(specsDir, digits) {
     const specPattern = createSpecDirPattern();
     async function scanDirectory(dir) {
       try {
-        const entries = await fs3.readdir(dir, { withFileTypes: true });
+        const entries = await fs9.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
           const match = entry.name.match(specPattern);
@@ -341,7 +331,7 @@ async function getGlobalNextSeq(specsDir, digits) {
             }
           }
           if (entry.name === "archived") continue;
-          const subDir = path3.join(dir, entry.name);
+          const subDir = path2.join(dir, entry.name);
           await scanDirectory(subDir);
         }
       } catch {
@@ -358,23 +348,23 @@ async function getGlobalNextSeq(specsDir, digits) {
   }
 }
 async function resolveSpecPath(specPath, cwd, specsDir) {
-  if (path3.isAbsolute(specPath)) {
+  if (path2.isAbsolute(specPath)) {
     try {
-      await fs3.access(specPath);
+      await fs9.access(specPath);
       return specPath;
     } catch {
       return null;
     }
   }
-  const cwdPath = path3.resolve(cwd, specPath);
+  const cwdPath = path2.resolve(cwd, specPath);
   try {
-    await fs3.access(cwdPath);
+    await fs9.access(cwdPath);
     return cwdPath;
   } catch {
   }
-  const specsPath = path3.join(specsDir, specPath);
+  const specsPath = path2.join(specsDir, specPath);
   try {
-    await fs3.access(specsPath);
+    await fs9.access(specsPath);
     return specsPath;
   } catch {
   }
@@ -392,17 +382,17 @@ async function searchBySequence(specsDir, seqNum) {
   const specPattern = createSpecDirPattern();
   async function scanDirectory(dir) {
     try {
-      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      const entries = await fs9.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const match = entry.name.match(specPattern);
         if (match) {
           const entrySeq = parseInt(match[1], 10);
           if (entrySeq === seqNum) {
-            return path3.join(dir, entry.name);
+            return path2.join(dir, entry.name);
           }
         }
-        const subDir = path3.join(dir, entry.name);
+        const subDir = path2.join(dir, entry.name);
         const result = await scanDirectory(subDir);
         if (result) return result;
       }
@@ -415,13 +405,13 @@ async function searchBySequence(specsDir, seqNum) {
 async function searchInAllDirectories(specsDir, specName) {
   async function scanDirectory(dir) {
     try {
-      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      const entries = await fs9.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name === specName) {
-          return path3.join(dir, entry.name);
+          return path2.join(dir, entry.name);
         }
-        const subDir = path3.join(dir, entry.name);
+        const subDir = path2.join(dir, entry.name);
         const result = await scanDirectory(subDir);
         if (result) return result;
       }
@@ -431,11 +421,6 @@ async function searchInAllDirectories(specsDir, specName) {
   }
   return scanDirectory(specsDir);
 }
-
-// src/utils/variable-resolver.ts
-import * as fs4 from "fs/promises";
-import * as path4 from "path";
-import { execSync } from "child_process";
 async function getGitInfo() {
   try {
     const user = execSync("git config user.name", { encoding: "utf-8" }).trim();
@@ -457,8 +442,8 @@ async function getGitInfo() {
 }
 async function getProjectName(cwd = process.cwd()) {
   try {
-    const packageJsonPath = path4.join(cwd, "package.json");
-    const content = await fs4.readFile(packageJsonPath, "utf-8");
+    const packageJsonPath = path2.join(cwd, "package.json");
+    const content = await fs9.readFile(packageJsonPath, "utf-8");
     const packageJson2 = JSON.parse(content);
     return packageJson2.name || null;
   } catch {
@@ -539,18 +524,6 @@ async function buildVariableContext(config, options = {}) {
   context.gitInfo = await getGitInfo() ?? void 0;
   return context;
 }
-
-// src/commands/check.ts
-import * as path5 from "path";
-import chalk3 from "chalk";
-
-// src/utils/ui.ts
-import ora from "ora";
-import chalk2 from "chalk";
-
-// src/utils/safe-output.ts
-import chalk from "chalk";
-import stripAnsi from "strip-ansi";
 function sanitizeUserInput(input) {
   if (typeof input !== "string") {
     return "";
@@ -571,7 +544,7 @@ async function withSpinner(text, fn, options) {
     spinner.succeed(options?.successText || text);
     return result;
   } catch (error) {
-    spinner.fail(options?.failText || `${text} failed`);
+    spinner.fail(`${text} failed`);
     throw error;
   }
 }
@@ -580,12 +553,12 @@ async function withSpinner(text, fn, options) {
 async function checkSpecs(options = {}) {
   const config = await loadConfig();
   const cwd = process.cwd();
-  const specsDir = path5.join(cwd, config.specsDir);
+  path2.join(cwd, config.specsDir);
   const specs = await loadAllSpecs();
   const sequenceMap = /* @__PURE__ */ new Map();
   const specPattern = createSpecDirPattern();
   for (const spec of specs) {
-    const specName = path5.basename(spec.path);
+    const specName = path2.basename(spec.path);
     const match = specName.match(specPattern);
     if (match) {
       const seq = parseInt(match[1], 10);
@@ -600,30 +573,30 @@ async function checkSpecs(options = {}) {
   const conflicts = Array.from(sequenceMap.entries()).filter(([_, paths]) => paths.length > 1).sort(([a], [b]) => a - b);
   if (conflicts.length === 0) {
     if (!options.quiet && !options.silent) {
-      console.log(chalk3.green("\u2713 No sequence conflicts detected"));
+      console.log(chalk16.green("\u2713 No sequence conflicts detected"));
     }
     return true;
   }
   if (!options.silent) {
     if (!options.quiet) {
       console.log("");
-      console.log(chalk3.yellow("\u26A0\uFE0F  Sequence conflicts detected:\n"));
+      console.log(chalk16.yellow("\u26A0\uFE0F  Sequence conflicts detected:\n"));
       for (const [seq, paths] of conflicts) {
-        console.log(chalk3.red(`  Sequence ${String(seq).padStart(config.structure.sequenceDigits, "0")}:`));
+        console.log(chalk16.red(`  Sequence ${String(seq).padStart(config.structure.sequenceDigits, "0")}:`));
         for (const p of paths) {
-          console.log(chalk3.gray(`    - ${sanitizeUserInput(p)}`));
+          console.log(chalk16.gray(`    - ${sanitizeUserInput(p)}`));
         }
         console.log("");
       }
-      console.log(chalk3.cyan("Tip: Use date prefix to prevent conflicts:"));
-      console.log(chalk3.gray('  Edit .lean-spec/config.json \u2192 structure.prefix: "{YYYYMMDD}-"'));
+      console.log(chalk16.cyan("Tip: Use date prefix to prevent conflicts:"));
+      console.log(chalk16.gray('  Edit .lean-spec/config.json \u2192 structure.prefix: "{YYYYMMDD}-"'));
       console.log("");
-      console.log(chalk3.cyan("Or rename folders manually to resolve."));
+      console.log(chalk16.cyan("Or rename folders manually to resolve."));
       console.log("");
     } else {
       console.log("");
-      console.log(chalk3.yellow(`\u26A0\uFE0F  Conflict warning: ${conflicts.length} sequence conflict(s) detected`));
-      console.log(chalk3.gray("Run: lean-spec check"));
+      console.log(chalk16.yellow(`\u26A0\uFE0F  Conflict warning: ${conflicts.length} sequence conflict(s) detected`));
+      console.log(chalk16.gray("Run: lean-spec check"));
       console.log("");
     }
   }
@@ -644,8 +617,8 @@ async function autoCheckIfEnabled() {
 async function createSpec(name, options = {}) {
   const config = await loadConfig();
   const cwd = process.cwd();
-  const specsDir = path6.join(cwd, config.specsDir);
-  await fs5.mkdir(specsDir, { recursive: true });
+  const specsDir = path2.join(cwd, config.specsDir);
+  await fs9.mkdir(specsDir, { recursive: true });
   const seq = await getGlobalNextSeq(specsDir, config.structure.sequenceDigits);
   let specRelativePath;
   if (config.structure.pattern === "flat") {
@@ -665,19 +638,18 @@ async function createSpec(name, options = {}) {
   } else {
     throw new Error(`Unknown pattern: ${config.structure.pattern}`);
   }
-  const specDir = path6.join(specsDir, specRelativePath);
-  const specFile = path6.join(specDir, config.structure.defaultFile);
+  const specDir = path2.join(specsDir, specRelativePath);
+  const specFile = path2.join(specDir, config.structure.defaultFile);
   try {
-    await fs5.access(specDir);
+    await fs9.access(specDir);
     throw new Error(`Spec already exists: ${sanitizeUserInput(specDir)}`);
   } catch (error) {
-    if (error.code === "ENOENT") {
-    } else {
+    if (error.code === "ENOENT") ; else {
       throw error;
     }
   }
-  await fs5.mkdir(specDir, { recursive: true });
-  const templatesDir = path6.join(cwd, ".lean-spec", "templates");
+  await fs9.mkdir(specDir, { recursive: true });
+  const templatesDir = path2.join(cwd, ".lean-spec", "templates");
   let templateName;
   if (options.template) {
     if (config.templates?.[options.template]) {
@@ -689,10 +661,10 @@ async function createSpec(name, options = {}) {
   } else {
     templateName = config.template || "spec-template.md";
   }
-  const templatePath = path6.join(templatesDir, templateName);
+  const templatePath = path2.join(templatesDir, templateName);
   let content;
   try {
-    const template = await fs5.readFile(templatePath, "utf-8");
+    const template = await fs9.readFile(templatePath, "utf-8");
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const title = options.title || name;
     const varContext = await buildVariableContext(config, { name: title, date });
@@ -722,7 +694,7 @@ async function createSpec(name, options = {}) {
       frontmatter: parsed.data
     };
     parsed.content = resolveVariables(parsed.content, contextWithFrontmatter);
-    const { enrichWithTimestamps } = await import("./frontmatter-26SOQGYM.js");
+    const { enrichWithTimestamps } = await import('./frontmatter-R2DANL5X.js');
     enrichWithTimestamps(parsed.data);
     content = matter.stringify(parsed.content, parsed.data);
     if (options.description) {
@@ -736,21 +708,16 @@ ${options.description}`
   } catch (error) {
     throw new Error(`Template not found: ${templatePath}. Run: lean-spec init`);
   }
-  await fs5.writeFile(specFile, content, "utf-8");
-  console.log(chalk4.green(`\u2713 Created: ${sanitizeUserInput(specDir)}/`));
-  console.log(chalk4.gray(`  Edit: ${sanitizeUserInput(specFile)}`));
+  await fs9.writeFile(specFile, content, "utf-8");
+  console.log(chalk16.green(`\u2713 Created: ${sanitizeUserInput(specDir)}/`));
+  console.log(chalk16.gray(`  Edit: ${sanitizeUserInput(specFile)}`));
   await autoCheckIfEnabled();
 }
-
-// src/commands/archive.ts
-import * as fs6 from "fs/promises";
-import * as path7 from "path";
-import chalk5 from "chalk";
 async function archiveSpec(specPath) {
   await autoCheckIfEnabled();
   const config = await loadConfig();
   const cwd = process.cwd();
-  const specsDir = path7.join(cwd, config.specsDir);
+  const specsDir = path2.join(cwd, config.specsDir);
   const resolvedPath = await resolveSpecPath(specPath, cwd, specsDir);
   if (!resolvedPath) {
     throw new Error(`Spec not found: ${sanitizeUserInput(specPath)}`);
@@ -759,19 +726,14 @@ async function archiveSpec(specPath) {
   if (specFile) {
     await updateFrontmatter(specFile, { status: "archived" });
   }
-  const archiveDir = path7.join(specsDir, "archived");
-  await fs6.mkdir(archiveDir, { recursive: true });
-  const specName = path7.basename(resolvedPath);
-  const archivePath = path7.join(archiveDir, specName);
-  await fs6.rename(resolvedPath, archivePath);
-  console.log(chalk5.green(`\u2713 Archived: ${sanitizeUserInput(archivePath)}`));
+  const archiveDir = path2.join(specsDir, "archived");
+  await fs9.mkdir(archiveDir, { recursive: true });
+  const specName = path2.basename(resolvedPath);
+  const archivePath = path2.join(archiveDir, specName);
+  await fs9.rename(resolvedPath, archivePath);
+  console.log(chalk16.green(`\u2713 Archived: ${sanitizeUserInput(archivePath)}`));
 }
 
-// src/commands/list.ts
-import chalk7 from "chalk";
-import * as fs7 from "fs/promises";
-import * as path8 from "path";
-
 // src/utils/pattern-detection.ts
 function detectPatternType(config) {
   const { pattern, groupExtractor } = config.structure;
@@ -795,66 +757,63 @@ function detectPatternType(config) {
     shouldGroup: false
   };
 }
-
-// src/utils/colors.ts
-import chalk6 from "chalk";
 var STATUS_CONFIG = {
   planned: {
     emoji: "\u{1F4C5}",
     label: "Planned",
-    colorFn: chalk6.blue,
-    badge: (s = "planned") => chalk6.blue(`[${s}]`)
+    colorFn: chalk16.blue,
+    badge: (s = "planned") => chalk16.blue(`[${s}]`)
   },
   "in-progress": {
     emoji: "\u23F3",
     label: "In Progress",
-    colorFn: chalk6.yellow,
-    badge: (s = "in-progress") => chalk6.yellow(`[${s}]`)
+    colorFn: chalk16.yellow,
+    badge: (s = "in-progress") => chalk16.yellow(`[${s}]`)
   },
   complete: {
     emoji: "\u2705",
     label: "Complete",
-    colorFn: chalk6.green,
-    badge: (s = "complete") => chalk6.green(`[${s}]`)
+    colorFn: chalk16.green,
+    badge: (s = "complete") => chalk16.green(`[${s}]`)
   },
   archived: {
     emoji: "\u{1F4E6}",
     label: "Archived",
-    colorFn: chalk6.gray,
-    badge: (s = "archived") => chalk6.gray(`[${s}]`)
+    colorFn: chalk16.gray,
+    badge: (s = "archived") => chalk16.gray(`[${s}]`)
   }
 };
 var PRIORITY_CONFIG = {
   critical: {
     emoji: "\u{1F534}",
-    colorFn: chalk6.red.bold,
-    badge: (s = "critical") => chalk6.red.bold(`[${s}]`)
+    colorFn: chalk16.red.bold,
+    badge: (s = "critical") => chalk16.red.bold(`[${s}]`)
   },
   high: {
     emoji: "\u{1F7E0}",
-    colorFn: chalk6.hex("#FFA500"),
-    badge: (s = "high") => chalk6.hex("#FFA500")(`[${s}]`)
+    colorFn: chalk16.hex("#FFA500"),
+    badge: (s = "high") => chalk16.hex("#FFA500")(`[${s}]`)
   },
   medium: {
     emoji: "\u{1F7E1}",
-    colorFn: chalk6.yellow,
-    badge: (s = "medium") => chalk6.yellow(`[${s}]`)
+    colorFn: chalk16.yellow,
+    badge: (s = "medium") => chalk16.yellow(`[${s}]`)
   },
   low: {
     emoji: "\u{1F7E2}",
-    colorFn: chalk6.gray,
-    badge: (s = "low") => chalk6.gray(`[${s}]`)
+    colorFn: chalk16.gray,
+    badge: (s = "low") => chalk16.gray(`[${s}]`)
   }
 };
 function formatStatusBadge(status) {
-  return STATUS_CONFIG[status]?.badge() || chalk6.white(`[${status}]`);
+  return STATUS_CONFIG[status]?.badge() || chalk16.white(`[${status}]`);
 }
 function formatPriorityBadge(priority) {
-  return PRIORITY_CONFIG[priority]?.badge() || chalk6.white(`[${priority}]`);
+  return PRIORITY_CONFIG[priority]?.badge() || chalk16.white(`[${priority}]`);
 }
 function getStatusIndicator(status) {
   const config = STATUS_CONFIG[status];
-  if (!config) return chalk6.gray("[unknown]");
+  if (!config) return chalk16.gray("[unknown]");
   return config.colorFn(`[${status}]`);
 }
 function getStatusEmoji(status) {
@@ -869,9 +828,9 @@ async function listSpecs(options = {}) {
   await autoCheckIfEnabled();
   const config = await loadConfig();
   const cwd = process.cwd();
-  const specsDir = path8.join(cwd, config.specsDir);
+  const specsDir = path2.join(cwd, config.specsDir);
   try {
-    await fs7.access(specsDir);
+    await fs9.access(specsDir);
   } catch {
     console.log("");
     console.log("No specs directory found. Initialize with: lean-spec init");
@@ -894,10 +853,10 @@ async function listSpecs(options = {}) {
     })
   );
   if (specs.length === 0) {
-    console.log(chalk7.dim("No specs found."));
+    console.log(chalk16.dim("No specs found."));
     return;
   }
-  console.log(chalk7.bold.cyan("\u{1F4C4} Spec List"));
+  console.log(chalk16.bold.cyan("\u{1F4C4} Spec List"));
   const filterParts = [];
   if (options.status) {
     const statusStr = Array.isArray(options.status) ? options.status.join(",") : options.status;
@@ -910,7 +869,7 @@ async function listSpecs(options = {}) {
   }
   if (options.assignee) filterParts.push(`assignee=${options.assignee}`);
   if (filterParts.length > 0) {
-    console.log(chalk7.dim(`Filtered by: ${filterParts.join(", ")}`));
+    console.log(chalk16.dim(`Filtered by: ${filterParts.join(", ")}`));
   }
   console.log("");
   const patternInfo = detectPatternType(config);
@@ -920,7 +879,7 @@ async function listSpecs(options = {}) {
     renderFlatList(specs);
   }
   console.log("");
-  console.log(chalk7.bold(`Total: ${chalk7.green(specs.length)} spec${specs.length !== 1 ? "s" : ""}`));
+  console.log(chalk16.bold(`Total: ${chalk16.green(specs.length)} spec${specs.length !== 1 ? "s" : ""}`));
 }
 function renderFlatList(specs) {
   for (const spec of specs) {
@@ -928,18 +887,18 @@ function renderFlatList(specs) {
     const priorityEmoji = getPriorityEmoji(spec.frontmatter.priority);
     let assigneeStr = "";
     if (spec.frontmatter.assignee) {
-      assigneeStr = " " + chalk7.cyan(`@${sanitizeUserInput(spec.frontmatter.assignee)}`);
+      assigneeStr = " " + chalk16.cyan(`@${sanitizeUserInput(spec.frontmatter.assignee)}`);
     }
     let tagsStr = "";
     if (spec.frontmatter.tags?.length) {
       const tags = Array.isArray(spec.frontmatter.tags) ? spec.frontmatter.tags : [];
       if (tags.length > 0) {
         const tagStr = tags.map((tag) => `#${sanitizeUserInput(tag)}`).join(" ");
-        tagsStr = " " + chalk7.dim(chalk7.magenta(tagStr));
+        tagsStr = " " + chalk16.dim(chalk16.magenta(tagStr));
       }
     }
     const priorityPrefix = priorityEmoji ? `${priorityEmoji} ` : "";
-    console.log(`${priorityPrefix}${statusEmoji} ${chalk7.cyan(sanitizeUserInput(spec.path))}${assigneeStr}${tagsStr}`);
+    console.log(`${priorityPrefix}${statusEmoji} ${chalk16.cyan(sanitizeUserInput(spec.path))}${assigneeStr}${tagsStr}`);
   }
 }
 function renderGroupedList(specs, groupExtractor) {
@@ -968,7 +927,7 @@ function renderGroupedList(specs, groupExtractor) {
     const groupName = sortedGroups[i];
     const groupSpecs = groups.get(groupName);
     const groupEmoji = /^\d{8}$/.test(groupName) ? "\u{1F4C5}" : groupName.startsWith("milestone") ? "\u{1F3AF}" : "\u{1F4C1}";
-    console.log(`${chalk7.bold.cyan(`${groupEmoji} ${groupName}/`)} ${chalk7.dim(`(${groupSpecs.length})`)}`);
+    console.log(`${chalk16.bold.cyan(`${groupEmoji} ${groupName}/`)} ${chalk16.dim(`(${groupSpecs.length})`)}`);
     console.log("");
     for (const spec of groupSpecs) {
       const statusEmoji = getStatusEmoji(spec.frontmatter.status);
@@ -976,33 +935,29 @@ function renderGroupedList(specs, groupExtractor) {
       const displayPath = spec.path.includes("/") ? spec.path.split("/").slice(1).join("/") : spec.path;
       let assigneeStr = "";
       if (spec.frontmatter.assignee) {
-        assigneeStr = " " + chalk7.cyan(`@${sanitizeUserInput(spec.frontmatter.assignee)}`);
+        assigneeStr = " " + chalk16.cyan(`@${sanitizeUserInput(spec.frontmatter.assignee)}`);
       }
       let tagsStr = "";
       if (spec.frontmatter.tags?.length) {
         const tags = Array.isArray(spec.frontmatter.tags) ? spec.frontmatter.tags : [];
         if (tags.length > 0) {
           const tagStr = tags.map((tag) => `#${sanitizeUserInput(tag)}`).join(" ");
-          tagsStr = " " + chalk7.dim(chalk7.magenta(tagStr));
+          tagsStr = " " + chalk16.dim(chalk16.magenta(tagStr));
         }
       }
       const priorityPrefix = priorityEmoji ? `${priorityEmoji} ` : "";
-      console.log(`  ${priorityPrefix}${statusEmoji} ${chalk7.cyan(sanitizeUserInput(displayPath))}${assigneeStr}${tagsStr}`);
+      console.log(`  ${priorityPrefix}${statusEmoji} ${chalk16.cyan(sanitizeUserInput(displayPath))}${assigneeStr}${tagsStr}`);
     }
     if (i < sortedGroups.length - 1) {
       console.log("");
     }
   }
 }
-
-// src/commands/update.ts
-import * as path9 from "path";
-import chalk8 from "chalk";
 async function updateSpec(specPath, updates) {
   await autoCheckIfEnabled();
   const config = await loadConfig();
   const cwd = process.cwd();
-  const specsDir = path9.join(cwd, config.specsDir);
+  const specsDir = path2.join(cwd, config.specsDir);
   const resolvedPath = await resolveSpecPath(specPath, cwd, specsDir);
   if (!resolvedPath) {
     throw new Error(`Spec not found: ${sanitizeUserInput(specPath)}. Tried: ${sanitizeUserInput(specPath)}, specs/${sanitizeUserInput(specPath)}, and searching in date directories`);
@@ -1024,22 +979,16 @@ async function updateSpec(specPath, updates) {
     });
   }
   await updateFrontmatter(specFile, allUpdates);
-  console.log(chalk8.green(`\u2713 Updated: ${sanitizeUserInput(path9.relative(cwd, resolvedPath))}`));
+  console.log(chalk16.green(`\u2713 Updated: ${sanitizeUserInput(path2.relative(cwd, resolvedPath))}`));
   const updatedFields = Object.keys(updates).filter((k) => k !== "customFields");
   if (updates.customFields) {
     updatedFields.push(...Object.keys(updates.customFields));
   }
-  console.log(chalk8.gray(`  Fields: ${updatedFields.join(", ")}`));
+  console.log(chalk16.gray(`  Fields: ${updatedFields.join(", ")}`));
 }
-
-// src/commands/backfill.ts
-import * as path10 from "path";
-
-// src/utils/git-timestamps.ts
-import { execSync as execSync2 } from "child_process";
 function isGitRepository() {
   try {
-    execSync2("git rev-parse --is-inside-work-tree", {
+    execSync("git rev-parse --is-inside-work-tree", {
       stdio: "ignore",
       encoding: "utf-8"
     });
@@ -1050,7 +999,7 @@ function isGitRepository() {
 }
 function getFirstCommitTimestamp(filePath) {
   try {
-    const timestamp = execSync2(
+    const timestamp = execSync(
       `git log --follow --format="%aI" --diff-filter=A -- "${filePath}" | tail -1`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
     ).trim();
@@ -1061,7 +1010,7 @@ function getFirstCommitTimestamp(filePath) {
 }
 function getLastCommitTimestamp(filePath) {
   try {
-    const timestamp = execSync2(
+    const timestamp = execSync(
       `git log --format="%aI" -n 1 -- "${filePath}"`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
     ).trim();
@@ -1072,7 +1021,7 @@ function getLastCommitTimestamp(filePath) {
 }
 function getCompletionTimestamp(filePath) {
   try {
-    const gitLog = execSync2(
+    const gitLog = execSync(
       `git log --format="%H|%aI" -p -- "${filePath}"`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
     );
@@ -1093,7 +1042,7 @@ function getCompletionTimestamp(filePath) {
 }
 function getFirstCommitAuthor(filePath) {
   try {
-    const author = execSync2(
+    const author = execSync(
       `git log --follow --format="%an" --diff-filter=A -- "${filePath}" | tail -1`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
     ).trim();
@@ -1105,7 +1054,7 @@ function getFirstCommitAuthor(filePath) {
 function parseStatusTransitions(filePath) {
   const transitions = [];
   try {
-    const gitLog = execSync2(
+    const gitLog = execSync(
       `git log --format="%H|%aI" -p --reverse -- "${filePath}"`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
     );
@@ -1153,7 +1102,7 @@ function extractGitTimestamps(filePath, options = {}) {
 }
 function fileExistsInGit(filePath) {
   try {
-    execSync2(
+    execSync(
       `git log -n 1 -- "${filePath}"`,
       { stdio: "ignore", encoding: "utf-8" }
     );
@@ -1176,7 +1125,7 @@ async function backfillTimestamps(options = {}) {
     specs = [];
     const config = await loadConfig();
     const cwd = process.cwd();
-    const specsDir = path10.join(cwd, config.specsDir);
+    const specsDir = path2.join(cwd, config.specsDir);
     for (const specPath of options.specs) {
       const resolved = await resolveSpecPath(specPath, cwd, specsDir);
       if (!resolved) {
@@ -1348,86 +1297,81 @@ function printSummary(results, options) {
     console.log("  Run \x1B[36mlspec stats\x1B[0m to see velocity metrics");
   }
 }
-
-// src/commands/templates.ts
-import * as fs8 from "fs/promises";
-import * as path11 from "path";
-import chalk9 from "chalk";
 async function listTemplates(cwd = process.cwd()) {
   const config = await loadConfig(cwd);
-  const templatesDir = path11.join(cwd, ".lean-spec", "templates");
+  const templatesDir = path2.join(cwd, ".lean-spec", "templates");
   console.log("");
-  console.log(chalk9.green("=== Project Templates ==="));
+  console.log(chalk16.green("=== Project Templates ==="));
   console.log("");
   try {
-    await fs8.access(templatesDir);
+    await fs9.access(templatesDir);
   } catch {
-    console.log(chalk9.yellow("No templates directory found."));
-    console.log(chalk9.gray("Run: lean-spec init"));
+    console.log(chalk16.yellow("No templates directory found."));
+    console.log(chalk16.gray("Run: lean-spec init"));
     console.log("");
     return;
   }
-  const files = await fs8.readdir(templatesDir);
+  const files = await fs9.readdir(templatesDir);
   const templateFiles = files.filter((f) => f.endsWith(".md"));
   if (templateFiles.length === 0) {
-    console.log(chalk9.yellow("No templates found."));
+    console.log(chalk16.yellow("No templates found."));
     console.log("");
     return;
   }
   if (config.templates && Object.keys(config.templates).length > 0) {
-    console.log(chalk9.cyan("Registered:"));
+    console.log(chalk16.cyan("Registered:"));
     for (const [name, file] of Object.entries(config.templates)) {
       const isDefault = config.template === file;
-      const marker = isDefault ? chalk9.green("\u2713 (default)") : "";
-      console.log(`  ${chalk9.bold(name)}: ${file} ${marker}`);
+      const marker = isDefault ? chalk16.green("\u2713 (default)") : "";
+      console.log(`  ${chalk16.bold(name)}: ${file} ${marker}`);
     }
     console.log("");
   }
-  console.log(chalk9.cyan("Available files:"));
+  console.log(chalk16.cyan("Available files:"));
   for (const file of templateFiles) {
-    const filePath = path11.join(templatesDir, file);
-    const stat5 = await fs8.stat(filePath);
+    const filePath = path2.join(templatesDir, file);
+    const stat5 = await fs9.stat(filePath);
     const sizeKB = (stat5.size / 1024).toFixed(1);
     console.log(`  ${file} (${sizeKB} KB)`);
   }
   console.log("");
-  console.log(chalk9.gray("Use templates with: lean-spec create <name> --template=<template-name>"));
+  console.log(chalk16.gray("Use templates with: lean-spec create <name> --template=<template-name>"));
   console.log("");
 }
 async function showTemplate(templateName, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
   if (!config.templates?.[templateName]) {
-    console.error(chalk9.red(`Template not found: ${templateName}`));
-    console.error(chalk9.gray(`Available: ${Object.keys(config.templates || {}).join(", ")}`));
+    console.error(chalk16.red(`Template not found: ${templateName}`));
+    console.error(chalk16.gray(`Available: ${Object.keys(config.templates || {}).join(", ")}`));
     process.exit(1);
   }
-  const templatesDir = path11.join(cwd, ".lean-spec", "templates");
+  const templatesDir = path2.join(cwd, ".lean-spec", "templates");
   const templateFile = config.templates[templateName];
-  const templatePath = path11.join(templatesDir, templateFile);
+  const templatePath = path2.join(templatesDir, templateFile);
   try {
-    const content = await fs8.readFile(templatePath, "utf-8");
+    const content = await fs9.readFile(templatePath, "utf-8");
     console.log("");
-    console.log(chalk9.cyan(`=== Template: ${templateName} (${templateFile}) ===`));
+    console.log(chalk16.cyan(`=== Template: ${templateName} (${templateFile}) ===`));
     console.log("");
     console.log(content);
     console.log("");
   } catch (error) {
-    console.error(chalk9.red(`Error reading template: ${templateFile}`));
+    console.error(chalk16.red(`Error reading template: ${templateFile}`));
     console.error(error);
     process.exit(1);
   }
 }
 async function addTemplate(name, file, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
-  const templatesDir = path11.join(cwd, ".lean-spec", "templates");
-  const templatePath = path11.join(templatesDir, file);
+  const templatesDir = path2.join(cwd, ".lean-spec", "templates");
+  const templatePath = path2.join(templatesDir, file);
   try {
-    await fs8.access(templatePath);
+    await fs9.access(templatePath);
   } catch {
-    console.error(chalk9.red(`Template file not found: ${file}`));
-    console.error(chalk9.gray(`Expected at: ${templatePath}`));
+    console.error(chalk16.red(`Template file not found: ${file}`));
+    console.error(chalk16.gray(`Expected at: ${templatePath}`));
     console.error(
-      chalk9.yellow("Create the file first or use: lean-spec templates copy <source> <target>")
+      chalk16.yellow("Create the file first or use: lean-spec templates copy <source> <target>")
     );
     process.exit(1);
   }
@@ -1435,73 +1379,61 @@ async function addTemplate(name, file, cwd = process.cwd()) {
     config.templates = {};
   }
   if (config.templates[name]) {
-    console.log(chalk9.yellow(`Warning: Template '${name}' already exists, updating...`));
+    console.log(chalk16.yellow(`Warning: Template '${name}' already exists, updating...`));
   }
   config.templates[name] = file;
   await saveConfig(config, cwd);
-  console.log(chalk9.green(`\u2713 Added template: ${name} \u2192 ${file}`));
-  console.log(chalk9.gray(`  Use with: lean-spec create <spec-name> --template=${name}`));
+  console.log(chalk16.green(`\u2713 Added template: ${name} \u2192 ${file}`));
+  console.log(chalk16.gray(`  Use with: lean-spec create <spec-name> --template=${name}`));
 }
 async function removeTemplate(name, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
   if (!config.templates?.[name]) {
-    console.error(chalk9.red(`Template not found: ${name}`));
-    console.error(chalk9.gray(`Available: ${Object.keys(config.templates || {}).join(", ")}`));
+    console.error(chalk16.red(`Template not found: ${name}`));
+    console.error(chalk16.gray(`Available: ${Object.keys(config.templates || {}).join(", ")}`));
     process.exit(1);
   }
   if (name === "default") {
-    console.error(chalk9.red("Cannot remove default template"));
+    console.error(chalk16.red("Cannot remove default template"));
     process.exit(1);
   }
   const file = config.templates[name];
   delete config.templates[name];
   await saveConfig(config, cwd);
-  console.log(chalk9.green(`\u2713 Removed template: ${name}`));
-  console.log(chalk9.gray(`  Note: Template file ${file} still exists in .lean-spec/templates/`));
+  console.log(chalk16.green(`\u2713 Removed template: ${name}`));
+  console.log(chalk16.gray(`  Note: Template file ${file} still exists in .lean-spec/templates/`));
 }
 async function copyTemplate(source, target, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
-  const templatesDir = path11.join(cwd, ".lean-spec", "templates");
+  const templatesDir = path2.join(cwd, ".lean-spec", "templates");
   let sourceFile;
   if (config.templates?.[source]) {
     sourceFile = config.templates[source];
   } else {
     sourceFile = source;
   }
-  const sourcePath = path11.join(templatesDir, sourceFile);
+  const sourcePath = path2.join(templatesDir, sourceFile);
   try {
-    await fs8.access(sourcePath);
+    await fs9.access(sourcePath);
   } catch {
-    console.error(chalk9.red(`Source template not found: ${source}`));
-    console.error(chalk9.gray(`Expected at: ${sourcePath}`));
+    console.error(chalk16.red(`Source template not found: ${source}`));
+    console.error(chalk16.gray(`Expected at: ${sourcePath}`));
     process.exit(1);
   }
   const targetFile = target.endsWith(".md") ? target : `${target}.md`;
-  const targetPath = path11.join(templatesDir, targetFile);
-  await fs8.copyFile(sourcePath, targetPath);
-  console.log(chalk9.green(`\u2713 Copied: ${sourceFile} \u2192 ${targetFile}`));
+  const targetPath = path2.join(templatesDir, targetFile);
+  await fs9.copyFile(sourcePath, targetPath);
+  console.log(chalk16.green(`\u2713 Copied: ${sourceFile} \u2192 ${targetFile}`));
   if (!config.templates) {
     config.templates = {};
   }
   const templateName = target.replace(/\.md$/, "");
   config.templates[templateName] = targetFile;
   await saveConfig(config, cwd);
-  console.log(chalk9.green(`\u2713 Registered template: ${templateName}`));
-  console.log(chalk9.gray(`  Edit: ${targetPath}`));
-  console.log(chalk9.gray(`  Use with: lean-spec create <spec-name> --template=${templateName}`));
+  console.log(chalk16.green(`\u2713 Registered template: ${templateName}`));
+  console.log(chalk16.gray(`  Edit: ${targetPath}`));
+  console.log(chalk16.gray(`  Use with: lean-spec create <spec-name> --template=${templateName}`));
 }
-
-// src/commands/init.ts
-import * as fs10 from "fs/promises";
-import * as path13 from "path";
-import { fileURLToPath } from "url";
-import chalk11 from "chalk";
-import { select } from "@inquirer/prompts";
-
-// src/utils/template-helpers.ts
-import * as fs9 from "fs/promises";
-import * as path12 from "path";
-import chalk10 from "chalk";
 async function detectExistingSystemPrompts(cwd) {
   const commonFiles = [
     "AGENTS.md",
@@ -1511,7 +1443,7 @@ async function detectExistingSystemPrompts(cwd) {
   const found = [];
   for (const file of commonFiles) {
     try {
-      await fs9.access(path12.join(cwd, file));
+      await fs9.access(path2.join(cwd, file));
       found.push(file);
     } catch {
     }
@@ -1520,8 +1452,8 @@ async function detectExistingSystemPrompts(cwd) {
 }
 async function handleExistingFiles(action, existingFiles, templateDir, cwd, variables = {}) {
   for (const file of existingFiles) {
-    const filePath = path12.join(cwd, file);
-    const templateFilePath = path12.join(templateDir, "files", file);
+    const filePath = path2.join(cwd, file);
+    const templateFilePath = path2.join(templateDir, "files", file);
     try {
       await fs9.access(templateFilePath);
     } catch {
@@ -1533,7 +1465,7 @@ async function handleExistingFiles(action, existingFiles, templateDir, cwd, vari
       for (const [key, value] of Object.entries(variables)) {
         template = template.replace(new RegExp(`\\{${key}\\}`, "g"), value);
       }
-      const promptPath = path12.join(cwd, ".lean-spec", "MERGE-AGENTS-PROMPT.md");
+      const promptPath = path2.join(cwd, ".lean-spec", "MERGE-AGENTS-PROMPT.md");
       const aiPrompt = `# AI Prompt: Consolidate AGENTS.md
 
 ## Task
@@ -1565,16 +1497,16 @@ Create a single consolidated AGENTS.md that:
 - Maintains clear structure and readability
 - Removes any duplicate or conflicting guidance
 `;
-      await fs9.mkdir(path12.dirname(promptPath), { recursive: true });
+      await fs9.mkdir(path2.dirname(promptPath), { recursive: true });
       await fs9.writeFile(promptPath, aiPrompt, "utf-8");
-      console.log(chalk10.green(`\u2713 Created AI consolidation prompt`));
-      console.log(chalk10.cyan(`  \u2192 ${promptPath}`));
+      console.log(chalk16.green(`\u2713 Created AI consolidation prompt`));
+      console.log(chalk16.cyan(`  \u2192 ${promptPath}`));
       console.log("");
-      console.log(chalk10.yellow("\u{1F4DD} Next steps:"));
-      console.log(chalk10.gray("  1. Open .lean-spec/MERGE-AGENTS-PROMPT.md"));
-      console.log(chalk10.gray("  2. Send it to your AI coding assistant (GitHub Copilot, Cursor, etc.)"));
-      console.log(chalk10.gray("  3. Let AI create the consolidated AGENTS.md"));
-      console.log(chalk10.gray("  4. Review and commit the result"));
+      console.log(chalk16.yellow("\u{1F4DD} Next steps:"));
+      console.log(chalk16.gray("  1. Open .lean-spec/MERGE-AGENTS-PROMPT.md"));
+      console.log(chalk16.gray("  2. Send it to your AI coding assistant (GitHub Copilot, Cursor, etc.)"));
+      console.log(chalk16.gray("  3. Let AI create the consolidated AGENTS.md"));
+      console.log(chalk16.gray("  4. Review and commit the result"));
       console.log("");
     } else if (action === "merge-append" && file === "AGENTS.md") {
       const existing = await fs9.readFile(filePath, "utf-8");
@@ -1590,19 +1522,19 @@ Create a single consolidated AGENTS.md that:
 
 ${template.split("\n").slice(1).join("\n")}`;
       await fs9.writeFile(filePath, merged, "utf-8");
-      console.log(chalk10.green(`\u2713 Appended LeanSpec section to ${file}`));
-      console.log(chalk10.yellow("  \u26A0 Note: May be verbose. Consider consolidating later."));
+      console.log(chalk16.green(`\u2713 Appended LeanSpec section to ${file}`));
+      console.log(chalk16.yellow("  \u26A0 Note: May be verbose. Consider consolidating later."));
     } else if (action === "overwrite") {
       const backupPath = `${filePath}.backup`;
       await fs9.rename(filePath, backupPath);
-      console.log(chalk10.yellow(`\u2713 Backed up ${file} \u2192 ${file}.backup`));
+      console.log(chalk16.yellow(`\u2713 Backed up ${file} \u2192 ${file}.backup`));
       let content = await fs9.readFile(templateFilePath, "utf-8");
       for (const [key, value] of Object.entries(variables)) {
         content = content.replace(new RegExp(`\\{${key}\\}`, "g"), value);
       }
       await fs9.writeFile(filePath, content, "utf-8");
-      console.log(chalk10.green(`\u2713 Created new ${file}`));
-      console.log(chalk10.gray(`  \u{1F4A1} Your original content is preserved in ${file}.backup`));
+      console.log(chalk16.green(`\u2713 Created new ${file}`));
+      console.log(chalk16.gray(`  \u{1F4A1} Your original content is preserved in ${file}.backup`));
     }
   }
 }
@@ -1610,8 +1542,8 @@ async function copyDirectory(src, dest, skipFiles = [], variables = {}) {
   await fs9.mkdir(dest, { recursive: true });
   const entries = await fs9.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path12.join(src, entry.name);
-    const destPath = path12.join(dest, entry.name);
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
     if (skipFiles.includes(entry.name)) {
       continue;
     }
@@ -1632,7 +1564,7 @@ async function copyDirectory(src, dest, skipFiles = [], variables = {}) {
 }
 async function getProjectName2(cwd) {
   try {
-    const packageJsonPath = path12.join(cwd, "package.json");
+    const packageJsonPath = path2.join(cwd, "package.json");
     const content = await fs9.readFile(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     if (pkg.name) {
@@ -1640,23 +1572,23 @@ async function getProjectName2(cwd) {
     }
   } catch {
   }
-  return path12.basename(cwd);
+  return path2.basename(cwd);
 }
 
 // src/commands/init.ts
-var __dirname2 = path13.dirname(fileURLToPath(import.meta.url));
-var TEMPLATES_DIR = path13.join(__dirname2, "..", "templates");
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var TEMPLATES_DIR = path2.join(__dirname, "..", "templates");
 async function initProject() {
   const cwd = process.cwd();
   try {
-    await fs10.access(path13.join(cwd, ".lean-spec", "config.json"));
-    console.log(chalk11.yellow("\u26A0 LeanSpec already initialized in this directory."));
-    console.log(chalk11.gray("To reinitialize, delete .lean-spec/ directory first."));
+    await fs9.access(path2.join(cwd, ".lean-spec", "config.json"));
+    console.log(chalk16.yellow("\u26A0 LeanSpec already initialized in this directory."));
+    console.log(chalk16.gray("To reinitialize, delete .lean-spec/ directory first."));
     return;
   } catch {
   }
   console.log("");
-  console.log(chalk11.green("Welcome to LeanSpec!"));
+  console.log(chalk16.green("Welcome to LeanSpec!"));
   console.log("");
   const setupMode = await select({
     message: "How would you like to set up?",
@@ -1694,14 +1626,14 @@ async function initProject() {
       ]
     });
   }
-  const templateDir = path13.join(TEMPLATES_DIR, templateName);
-  const templateConfigPath = path13.join(templateDir, "config.json");
+  const templateDir = path2.join(TEMPLATES_DIR, templateName);
+  const templateConfigPath = path2.join(templateDir, "config.json");
   let templateConfig;
   try {
-    const content = await fs10.readFile(templateConfigPath, "utf-8");
+    const content = await fs9.readFile(templateConfigPath, "utf-8");
     templateConfig = JSON.parse(content).config;
   } catch {
-    console.error(chalk11.red(`Error: Template not found: ${templateName}`));
+    console.error(chalk16.red(`Error: Template not found: ${templateName}`));
     process.exit(1);
   }
   let patternChoice = "simple";
@@ -1744,27 +1676,27 @@ async function initProject() {
     templateConfig.structure.prefix = "{YYYYMMDD}-";
   } else if (patternChoice === "custom") {
     console.log("");
-    console.log(chalk11.yellow("\u26A0 Custom pattern input is not yet implemented."));
-    console.log(chalk11.gray("  You can manually edit .lean-spec/config.json after initialization."));
-    console.log(chalk11.gray("  Using simple pattern for now."));
+    console.log(chalk16.yellow("\u26A0 Custom pattern input is not yet implemented."));
+    console.log(chalk16.gray("  You can manually edit .lean-spec/config.json after initialization."));
+    console.log(chalk16.gray("  Using simple pattern for now."));
     console.log("");
     templateConfig.structure.pattern = "flat";
     templateConfig.structure.prefix = "";
   }
-  const templatesDir = path13.join(cwd, ".lean-spec", "templates");
+  const templatesDir = path2.join(cwd, ".lean-spec", "templates");
   try {
-    await fs10.mkdir(templatesDir, { recursive: true });
+    await fs9.mkdir(templatesDir, { recursive: true });
   } catch (error) {
-    console.error(chalk11.red("Error creating templates directory:"), error);
+    console.error(chalk16.red("Error creating templates directory:"), error);
     process.exit(1);
   }
-  const templateSpecPath = path13.join(templateDir, "spec-template.md");
-  const targetSpecPath = path13.join(templatesDir, "spec-template.md");
+  const templateSpecPath = path2.join(templateDir, "spec-template.md");
+  const targetSpecPath = path2.join(templatesDir, "spec-template.md");
   try {
-    await fs10.copyFile(templateSpecPath, targetSpecPath);
-    console.log(chalk11.green("\u2713 Created .lean-spec/templates/spec-template.md"));
+    await fs9.copyFile(templateSpecPath, targetSpecPath);
+    console.log(chalk16.green("\u2713 Created .lean-spec/templates/spec-template.md"));
   } catch (error) {
-    console.error(chalk11.red("Error copying template:"), error);
+    console.error(chalk16.red("Error copying template:"), error);
     process.exit(1);
   }
   templateConfig.template = "spec-template.md";
@@ -1772,12 +1704,12 @@ async function initProject() {
     default: "spec-template.md"
   };
   await saveConfig(templateConfig, cwd);
-  console.log(chalk11.green("\u2713 Created .lean-spec/config.json"));
+  console.log(chalk16.green("\u2713 Created .lean-spec/config.json"));
   const existingFiles = await detectExistingSystemPrompts(cwd);
   let skipFiles = [];
   if (existingFiles.length > 0) {
     console.log("");
-    console.log(chalk11.yellow(`Found existing: ${existingFiles.join(", ")}`));
+    console.log(chalk16.yellow(`Found existing: ${existingFiles.join(", ")}`));
     const action = await select({
       message: "How would you like to handle existing AGENTS.md?",
       choices: [
@@ -1810,33 +1742,28 @@ async function initProject() {
     }
   }
   const projectName = await getProjectName2(cwd);
-  const filesDir = path13.join(templateDir, "files");
+  const filesDir = path2.join(templateDir, "files");
   try {
     await copyDirectory(filesDir, cwd, skipFiles, { project_name: projectName });
-    console.log(chalk11.green("\u2713 Initialized project structure"));
+    console.log(chalk16.green("\u2713 Initialized project structure"));
   } catch (error) {
-    console.error(chalk11.red("Error copying template files:"), error);
+    console.error(chalk16.red("Error copying template files:"), error);
     process.exit(1);
   }
   console.log("");
-  console.log(chalk11.green("\u2713 LeanSpec initialized!"));
+  console.log(chalk16.green("\u2713 LeanSpec initialized!"));
   console.log("");
   console.log("Next steps:");
-  console.log(chalk11.gray("  - Review and customize AGENTS.md"));
-  console.log(chalk11.gray("  - Check out example spec in specs/"));
-  console.log(chalk11.gray("  - Create your first spec: lean-spec create my-feature"));
+  console.log(chalk16.gray("  - Review and customize AGENTS.md"));
+  console.log(chalk16.gray("  - Check out example spec in specs/"));
+  console.log(chalk16.gray("  - Create your first spec: lean-spec create my-feature"));
   console.log("");
 }
-
-// src/commands/files.ts
-import * as fs11 from "fs/promises";
-import * as path14 from "path";
-import chalk12 from "chalk";
 async function filesCommand(specPath, options = {}) {
   await autoCheckIfEnabled();
   const config = await loadConfig();
   const cwd = process.cwd();
-  const specsDir = path14.join(cwd, config.specsDir);
+  const specsDir = path2.join(cwd, config.specsDir);
   const resolvedPath = await resolveSpecPath(specPath, cwd, specsDir);
   if (!resolvedPath) {
     throw new Error(`Spec not found: ${sanitizeUserInput(specPath)}. Try using the full path or spec name (e.g., 001-my-spec)`);
@@ -1847,12 +1774,12 @@ async function filesCommand(specPath, options = {}) {
   }
   const subFiles = await loadSubFiles(spec.fullPath);
   console.log("");
-  console.log(chalk12.cyan(`\u{1F4C4} Files in ${sanitizeUserInput(spec.name)}`));
+  console.log(chalk16.cyan(`\u{1F4C4} Files in ${sanitizeUserInput(spec.name)}`));
   console.log("");
-  console.log(chalk12.green("Required:"));
-  const readmeStat = await fs11.stat(spec.filePath);
+  console.log(chalk16.green("Required:"));
+  const readmeStat = await fs9.stat(spec.filePath);
   const readmeSize = formatSize(readmeStat.size);
-  console.log(chalk12.green(`  \u2713 README.md              (${readmeSize})  Main spec`));
+  console.log(chalk16.green(`  \u2713 README.md              (${readmeSize})  Main spec`));
   console.log("");
   let filteredFiles = subFiles;
   if (options.type === "docs") {
@@ -1861,25 +1788,25 @@ async function filesCommand(specPath, options = {}) {
     filteredFiles = subFiles.filter((f) => f.type === "asset");
   }
   if (filteredFiles.length === 0) {
-    console.log(chalk12.gray("No additional files"));
+    console.log(chalk16.gray("No additional files"));
     console.log("");
     return;
   }
   const documents = filteredFiles.filter((f) => f.type === "document");
   const assets = filteredFiles.filter((f) => f.type === "asset");
   if (documents.length > 0 && (!options.type || options.type === "docs")) {
-    console.log(chalk12.cyan("Documents:"));
+    console.log(chalk16.cyan("Documents:"));
     for (const file of documents) {
       const size = formatSize(file.size);
-      console.log(chalk12.cyan(`  \u2713 ${sanitizeUserInput(file.name).padEnd(20)} (${size})`));
+      console.log(chalk16.cyan(`  \u2713 ${sanitizeUserInput(file.name).padEnd(20)} (${size})`));
     }
     console.log("");
   }
   if (assets.length > 0 && (!options.type || options.type === "assets")) {
-    console.log(chalk12.yellow("Assets:"));
+    console.log(chalk16.yellow("Assets:"));
     for (const file of assets) {
       const size = formatSize(file.size);
-      console.log(chalk12.yellow(`  \u2713 ${sanitizeUserInput(file.name).padEnd(20)} (${size})`));
+      console.log(chalk16.yellow(`  \u2713 ${sanitizeUserInput(file.name).padEnd(20)} (${size})`));
     }
     console.log("");
   }
@@ -1887,7 +1814,7 @@ async function filesCommand(specPath, options = {}) {
   const totalSize = formatSize(
     readmeStat.size + filteredFiles.reduce((sum, f) => sum + f.size, 0)
   );
-  console.log(chalk12.gray(`Total: ${totalFiles} files, ${totalSize}`));
+  console.log(chalk16.gray(`Total: ${totalFiles} files, ${totalSize}`));
   console.log("");
 }
 function formatSize(bytes) {
@@ -1899,55 +1826,6 @@ function formatSize(bytes) {
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
   }
 }
-
-// src/commands/validate.ts
-import * as fs12 from "fs/promises";
-import * as path16 from "path";
-import chalk14 from "chalk";
-
-// src/validators/line-count.ts
-var LineCountValidator = class {
-  name = "max-lines";
-  description = "Enforce Context Economy: specs must be <400 lines";
-  maxLines;
-  warningThreshold;
-  constructor(options = {}) {
-    this.maxLines = options.maxLines ?? 400;
-    this.warningThreshold = options.warningThreshold ?? 300;
-  }
-  validate(_spec, content) {
-    const lines = content.split("\n").length;
-    if (lines > this.maxLines) {
-      return {
-        passed: false,
-        errors: [{
-          message: `Spec exceeds ${this.maxLines} lines (${lines} lines)`,
-          suggestion: "Consider splitting into sub-specs using spec 012 pattern"
-        }],
-        warnings: []
-      };
-    }
-    if (lines > this.warningThreshold) {
-      return {
-        passed: true,
-        errors: [],
-        warnings: [{
-          message: `Spec approaching limit (${lines}/${this.maxLines} lines)`,
-          suggestion: "Consider simplification or splitting"
-        }]
-      };
-    }
-    return {
-      passed: true,
-      errors: [],
-      warnings: []
-    };
-  }
-};
-
-// src/validators/frontmatter.ts
-import matter2 from "gray-matter";
-import yaml2 from "js-yaml";
 var FrontmatterValidator = class {
   name = "frontmatter";
   description = "Validate spec frontmatter for required fields and valid values";
@@ -1962,9 +1840,9 @@ var FrontmatterValidator = class {
     const warnings = [];
     let parsed;
     try {
-      parsed = matter2(content, {
+      parsed = matter(content, {
         engines: {
-          yaml: (str) => yaml2.load(str, { schema: yaml2.FAILSAFE_SCHEMA })
+          yaml: (str) => yaml.load(str, { schema: yaml.FAILSAFE_SCHEMA })
         }
       });
     } catch (error) {
@@ -2078,9 +1956,6 @@ var FrontmatterValidator = class {
     return { valid: true };
   }
 };
-
-// src/validators/structure.ts
-import matter3 from "gray-matter";
 var StructureValidator = class {
   name = "structure";
   description = "Validate spec structure and required sections";
@@ -2095,7 +1970,7 @@ var StructureValidator = class {
     const warnings = [];
     let parsed;
     try {
-      parsed = matter3(content);
+      parsed = matter(content);
     } catch (error) {
       errors.push({
         message: "Failed to parse frontmatter",
@@ -2424,18 +2299,19 @@ var CorruptionValidator = class {
     return errors;
   }
 };
-
-// src/validators/sub-spec.ts
-import * as path15 from "path";
 var SubSpecValidator = class {
   name = "sub-specs";
-  description = "Validate sub-spec files per spec 012 conventions";
-  maxLines;
+  description = "Validate sub-spec files using direct token thresholds (spec 071)";
+  excellentThreshold;
+  goodThreshold;
   warningThreshold;
+  maxLines;
   checkCrossReferences;
   constructor(options = {}) {
-    this.maxLines = options.maxLines ?? 400;
-    this.warningThreshold = options.warningThreshold ?? 300;
+    this.excellentThreshold = options.excellentThreshold ?? 2e3;
+    this.goodThreshold = options.goodThreshold ?? 3500;
+    this.warningThreshold = options.warningThreshold ?? 5e3;
+    this.maxLines = options.maxLines ?? 500;
     this.checkCrossReferences = options.checkCrossReferences ?? true;
   }
   async validate(spec, content) {
@@ -2447,7 +2323,7 @@ var SubSpecValidator = class {
       return { passed: true, errors, warnings };
     }
     this.validateNamingConventions(subSpecs, warnings);
-    await this.validateLineCounts(subSpecs, errors, warnings);
+    await this.validateComplexity(subSpecs, errors, warnings);
     this.checkOrphanedSubSpecs(subSpecs, content, warnings);
     if (this.checkCrossReferences) {
       await this.validateCrossReferences(subSpecs, spec, warnings);
@@ -2464,7 +2340,7 @@ var SubSpecValidator = class {
    */
   validateNamingConventions(subSpecs, warnings) {
     for (const subSpec of subSpecs) {
-      const baseName = path15.basename(subSpec.name, ".md");
+      const baseName = path2.basename(subSpec.name, ".md");
       if (baseName !== baseName.toUpperCase()) {
         warnings.push({
           message: `Sub-spec filename should be uppercase: ${subSpec.name}`,
@@ -2474,23 +2350,50 @@ var SubSpecValidator = class {
     }
   }
   /**
-   * Validate line counts for each sub-spec file
+   * Validate complexity for each sub-spec file using direct token thresholds
+   * Same approach as ComplexityValidator (spec 071)
    */
-  async validateLineCounts(subSpecs, errors, warnings) {
+  async validateComplexity(subSpecs, errors, warnings) {
     for (const subSpec of subSpecs) {
       if (!subSpec.content) {
         continue;
       }
-      const lines = subSpec.content.split("\n").length;
-      if (lines > this.maxLines) {
+      const lines = subSpec.content.split("\n");
+      const lineCount = lines.length;
+      let sectionCount = 0;
+      let inCodeBlock = false;
+      for (const line of lines) {
+        if (line.trim().startsWith("```")) {
+          inCodeBlock = !inCodeBlock;
+          continue;
+        }
+        if (!inCodeBlock && line.match(/^#{2,4}\s/)) {
+          sectionCount++;
+        }
+      }
+      const tokenResult = await countTokens(subSpec.content);
+      const tokenCount = tokenResult.total;
+      if (tokenCount > this.warningThreshold) {
         errors.push({
-          message: `Sub-spec ${subSpec.name} exceeds ${this.maxLines} lines (${lines} lines)`,
-          suggestion: "Consider further splitting or simplification"
+          message: `Sub-spec ${subSpec.name} has ${tokenCount.toLocaleString()} tokens (threshold: ${this.warningThreshold.toLocaleString()}) - should split`,
+          suggestion: "Consider splitting for Context Economy (attention and cognitive load)"
+        });
+      } else if (tokenCount > this.goodThreshold) {
+        warnings.push({
+          message: `Sub-spec ${subSpec.name} has ${tokenCount.toLocaleString()} tokens (threshold: ${this.goodThreshold.toLocaleString()})`,
+          suggestion: "Consider simplification or further splitting"
+        });
+      }
+      if (sectionCount < 8 && lineCount > 200) {
+        warnings.push({
+          message: `Sub-spec ${subSpec.name} has only ${sectionCount} sections - too monolithic`,
+          suggestion: "Break into 15-35 sections for better readability (7\xB12 cognitive chunks)"
         });
-      } else if (lines > this.warningThreshold) {
+      }
+      if (lineCount > this.maxLines) {
         warnings.push({
-          message: `Sub-spec ${subSpec.name} approaching limit (${lines}/${this.maxLines} lines)`,
-          suggestion: "Consider simplification"
+          message: `Sub-spec ${subSpec.name} is very long (${lineCount} lines)`,
+          suggestion: "Consider splitting even if token count is acceptable"
         });
       }
     }
@@ -2536,9 +2439,6 @@ var SubSpecValidator = class {
     }
   }
 };
-
-// src/utils/validate-formatter.ts
-import chalk13 from "chalk";
 function groupIssuesByFile(results) {
   const fileMap = /* @__PURE__ */ new Map();
   const addIssue = (filePath, issue, spec) => {
@@ -2605,17 +2505,17 @@ function formatFileIssues(fileResult, specsDir) {
     const priority = fileResult.spec.frontmatter.priority || "medium";
     const statusBadge = formatStatusBadge(status);
     const priorityBadge = formatPriorityBadge(priority);
-    lines.push(chalk13.bold.cyan(`${specName} ${statusBadge} ${priorityBadge}`));
+    lines.push(chalk16.bold.cyan(`${specName} ${statusBadge} ${priorityBadge}`));
   } else {
-    lines.push(chalk13.cyan.underline(relativePath));
+    lines.push(chalk16.cyan.underline(relativePath));
   }
   for (const issue of fileResult.issues) {
-    const severityColor = issue.severity === "error" ? chalk13.red : chalk13.yellow;
+    const severityColor = issue.severity === "error" ? chalk16.red : chalk16.yellow;
     const severityText = severityColor(issue.severity.padEnd(9));
-    const ruleText = chalk13.gray(issue.ruleName);
+    const ruleText = chalk16.gray(issue.ruleName);
     lines.push(`  ${severityText}${issue.message.padEnd(60)} ${ruleText}`);
     if (issue.suggestion) {
-      lines.push(chalk13.gray(`           \u2192 ${issue.suggestion}`));
+      lines.push(chalk16.gray(`           \u2192 ${issue.suggestion}`));
     }
   }
   lines.push("");
@@ -2625,25 +2525,25 @@ function formatSummary(totalSpecs, errorCount, warningCount, cleanCount) {
   if (errorCount > 0) {
     const errorText = errorCount === 1 ? "error" : "errors";
     const warningText = warningCount === 1 ? "warning" : "warnings";
-    return chalk13.red.bold(
+    return chalk16.red.bold(
       `\u2716 ${errorCount} ${errorText}, ${warningCount} ${warningText} (${totalSpecs} specs checked, ${cleanCount} clean)`
     );
   } else if (warningCount > 0) {
     const warningText = warningCount === 1 ? "warning" : "warnings";
-    return chalk13.yellow.bold(
+    return chalk16.yellow.bold(
       `\u26A0 ${warningCount} ${warningText} (${totalSpecs} specs checked, ${cleanCount} clean)`
     );
   } else {
-    return chalk13.green.bold(`\u2713 All ${totalSpecs} specs passed`);
+    return chalk16.green.bold(`\u2713 All ${totalSpecs} specs passed`);
   }
 }
 function formatPassingSpecs(specs, specsDir) {
   const lines = [];
-  lines.push(chalk13.green.bold(`
+  lines.push(chalk16.green.bold(`
 \u2713 ${specs.length} specs passed:`));
   for (const spec of specs) {
     const relativePath = normalizeFilePath(spec.filePath);
-    lines.push(chalk13.gray(`  ${relativePath}`));
+    lines.push(chalk16.gray(`  ${relativePath}`));
   }
   return lines.join("\n");
 }
@@ -2689,16 +2589,16 @@ function formatValidationResults(results, specs, specsDir, options = {}) {
     return formatJson(displayResults, specs.length, errorCount2, warningCount2);
   }
   const lines = [];
-  lines.push(chalk13.bold(`
+  lines.push(chalk16.bold(`
 Validating ${specs.length} specs...
 `));
   let previousSpecName;
   for (const fileResult of displayResults) {
     if (fileResult.spec && previousSpecName && fileResult.spec.name !== previousSpecName) {
-      lines.push(chalk13.gray("\u2500".repeat(80)));
+      lines.push(chalk16.gray("\u2500".repeat(80)));
       lines.push("");
     }
-    lines.push(formatFileIssues(fileResult, specsDir));
+    lines.push(formatFileIssues(fileResult));
     if (fileResult.spec) {
       previousSpecName = fileResult.spec.name;
     }
@@ -2716,10 +2616,10 @@ Validating ${specs.length} specs...
   if (options.verbose && cleanCount > 0) {
     const specsWithIssues = new Set(fileResults.map((fr) => fr.filePath));
     const passingSpecs = specs.filter((spec) => !specsWithIssues.has(spec.filePath));
-    lines.push(formatPassingSpecs(passingSpecs, specsDir));
+    lines.push(formatPassingSpecs(passingSpecs));
   }
   if (!options.verbose && cleanCount > 0 && displayResults.length > 0) {
-    lines.push(chalk13.gray("\nRun with --verbose to see passing specs."));
+    lines.push(chalk16.gray("\nRun with --verbose to see passing specs."));
   }
   return lines.join("\n");
 }
@@ -2733,12 +2633,12 @@ async function validateCommand(options = {}) {
     specs = [];
     for (const specPath of options.specs) {
       const spec = allSpecs.find(
-        (s) => s.path.includes(specPath) || path16.basename(s.path).includes(specPath)
+        (s) => s.path.includes(specPath) || path2.basename(s.path).includes(specPath)
       );
       if (spec) {
         specs.push(spec);
       } else {
-        console.error(chalk14.red(`Error: Spec not found: ${specPath}`));
+        console.error(chalk16.red(`Error: Spec not found: ${specPath}`));
         return false;
       }
     }
@@ -2753,7 +2653,8 @@ async function validateCommand(options = {}) {
     return true;
   }
   const validators = [
-    new LineCountValidator({ maxLines: options.maxLines }),
+    new ComplexityValidator({ maxLines: options.maxLines }),
+    // Token-based complexity (primary), line count (backstop)
     new FrontmatterValidator(),
     new StructureValidator(),
     new CorruptionValidator(),
@@ -2763,19 +2664,23 @@ async function validateCommand(options = {}) {
   for (const spec of specs) {
     let content;
     try {
-      content = await fs12.readFile(spec.filePath, "utf-8");
+      content = await fs9.readFile(spec.filePath, "utf-8");
     } catch (error) {
-      console.error(chalk14.red(`Error reading ${spec.filePath}:`), error);
+      console.error(chalk16.red(`Error reading ${spec.filePath}:`), error);
       continue;
     }
     for (const validator of validators) {
-      const result = await validator.validate(spec, content);
-      results.push({
-        spec,
-        validatorName: validator.name,
-        result,
-        content
-      });
+      try {
+        const result = await validator.validate(spec, content);
+        results.push({
+          spec,
+          validatorName: validator.name,
+          result,
+          content
+        });
+      } catch (error) {
+        console.error(chalk16.yellow(`Warning: Validator ${validator.name} failed:`), error instanceof Error ? error.message : error);
+      }
     }
   }
   const formatOptions = {
@@ -2789,14 +2694,10 @@ async function validateCommand(options = {}) {
   const hasErrors = results.some((r) => !r.result.passed);
   return !hasErrors;
 }
-
-// src/commands/migrate.ts
-import * as fs13 from "fs/promises";
-import * as path17 from "path";
 async function migrateCommand(inputPath, options = {}) {
   const config = await loadConfig();
   try {
-    const stats = await fs13.stat(inputPath);
+    const stats = await fs9.stat(inputPath);
     if (!stats.isDirectory()) {
       console.error("\x1B[31m\u274C Error:\x1B[0m Input path must be a directory");
       process.exit(1);
@@ -2824,16 +2725,16 @@ async function migrateCommand(inputPath, options = {}) {
 async function scanDocuments(dirPath) {
   const documents = [];
   async function scanRecursive(currentPath) {
-    const entries = await fs13.readdir(currentPath, { withFileTypes: true });
+    const entries = await fs9.readdir(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path17.join(currentPath, entry.name);
+      const fullPath = path2.join(currentPath, entry.name);
       if (entry.isDirectory()) {
         if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
           await scanRecursive(fullPath);
         }
       } else if (entry.isFile()) {
         if (entry.name.endsWith(".md") || entry.name.endsWith(".markdown")) {
-          const stats = await fs13.stat(fullPath);
+          const stats = await fs9.stat(fullPath);
           documents.push({
             path: fullPath,
             name: entry.name,
@@ -2847,7 +2748,7 @@ async function scanDocuments(dirPath) {
   return documents;
 }
 async function outputManualInstructions(inputPath, documents, config) {
-  const specsDir = config.specsDir || "specs";
+  config.specsDir || "specs";
   console.log("\u2550".repeat(70));
   console.log("\x1B[1m\x1B[36m\u{1F4CB} LeanSpec Migration Instructions\x1B[0m");
   console.log("\u2550".repeat(70));
@@ -2966,7 +2867,7 @@ async function verifyAITool(provider) {
   let installed = false;
   let version;
   try {
-    const { execSync: execSync3 } = await import("child_process");
+    const { execSync: execSync3 } = await import('child_process');
     execSync3(`which ${toolDef.cliCommand}`, { stdio: "ignore" });
     installed = true;
     try {
@@ -3003,12 +2904,6 @@ function satisfiesVersion(version, minVersion) {
   }
   return true;
 }
-
-// src/commands/board.ts
-import chalk15 from "chalk";
-
-// src/utils/completion.ts
-import dayjs from "dayjs";
 function isCriticalOverdue(spec) {
   if (spec.frontmatter.status === "complete" || spec.frontmatter.status === "archived") {
     return false;
@@ -3016,7 +2911,7 @@ function isCriticalOverdue(spec) {
   if (!spec.frontmatter.due) {
     return false;
   }
-  const isOverdue = dayjs(spec.frontmatter.due).isBefore(dayjs(), "day");
+  const isOverdue = dayjs2(spec.frontmatter.due).isBefore(dayjs2(), "day");
   const isCritical = spec.frontmatter.priority === "critical" || spec.frontmatter.priority === "high";
   return isOverdue && isCritical;
 }
@@ -3028,7 +2923,7 @@ function isLongRunning(spec) {
   if (!updatedAt) {
     return false;
   }
-  const daysSinceUpdate = dayjs().diff(dayjs(updatedAt), "day");
+  const daysSinceUpdate = dayjs2().diff(dayjs2(updatedAt), "day");
   return daysSinceUpdate > 7;
 }
 function calculateCompletion(specs) {
@@ -3071,9 +2966,6 @@ function getCompletionStatus(score) {
     return { emoji: "\u2717", label: "Needs Attention", color: "red" };
   }
 }
-
-// src/utils/velocity.ts
-import dayjs2 from "dayjs";
 function calculateCycleTime(spec) {
   if (spec.frontmatter.status !== "complete" && spec.frontmatter.status !== "archived") {
     return null;
@@ -3196,7 +3088,7 @@ async function boardCommand(options) {
     })
   );
   if (specs.length === 0) {
-    console.log(chalk15.dim("No specs found."));
+    console.log(chalk16.dim("No specs found."));
     return;
   }
   const columns = {
@@ -3211,18 +3103,18 @@ async function boardCommand(options) {
       columns[status].push(spec);
     }
   }
-  console.log(chalk15.bold.cyan("\u{1F4CB} Spec Kanban Board"));
+  console.log(chalk16.bold.cyan("\u{1F4CB} Spec Kanban Board"));
   if (options.tag || options.assignee) {
     const filterParts = [];
     if (options.tag) filterParts.push(`tag=${options.tag}`);
     if (options.assignee) filterParts.push(`assignee=${options.assignee}`);
-    console.log(chalk15.dim(`Filtered by: ${filterParts.join(", ")}`));
+    console.log(chalk16.dim(`Filtered by: ${filterParts.join(", ")}`));
   }
   console.log("");
   if (!options.simple) {
     const completionMetrics = calculateCompletion(specs);
     const velocityMetrics = calculateVelocityMetrics(specs);
-    const completionStatus = getCompletionStatus(completionMetrics.score);
+    getCompletionStatus(completionMetrics.score);
     const boxWidth = 62;
     const topBorder = "\u2554" + "\u2550".repeat(boxWidth - 2) + "\u2557";
     const bottomBorder = "\u255A" + "\u2550".repeat(boxWidth - 2) + "\u255D";
@@ -3231,12 +3123,12 @@ async function boardCommand(options) {
       const padding = boxWidth - 2 - visibleLength;
       return content + " ".repeat(Math.max(0, padding));
     };
-    console.log(chalk15.dim(topBorder));
-    const headerLine = chalk15.bold("  Project Overview");
-    console.log(chalk15.dim("\u2551") + padLine(headerLine) + chalk15.dim("\u2551"));
-    const percentageColor = completionMetrics.score >= 70 ? chalk15.green : completionMetrics.score >= 40 ? chalk15.yellow : chalk15.red;
+    console.log(chalk16.dim(topBorder));
+    const headerLine = chalk16.bold("  Project Overview");
+    console.log(chalk16.dim("\u2551") + padLine(headerLine) + chalk16.dim("\u2551"));
+    const percentageColor = completionMetrics.score >= 70 ? chalk16.green : completionMetrics.score >= 40 ? chalk16.yellow : chalk16.red;
     const line1 = `  ${completionMetrics.totalSpecs} total \xB7 ${completionMetrics.activeSpecs} active \xB7 ${completionMetrics.completeSpecs} complete ${percentageColor("(" + completionMetrics.score + "%)")}`;
-    console.log(chalk15.dim("\u2551") + padLine(line1) + chalk15.dim("\u2551"));
+    console.log(chalk16.dim("\u2551") + padLine(line1) + chalk16.dim("\u2551"));
     if (completionMetrics.criticalIssues.length > 0 || completionMetrics.warnings.length > 0) {
       const alerts = [];
       if (completionMetrics.criticalIssues.length > 0) {
@@ -3245,27 +3137,27 @@ async function boardCommand(options) {
       if (completionMetrics.warnings.length > 0) {
         alerts.push(`${completionMetrics.warnings.length} specs WIP > 7 days`);
       }
-      const alertLine = `  ${chalk15.yellow("\u26A0\uFE0F  " + alerts.join(" \xB7 "))}`;
-      console.log(chalk15.dim("\u2551") + padLine(alertLine) + chalk15.dim("\u2551"));
+      const alertLine = `  ${chalk16.yellow("\u26A0\uFE0F  " + alerts.join(" \xB7 "))}`;
+      console.log(chalk16.dim("\u2551") + padLine(alertLine) + chalk16.dim("\u2551"));
     }
-    const velocityLine = `  ${chalk15.cyan("\u{1F680} Velocity:")} ${velocityMetrics.cycleTime.average.toFixed(1)}d avg cycle \xB7 ${(velocityMetrics.throughput.perWeek / 7 * 7).toFixed(1)}/wk throughput`;
-    console.log(chalk15.dim("\u2551") + padLine(velocityLine) + chalk15.dim("\u2551"));
-    console.log(chalk15.dim(bottomBorder));
+    const velocityLine = `  ${chalk16.cyan("\u{1F680} Velocity:")} ${velocityMetrics.cycleTime.average.toFixed(1)}d avg cycle \xB7 ${(velocityMetrics.throughput.perWeek / 7 * 7).toFixed(1)}/wk throughput`;
+    console.log(chalk16.dim("\u2551") + padLine(velocityLine) + chalk16.dim("\u2551"));
+    console.log(chalk16.dim(bottomBorder));
     console.log("");
     if (options.completionOnly) {
       return;
     }
   }
   renderColumn(STATUS_CONFIG.planned.label, STATUS_CONFIG.planned.emoji, columns.planned, true, STATUS_CONFIG.planned.colorFn);
-  console.log(chalk15.dim("\u2501".repeat(70)));
+  console.log(chalk16.dim("\u2501".repeat(70)));
   console.log("");
   renderColumn(STATUS_CONFIG["in-progress"].label, STATUS_CONFIG["in-progress"].emoji, columns["in-progress"], true, STATUS_CONFIG["in-progress"].colorFn);
-  console.log(chalk15.dim("\u2501".repeat(70)));
+  console.log(chalk16.dim("\u2501".repeat(70)));
   console.log("");
   renderColumn(STATUS_CONFIG.complete.label, STATUS_CONFIG.complete.emoji, columns.complete, options.showComplete || false, STATUS_CONFIG.complete.colorFn);
 }
 function renderColumn(title, emoji, specs, expanded, colorFn) {
-  console.log(`${emoji} ${colorFn(chalk15.bold(`${title} (${specs.length})`))}`);
+  console.log(`${emoji} ${colorFn(chalk16.bold(`${title} (${specs.length})`))}`);
   console.log("");
   if (expanded && specs.length > 0) {
     const priorityGroups = {
@@ -3290,31 +3182,30 @@ function renderColumn(title, emoji, specs, expanded, colorFn) {
       firstGroup = false;
       const priorityLabel = priority === "none" ? "No Priority" : priority.charAt(0).toUpperCase() + priority.slice(1);
       const priorityEmoji = priority === "none" ? "\u26AA" : PRIORITY_CONFIG[priority].emoji;
-      const priorityColor = priority === "none" ? chalk15.dim : PRIORITY_CONFIG[priority].colorFn;
-      console.log(`  ${priorityColor(`${priorityEmoji} ${chalk15.bold(priorityLabel)} ${chalk15.dim(`(${groupSpecs.length})`)}`)}`);
-      ;
+      const priorityColor = priority === "none" ? chalk16.dim : PRIORITY_CONFIG[priority].colorFn;
+      console.log(`  ${priorityColor(`${priorityEmoji} ${chalk16.bold(priorityLabel)} ${chalk16.dim(`(${groupSpecs.length})`)}`)}`);
       for (const spec of groupSpecs) {
         let assigneeStr = "";
         if (spec.frontmatter.assignee) {
-          assigneeStr = " " + chalk15.cyan(`@${sanitizeUserInput(spec.frontmatter.assignee)}`);
+          assigneeStr = " " + chalk16.cyan(`@${sanitizeUserInput(spec.frontmatter.assignee)}`);
         }
         let tagsStr = "";
         if (spec.frontmatter.tags?.length) {
           const tags = Array.isArray(spec.frontmatter.tags) ? spec.frontmatter.tags : [];
           if (tags.length > 0) {
             const tagStr = tags.map((tag) => `#${sanitizeUserInput(tag)}`).join(" ");
-            tagsStr = " " + chalk15.dim(chalk15.magenta(tagStr));
+            tagsStr = " " + chalk16.dim(chalk16.magenta(tagStr));
           }
         }
-        console.log(`    ${chalk15.cyan(sanitizeUserInput(spec.path))}${assigneeStr}${tagsStr}`);
+        console.log(`    ${chalk16.cyan(sanitizeUserInput(spec.path))}${assigneeStr}${tagsStr}`);
       }
     }
     console.log("");
   } else if (!expanded && specs.length > 0) {
-    console.log(`  ${chalk15.dim("(collapsed, use --complete to expand)")}`);
+    console.log(`  ${chalk16.dim("(collapsed, use --complete to expand)")}`);
     console.log("");
   } else {
-    console.log(`  ${chalk15.dim("(empty)")}`);
+    console.log(`  ${chalk16.dim("(empty)")}`);
     console.log("");
   }
 }
@@ -3322,10 +3213,6 @@ function stripAnsi2(str) {
   return str.replace(/\u001b\[\d+m/g, "");
 }
 
-// src/commands/stats.ts
-import chalk16 from "chalk";
-import dayjs4 from "dayjs";
-
 // src/utils/spec-stats.ts
 function countSpecsByStatusAndPriority(specs) {
   const statusCounts = {
@@ -3359,13 +3246,10 @@ function countSpecsByStatusAndPriority(specs) {
   }
   return { statusCounts, priorityCounts, tagCounts };
 }
-
-// src/utils/insights.ts
-import dayjs3 from "dayjs";
 function generateInsights(specs) {
   const insights = [];
   const criticalOverdue = specs.filter(
-    (s) => s.frontmatter.priority === "critical" && s.frontmatter.due && dayjs3(s.frontmatter.due).isBefore(dayjs3(), "day") && s.frontmatter.status !== "complete" && s.frontmatter.status !== "archived"
+    (s) => s.frontmatter.priority === "critical" && s.frontmatter.due && dayjs2(s.frontmatter.due).isBefore(dayjs2(), "day") && s.frontmatter.status !== "complete" && s.frontmatter.status !== "archived"
   );
   if (criticalOverdue.length > 0) {
     insights.push({
@@ -3375,7 +3259,7 @@ function generateInsights(specs) {
     });
   }
   const highOverdue = specs.filter(
-    (s) => s.frontmatter.priority === "high" && s.frontmatter.due && dayjs3(s.frontmatter.due).isBefore(dayjs3(), "day") && s.frontmatter.status !== "complete" && s.frontmatter.status !== "archived"
+    (s) => s.frontmatter.priority === "high" && s.frontmatter.due && dayjs2(s.frontmatter.due).isBefore(dayjs2(), "day") && s.frontmatter.status !== "complete" && s.frontmatter.status !== "archived"
   );
   if (highOverdue.length > 0) {
     insights.push({
@@ -3392,7 +3276,7 @@ function generateInsights(specs) {
     if (!updatedAt) {
       return false;
     }
-    const daysSinceUpdate = dayjs3().diff(dayjs3(updatedAt), "day");
+    const daysSinceUpdate = dayjs2().diff(dayjs2(updatedAt), "day");
     return daysSinceUpdate > 7;
   });
   if (longRunning.length > 0) {
@@ -3425,14 +3309,14 @@ function generateInsights(specs) {
   return insights.slice(0, 5);
 }
 function getSpecInsightDetails(spec) {
-  if (spec.frontmatter.due && dayjs3(spec.frontmatter.due).isBefore(dayjs3(), "day") && spec.frontmatter.status !== "complete" && spec.frontmatter.status !== "archived") {
-    const daysOverdue = dayjs3().diff(dayjs3(spec.frontmatter.due), "day");
+  if (spec.frontmatter.due && dayjs2(spec.frontmatter.due).isBefore(dayjs2(), "day") && spec.frontmatter.status !== "complete" && spec.frontmatter.status !== "archived") {
+    const daysOverdue = dayjs2().diff(dayjs2(spec.frontmatter.due), "day");
     return `overdue by ${daysOverdue} day${daysOverdue > 1 ? "s" : ""}`;
   }
   if (spec.frontmatter.status === "in-progress") {
     const updatedAt = spec.frontmatter.updated || spec.frontmatter.updated_at || spec.frontmatter.created || spec.frontmatter.created_at;
     if (updatedAt) {
-      const daysSinceUpdate = dayjs3().diff(dayjs3(updatedAt), "day");
+      const daysSinceUpdate = dayjs2().diff(dayjs2(updatedAt), "day");
       if (daysSinceUpdate > 7) {
         return `in-progress for ${daysSinceUpdate} days`;
       }
@@ -3462,7 +3346,7 @@ async function statsCommand(options) {
     console.log("No specs found.");
     return;
   }
-  const showFull = options.full || false;
+  options.full || false;
   const showStats = options.full || !options.timeline && !options.velocity;
   const showTimeline = options.timeline || options.full;
   const showVelocity = options.velocity || options.full;
@@ -3532,7 +3416,7 @@ async function statsCommand(options) {
         const criticalInProgress = specs.filter((s) => s.frontmatter.priority === "critical" && s.frontmatter.status === "in-progress").length;
         const criticalComplete = specs.filter((s) => s.frontmatter.priority === "critical" && s.frontmatter.status === "complete").length;
         const criticalOverdue = specs.filter(
-          (s) => s.frontmatter.priority === "critical" && s.frontmatter.due && dayjs4(s.frontmatter.due).isBefore(dayjs4(), "day") && s.frontmatter.status !== "complete"
+          (s) => s.frontmatter.priority === "critical" && s.frontmatter.due && dayjs2(s.frontmatter.due).isBefore(dayjs2(), "day") && s.frontmatter.status !== "complete"
         ).length;
         const parts = [];
         if (criticalPlanned > 0) parts.push(chalk16.dim(`${criticalPlanned} planned`));
@@ -3546,7 +3430,7 @@ async function statsCommand(options) {
         const highInProgress = specs.filter((s) => s.frontmatter.priority === "high" && s.frontmatter.status === "in-progress").length;
         const highComplete = specs.filter((s) => s.frontmatter.priority === "high" && s.frontmatter.status === "complete").length;
         const highOverdue = specs.filter(
-          (s) => s.frontmatter.priority === "high" && s.frontmatter.due && dayjs4(s.frontmatter.due).isBefore(dayjs4(), "day") && s.frontmatter.status !== "complete"
+          (s) => s.frontmatter.priority === "high" && s.frontmatter.due && dayjs2(s.frontmatter.due).isBefore(dayjs2(), "day") && s.frontmatter.status !== "complete"
         ).length;
         const parts = [];
         if (highPlanned > 0) parts.push(chalk16.dim(`${highPlanned} planned`));
@@ -3708,18 +3592,18 @@ async function statsCommand(options) {
   }
   if (showTimeline) {
     const days = 30;
-    const today = dayjs4();
+    const today = dayjs2();
     const startDate = today.subtract(days, "day");
     const createdByDate = {};
     const completedByDate = {};
     for (const spec of specs) {
-      const created = dayjs4(spec.frontmatter.created);
+      const created = dayjs2(spec.frontmatter.created);
       if (created.isAfter(startDate)) {
         const dateKey = created.format("YYYY-MM-DD");
         createdByDate[dateKey] = (createdByDate[dateKey] || 0) + 1;
       }
       if (spec.frontmatter.completed) {
-        const completed = dayjs4(spec.frontmatter.completed);
+        const completed = dayjs2(spec.frontmatter.completed);
         if (completed.isAfter(startDate)) {
           const dateKey = completed.format("YYYY-MM-DD");
           completedByDate[dateKey] = (completedByDate[dateKey] || 0) + 1;
@@ -3838,9 +3722,6 @@ async function statsCommand(options) {
     }
   }
 }
-
-// src/commands/search.ts
-import chalk17 from "chalk";
 async function searchCommand(query, options) {
   await autoCheckIfEnabled();
   const filter = {};
@@ -3884,32 +3765,32 @@ async function searchCommand(query, options) {
   }
   if (results.length === 0) {
     console.log("");
-    console.log(chalk17.yellow(`\u{1F50D} No specs found matching "${sanitizeUserInput(query)}"`));
+    console.log(chalk16.yellow(`\u{1F50D} No specs found matching "${sanitizeUserInput(query)}"`));
     if (Object.keys(filter).length > 0) {
       const filters = [];
       if (options.status) filters.push(`status=${sanitizeUserInput(options.status)}`);
       if (options.tag) filters.push(`tag=${sanitizeUserInput(options.tag)}`);
       if (options.priority) filters.push(`priority=${sanitizeUserInput(options.priority)}`);
       if (options.assignee) filters.push(`assignee=${sanitizeUserInput(options.assignee)}`);
-      console.log(chalk17.gray(`With filters: ${filters.join(", ")}`));
+      console.log(chalk16.gray(`With filters: ${filters.join(", ")}`));
     }
     console.log("");
     return;
   }
   console.log("");
-  console.log(chalk17.green(`\u{1F50D} Found ${results.length} spec${results.length === 1 ? "" : "s"} matching "${sanitizeUserInput(query)}"`));
+  console.log(chalk16.green(`\u{1F50D} Found ${results.length} spec${results.length === 1 ? "" : "s"} matching "${sanitizeUserInput(query)}"`));
   if (Object.keys(filter).length > 0) {
     const filters = [];
     if (options.status) filters.push(`status=${sanitizeUserInput(options.status)}`);
     if (options.tag) filters.push(`tag=${sanitizeUserInput(options.tag)}`);
     if (options.priority) filters.push(`priority=${sanitizeUserInput(options.priority)}`);
     if (options.assignee) filters.push(`assignee=${sanitizeUserInput(options.assignee)}`);
-    console.log(chalk17.gray(`With filters: ${filters.join(", ")}`));
+    console.log(chalk16.gray(`With filters: ${filters.join(", ")}`));
   }
   console.log("");
   for (const result of results) {
     const { spec, matches } = result;
-    console.log(chalk17.cyan(`${spec.frontmatter.status === "in-progress" ? "\u{1F528}" : spec.frontmatter.status === "complete" ? "\u2705" : "\u{1F4C5}"} ${sanitizeUserInput(spec.path)}`));
+    console.log(chalk16.cyan(`${spec.frontmatter.status === "in-progress" ? "\u{1F528}" : spec.frontmatter.status === "complete" ? "\u2705" : "\u{1F4C5}"} ${sanitizeUserInput(spec.path)}`));
     const meta = [];
     if (spec.frontmatter.priority) {
       const priorityEmoji = spec.frontmatter.priority === "critical" ? "\u{1F534}" : spec.frontmatter.priority === "high" ? "\u{1F7E1}" : spec.frontmatter.priority === "medium" ? "\u{1F7E0}" : "\u{1F7E2}";
@@ -3919,34 +3800,30 @@ async function searchCommand(query, options) {
       meta.push(`[${spec.frontmatter.tags.map((tag) => sanitizeUserInput(tag)).join(", ")}]`);
     }
     if (meta.length > 0) {
-      console.log(chalk17.gray(`  ${meta.join(" \u2022 ")}`));
+      console.log(chalk16.gray(`  ${meta.join(" \u2022 ")}`));
     }
     const maxMatches = 3;
     for (let i = 0; i < Math.min(matches.length, maxMatches); i++) {
-      console.log(`  ${chalk17.gray("Match:")} ${matches[i].trim()}`);
+      console.log(`  ${chalk16.gray("Match:")} ${matches[i].trim()}`);
     }
     if (matches.length > maxMatches) {
-      console.log(chalk17.gray(`  ... and ${matches.length - maxMatches} more match${matches.length - maxMatches === 1 ? "" : "es"}`));
+      console.log(chalk16.gray(`  ... and ${matches.length - maxMatches} more match${matches.length - maxMatches === 1 ? "" : "es"}`));
     }
     console.log("");
   }
 }
 function highlightMatch(text, query) {
   const regex = new RegExp(`(${escapeRegex(query)})`, "gi");
-  return text.replace(regex, chalk17.yellow("$1"));
+  return text.replace(regex, chalk16.yellow("$1"));
 }
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-
-// src/commands/deps.ts
-import chalk18 from "chalk";
-import * as path18 from "path";
 async function depsCommand(specPath, options) {
   await autoCheckIfEnabled();
   const config = await loadConfig();
   const cwd = process.cwd();
-  const specsDir = path18.join(cwd, config.specsDir);
+  const specsDir = path2.join(cwd, config.specsDir);
   const resolvedPath = await resolveSpecPath(specPath, cwd, specsDir);
   if (!resolvedPath) {
     throw new Error(`Spec not found: ${sanitizeUserInput(specPath)}`);
@@ -3975,16 +3852,16 @@ async function depsCommand(specPath, options) {
     return;
   }
   console.log("");
-  console.log(chalk18.green(`\u{1F4E6} Dependencies for ${chalk18.cyan(sanitizeUserInput(spec.path))}`));
+  console.log(chalk16.green(`\u{1F4E6} Dependencies for ${chalk16.cyan(sanitizeUserInput(spec.path))}`));
   console.log("");
   const hasAnyRelationships = dependsOn.length > 0 || blocks.length > 0 || relatedSpecs.length > 0;
   if (!hasAnyRelationships) {
-    console.log(chalk18.gray("  No dependencies or relationships"));
+    console.log(chalk16.gray("  No dependencies or relationships"));
     console.log("");
     return;
   }
   if (dependsOn.length > 0) {
-    console.log(chalk18.bold("Depends On:"));
+    console.log(chalk16.bold("Depends On:"));
     for (const dep of dependsOn) {
       const status = getStatusIndicator(dep.frontmatter.status);
       console.log(`  \u2192 ${sanitizeUserInput(dep.path)} ${status}`);
@@ -3992,7 +3869,7 @@ async function depsCommand(specPath, options) {
     console.log("");
   }
   if (blocks.length > 0) {
-    console.log(chalk18.bold("Required By:"));
+    console.log(chalk16.bold("Required By:"));
     for (const blocked of blocks) {
       const status = getStatusIndicator(blocked.frontmatter.status);
       console.log(`  \u2190 ${sanitizeUserInput(blocked.path)} ${status}`);
@@ -4000,7 +3877,7 @@ async function depsCommand(specPath, options) {
     console.log("");
   }
   if (relatedSpecs.length > 0) {
-    console.log(chalk18.bold("Related Specs:"));
+    console.log(chalk16.bold("Related Specs:"));
     for (const rel of relatedSpecs) {
       const status = getStatusIndicator(rel.frontmatter.status);
       console.log(`  \u27F7 ${sanitizeUserInput(rel.path)} ${status}`);
@@ -4008,7 +3885,7 @@ async function depsCommand(specPath, options) {
     console.log("");
   }
   if (options.graph || dependsOn.length > 0) {
-    console.log(chalk18.bold("Dependency Chain:"));
+    console.log(chalk16.bold("Dependency Chain:"));
     const chain = buildDependencyChain(spec, specMap, options.depth || 3);
     displayChain(chain, 0);
     console.log("");
@@ -4022,8 +3899,8 @@ function findDependencies(spec, specMap) {
     if (dep) {
       deps.push(dep);
     } else {
-      for (const [path20, s] of specMap.entries()) {
-        if (path20.includes(depPath)) {
+      for (const [path21, s] of specMap.entries()) {
+        if (path21.includes(depPath)) {
           deps.push(s);
           break;
         }
@@ -4055,8 +3932,8 @@ function findRelated(spec, specMap) {
     if (rel) {
       related.push(rel);
     } else {
-      for (const [path20, s] of specMap.entries()) {
-        if (path20.includes(relPath)) {
+      for (const [path21, s] of specMap.entries()) {
+        if (path21.includes(relPath)) {
           related.push(s);
           break;
         }
@@ -4114,7 +3991,7 @@ function buildDependencyChain(spec, specMap, maxDepth, currentDepth = 0, visited
 function displayChain(node, level) {
   const indent = "  ".repeat(level);
   const status = getStatusIndicator(node.spec.frontmatter.status);
-  const name = level === 0 ? chalk18.cyan(node.spec.path) : node.spec.path;
+  const name = level === 0 ? chalk16.cyan(node.spec.path) : node.spec.path;
   console.log(`${indent}${name} ${status}`);
   for (const dep of node.dependencies) {
     const prefix = "  ".repeat(level) + "\u2514\u2500 ";
@@ -4125,10 +4002,6 @@ function displayChain(node, level) {
     }
   }
 }
-
-// src/commands/timeline.ts
-import chalk19 from "chalk";
-import dayjs5 from "dayjs";
 async function timelineCommand(options) {
   await autoCheckIfEnabled();
   const createBar = (count, maxCount, width, char = "\u2501") => {
@@ -4143,13 +4016,13 @@ async function timelineCommand(options) {
     console.log("No specs found.");
     return;
   }
-  const today = dayjs5();
+  const today = dayjs2();
   const startDate = today.subtract(days, "day");
   const createdByDate = {};
   const completedByDate = {};
   const createdByMonth = {};
   for (const spec of specs) {
-    const created = dayjs5(spec.frontmatter.created);
+    const created = dayjs2(spec.frontmatter.created);
     if (created.isAfter(startDate)) {
       const dateKey = created.format("YYYY-MM-DD");
       createdByDate[dateKey] = (createdByDate[dateKey] || 0) + 1;
@@ -4157,26 +4030,26 @@ async function timelineCommand(options) {
     const monthKey = created.format("MMM YYYY");
     createdByMonth[monthKey] = (createdByMonth[monthKey] || 0) + 1;
     if (spec.frontmatter.completed) {
-      const completed = dayjs5(spec.frontmatter.completed);
+      const completed = dayjs2(spec.frontmatter.completed);
       if (completed.isAfter(startDate)) {
         const dateKey = completed.format("YYYY-MM-DD");
         completedByDate[dateKey] = (completedByDate[dateKey] || 0) + 1;
       }
     }
   }
-  console.log(chalk19.bold.cyan("\u{1F4C8} Spec Timeline"));
+  console.log(chalk16.bold.cyan("\u{1F4C8} Spec Timeline"));
   console.log("");
   const allDates = /* @__PURE__ */ new Set([...Object.keys(createdByDate), ...Object.keys(completedByDate)]);
   const sortedDates = Array.from(allDates).sort();
   if (sortedDates.length > 0) {
-    console.log(chalk19.bold(`\u{1F4C5} Activity (Last ${days} Days)`));
+    console.log(chalk16.bold(`\u{1F4C5} Activity (Last ${days} Days)`));
     console.log("");
     const labelWidth2 = 15;
     const barWidth = 20;
     const specsWidth = 3;
     const colWidth = barWidth + specsWidth;
-    console.log(`  ${"Date".padEnd(labelWidth2)}  ${chalk19.cyan("Created".padEnd(colWidth))}  ${chalk19.green("Completed".padEnd(colWidth))}`);
-    console.log(`  ${chalk19.dim("\u2500".repeat(labelWidth2))}  ${chalk19.dim("\u2500".repeat(colWidth))}  ${chalk19.dim("\u2500".repeat(colWidth))}`);
+    console.log(`  ${"Date".padEnd(labelWidth2)}  ${chalk16.cyan("Created".padEnd(colWidth))}  ${chalk16.green("Completed".padEnd(colWidth))}`);
+    console.log(`  ${chalk16.dim("\u2500".repeat(labelWidth2))}  ${chalk16.dim("\u2500".repeat(colWidth))}  ${chalk16.dim("\u2500".repeat(colWidth))}`);
     const maxCount = Math.max(...Object.values(createdByDate), ...Object.values(completedByDate));
     for (const date of sortedDates) {
       const created = createdByDate[date] || 0;
@@ -4185,61 +4058,61 @@ async function timelineCommand(options) {
       const completedBar = createBar(completed, maxCount, barWidth);
       const createdCol = `${createdBar.padEnd(barWidth)}${created.toString().padStart(specsWidth)}`;
       const completedCol = `${completedBar.padEnd(barWidth)}${completed.toString().padStart(specsWidth)}`;
-      console.log(`  ${chalk19.dim(date.padEnd(labelWidth2))}  ${chalk19.cyan(createdCol)}  ${chalk19.green(completedCol)}`);
+      console.log(`  ${chalk16.dim(date.padEnd(labelWidth2))}  ${chalk16.cyan(createdCol)}  ${chalk16.green(completedCol)}`);
     }
     console.log("");
   }
   const sortedMonths = Object.entries(createdByMonth).sort((a, b) => {
-    const dateA = dayjs5(a[0], "MMM YYYY");
-    const dateB = dayjs5(b[0], "MMM YYYY");
+    const dateA = dayjs2(a[0], "MMM YYYY");
+    const dateB = dayjs2(b[0], "MMM YYYY");
     return dateB.diff(dateA);
   }).slice(0, 6);
   if (sortedMonths.length > 0) {
-    console.log(chalk19.bold("\u{1F4CA} Monthly Overview"));
+    console.log(chalk16.bold("\u{1F4CA} Monthly Overview"));
     console.log("");
     const labelWidth2 = 15;
     const barWidth = 20;
     const specsWidth = 3;
     const colWidth = barWidth + specsWidth;
-    console.log(`  ${"Month".padEnd(labelWidth2)}  ${chalk19.magenta("Specs".padEnd(colWidth))}`);
-    console.log(`  ${chalk19.dim("\u2500".repeat(labelWidth2))}  ${chalk19.dim("\u2500".repeat(colWidth))}`);
+    console.log(`  ${"Month".padEnd(labelWidth2)}  ${chalk16.magenta("Specs".padEnd(colWidth))}`);
+    console.log(`  ${chalk16.dim("\u2500".repeat(labelWidth2))}  ${chalk16.dim("\u2500".repeat(colWidth))}`);
     const maxCount = Math.max(...sortedMonths.map(([, count]) => count));
     for (const [month, count] of sortedMonths) {
       const bar = createBar(count, maxCount, barWidth);
-      console.log(`  ${month.padEnd(labelWidth2)}  ${chalk19.magenta(bar.padEnd(barWidth))}${chalk19.magenta(count.toString().padStart(specsWidth))}`);
+      console.log(`  ${month.padEnd(labelWidth2)}  ${chalk16.magenta(bar.padEnd(barWidth))}${chalk16.magenta(count.toString().padStart(specsWidth))}`);
     }
     console.log("");
   }
   const last7Days = specs.filter((s) => {
     if (!s.frontmatter.completed) return false;
-    const completed = dayjs5(s.frontmatter.completed);
+    const completed = dayjs2(s.frontmatter.completed);
     return completed.isAfter(today.subtract(7, "day"));
   }).length;
   const last30Days = specs.filter((s) => {
     if (!s.frontmatter.completed) return false;
-    const completed = dayjs5(s.frontmatter.completed);
+    const completed = dayjs2(s.frontmatter.completed);
     return completed.isAfter(today.subtract(30, "day"));
   }).length;
-  console.log(chalk19.bold("\u2705 Completion Rate"));
+  console.log(chalk16.bold("\u2705 Completion Rate"));
   console.log("");
   const labelWidth = 15;
   const valueWidth = 5;
   console.log(`  ${"Period".padEnd(labelWidth)}  ${"Specs".padStart(valueWidth)}`);
-  console.log(`  ${chalk19.dim("\u2500".repeat(labelWidth))}  ${chalk19.dim("\u2500".repeat(valueWidth))}`);
-  console.log(`  ${"Last 7 days".padEnd(labelWidth)}  ${chalk19.green(last7Days.toString().padStart(valueWidth))}`);
-  console.log(`  ${"Last 30 days".padEnd(labelWidth)}  ${chalk19.green(last30Days.toString().padStart(valueWidth))}`);
+  console.log(`  ${chalk16.dim("\u2500".repeat(labelWidth))}  ${chalk16.dim("\u2500".repeat(valueWidth))}`);
+  console.log(`  ${"Last 7 days".padEnd(labelWidth)}  ${chalk16.green(last7Days.toString().padStart(valueWidth))}`);
+  console.log(`  ${"Last 30 days".padEnd(labelWidth)}  ${chalk16.green(last30Days.toString().padStart(valueWidth))}`);
   console.log("");
   if (options.byTag) {
     const tagStats = {};
     for (const spec of specs) {
-      const created = dayjs5(spec.frontmatter.created);
+      const created = dayjs2(spec.frontmatter.created);
       const isInRange = created.isAfter(startDate);
       if (isInRange && spec.frontmatter.tags) {
         for (const tag of spec.frontmatter.tags) {
           if (!tagStats[tag]) tagStats[tag] = { created: 0, completed: 0 };
           tagStats[tag].created++;
           if (spec.frontmatter.completed) {
-            const completed = dayjs5(spec.frontmatter.completed);
+            const completed = dayjs2(spec.frontmatter.completed);
             if (completed.isAfter(startDate)) {
               tagStats[tag].completed++;
             }
@@ -4249,9 +4122,9 @@ async function timelineCommand(options) {
     }
     const sortedTags = Object.entries(tagStats).sort((a, b) => b[1].created - a[1].created).slice(0, 10);
     if (sortedTags.length > 0) {
-      console.log(chalk19.bold("\u{1F3F7}\uFE0F  By Tag"));
+      console.log(chalk16.bold("\u{1F3F7}\uFE0F  By Tag"));
       for (const [tag, stats] of sortedTags) {
-        console.log(`  ${chalk19.dim("#")}${tag.padEnd(20)} ${chalk19.cyan(stats.created)} created \xB7 ${chalk19.green(stats.completed)} completed`);
+        console.log(`  ${chalk16.dim("#")}${tag.padEnd(20)} ${chalk16.cyan(stats.created)} created \xB7 ${chalk16.green(stats.completed)} completed`);
       }
       console.log("");
     }
@@ -4260,14 +4133,14 @@ async function timelineCommand(options) {
     const assigneeStats = {};
     for (const spec of specs) {
       if (!spec.frontmatter.assignee) continue;
-      const created = dayjs5(spec.frontmatter.created);
+      const created = dayjs2(spec.frontmatter.created);
       const isInRange = created.isAfter(startDate);
       if (isInRange) {
         const assignee = spec.frontmatter.assignee;
         if (!assigneeStats[assignee]) assigneeStats[assignee] = { created: 0, completed: 0 };
         assigneeStats[assignee].created++;
         if (spec.frontmatter.completed) {
-          const completed = dayjs5(spec.frontmatter.completed);
+          const completed = dayjs2(spec.frontmatter.completed);
           if (completed.isAfter(startDate)) {
             assigneeStats[assignee].completed++;
           }
@@ -4276,18 +4149,14 @@ async function timelineCommand(options) {
     }
     const sortedAssignees = Object.entries(assigneeStats).sort((a, b) => b[1].created - a[1].created);
     if (sortedAssignees.length > 0) {
-      console.log(chalk19.bold("\u{1F464} By Assignee"));
+      console.log(chalk16.bold("\u{1F464} By Assignee"));
       for (const [assignee, stats] of sortedAssignees) {
-        console.log(`  ${chalk19.dim("@")}${assignee.padEnd(20)} ${chalk19.cyan(stats.created)} created \xB7 ${chalk19.green(stats.completed)} completed`);
+        console.log(`  ${chalk16.dim("@")}${assignee.padEnd(20)} ${chalk16.cyan(stats.created)} created \xB7 ${chalk16.green(stats.completed)} completed`);
       }
       console.log("");
     }
   }
 }
-
-// src/commands/gantt.ts
-import chalk20 from "chalk";
-import dayjs6 from "dayjs";
 var SPEC_COLUMN_WIDTH = 43;
 var COLUMN_SEPARATOR = "  ";
 var SPEC_INDENT = "  ";
@@ -4300,10 +4169,10 @@ var STATUS_CONFIG2 = {
   archived: { emoji: "\u{1F4E6}", color: "gray" }
 };
 var PRIORITY_CONFIG3 = {
-  critical: { emoji: "\u{1F534}", label: "CRITICAL", colorFn: chalk20.red },
-  high: { emoji: "\u{1F7E0}", label: "HIGH", colorFn: chalk20.hex("#FFA500") },
-  medium: { emoji: "\u{1F7E1}", label: "MEDIUM", colorFn: chalk20.yellow },
-  low: { emoji: "\u{1F7E2}", label: "LOW", colorFn: chalk20.green }
+  critical: { emoji: "\u{1F534}", label: "CRITICAL", colorFn: chalk16.red },
+  high: { emoji: "\u{1F7E0}", label: "HIGH", colorFn: chalk16.hex("#FFA500") },
+  medium: { emoji: "\u{1F7E1}", label: "MEDIUM", colorFn: chalk16.yellow },
+  low: { emoji: "\u{1F7E2}", label: "LOW", colorFn: chalk16.green }
 };
 async function ganttCommand(options) {
   await autoCheckIfEnabled();
@@ -4326,8 +4195,8 @@ async function ganttCommand(options) {
     return spec.frontmatter.status !== "archived";
   });
   if (relevantSpecs.length === 0) {
-    console.log(chalk20.dim("No active specs found."));
-    console.log(chalk20.dim("Tip: Use --show-complete to include completed specs."));
+    console.log(chalk16.dim("No active specs found."));
+    console.log(chalk16.dim("Tip: Use --show-complete to include completed specs."));
     return;
   }
   const groupedSpecs = {
@@ -4336,12 +4205,9 @@ async function ganttCommand(options) {
     medium: [],
     low: []
   };
-  const noPrioritySpecs = [];
   for (const spec of relevantSpecs) {
     if (spec.frontmatter.priority && spec.frontmatter.priority in groupedSpecs) {
       groupedSpecs[spec.frontmatter.priority].push(spec);
-    } else {
-      noPrioritySpecs.push(spec);
     }
   }
   const sortSpecs = (specs2) => {
@@ -4353,20 +4219,20 @@ async function ganttCommand(options) {
       if (a.frontmatter.due && !b.frontmatter.due) return -1;
       if (!a.frontmatter.due && b.frontmatter.due) return 1;
       if (a.frontmatter.due && b.frontmatter.due) {
-        return dayjs6(a.frontmatter.due).diff(dayjs6(b.frontmatter.due));
+        return dayjs2(a.frontmatter.due).diff(dayjs2(b.frontmatter.due));
       }
       return 0;
     });
   };
-  const today = dayjs6();
+  const today = dayjs2();
   const startDate = today.startOf("week");
   const endDate = startDate.add(weeks, "week");
   const inProgress = relevantSpecs.filter((s) => s.frontmatter.status === "in-progress").length;
   const planned = relevantSpecs.filter((s) => s.frontmatter.status === "planned").length;
   const overdue = relevantSpecs.filter(
-    (s) => s.frontmatter.due && dayjs6(s.frontmatter.due).isBefore(today) && s.frontmatter.status !== "complete"
+    (s) => s.frontmatter.due && dayjs2(s.frontmatter.due).isBefore(today) && s.frontmatter.status !== "complete"
   ).length;
-  console.log(chalk20.bold.cyan(`\u{1F4C5} Gantt Chart (${weeks} weeks from ${startDate.format("MMM D, YYYY")})`));
+  console.log(chalk16.bold.cyan(`\u{1F4C5} Gantt Chart (${weeks} weeks from ${startDate.format("MMM D, YYYY")})`));
   console.log("");
   const specHeader = "Spec".padEnd(SPEC_COLUMN_WIDTH);
   const timelineHeader = "Timeline";
@@ -4378,17 +4244,17 @@ async function ganttCommand(options) {
     calendarDates.push(dateStr);
   }
   const dateRow = " ".repeat(SPEC_COLUMN_WIDTH) + COLUMN_SEPARATOR + calendarDates.join("");
-  console.log(chalk20.dim(dateRow));
+  console.log(chalk16.dim(dateRow));
   const specSeparator = "\u2500".repeat(SPEC_COLUMN_WIDTH);
   const timelineSeparator = "\u2500".repeat(timelineColumnWidth);
-  console.log(chalk20.dim(specSeparator + COLUMN_SEPARATOR + timelineSeparator));
+  console.log(chalk16.dim(specSeparator + COLUMN_SEPARATOR + timelineSeparator));
   const todayWeekOffset = today.diff(startDate, "week");
   const todayMarkerPos = todayWeekOffset * 8;
   let todayMarker = " ".repeat(SPEC_COLUMN_WIDTH) + COLUMN_SEPARATOR;
   if (todayMarkerPos >= 0 && todayMarkerPos < timelineColumnWidth) {
     todayMarker += " ".repeat(todayMarkerPos) + "\u2502 Today";
   }
-  console.log(chalk20.dim(todayMarker));
+  console.log(chalk16.dim(todayMarker));
   console.log("");
   const priorities = ["critical", "high", "medium", "low"];
   for (const priority of priorities) {
@@ -4406,13 +4272,12 @@ async function ganttCommand(options) {
   const summaryParts = [];
   if (inProgress > 0) summaryParts.push(`${inProgress} in-progress`);
   if (planned > 0) summaryParts.push(`${planned} planned`);
-  if (overdue > 0) summaryParts.push(chalk20.red(`${overdue} overdue`));
-  console.log(chalk20.bold("Summary: ") + summaryParts.join(" \xB7 "));
-  console.log(chalk20.dim('\u{1F4A1} Tip: Add "due: YYYY-MM-DD" to frontmatter for timeline planning'));
+  if (overdue > 0) summaryParts.push(chalk16.red(`${overdue} overdue`));
+  console.log(chalk16.bold("Summary: ") + summaryParts.join(" \xB7 "));
+  console.log(chalk16.dim('\u{1F4A1} Tip: Add "due: YYYY-MM-DD" to frontmatter for timeline planning'));
 }
 function renderSpecRow(spec, startDate, endDate, weeks, today) {
   const statusConfig = STATUS_CONFIG2[spec.frontmatter.status];
-  const timelineColumnWidth = weeks * 8;
   const emoji = statusConfig.emoji;
   const maxNameLength = SPEC_COLUMN_WIDTH - 2;
   let specName = spec.name;
@@ -4422,7 +4287,7 @@ function renderSpecRow(spec, startDate, endDate, weeks, today) {
   const specColumn = `${SPEC_INDENT}${emoji} ${specName}`.padEnd(SPEC_COLUMN_WIDTH);
   let timelineColumn;
   if (!spec.frontmatter.due) {
-    timelineColumn = chalk20.dim("(no due date set)");
+    timelineColumn = chalk16.dim("(no due date set)");
   } else {
     timelineColumn = renderTimelineBar(spec, startDate, endDate, weeks, today);
   }
@@ -4431,7 +4296,7 @@ function renderSpecRow(spec, startDate, endDate, weeks, today) {
 function renderTimelineBar(spec, startDate, endDate, weeks, today) {
   const charsPerWeek = 8;
   const totalChars = weeks * charsPerWeek;
-  const due = dayjs6(spec.frontmatter.due);
+  const due = dayjs2(spec.frontmatter.due);
   const specStart = today;
   const startDaysFromStart = specStart.diff(startDate, "day");
   const dueDaysFromStart = due.diff(startDate, "day");
@@ -4445,13 +4310,13 @@ function renderTimelineBar(spec, startDate, endDate, weeks, today) {
     result += " ".repeat(barStart);
   }
   if (spec.frontmatter.status === "complete") {
-    result += chalk20.green(FILLED_BAR_CHAR.repeat(barLength));
+    result += chalk16.green(FILLED_BAR_CHAR.repeat(barLength));
   } else if (spec.frontmatter.status === "in-progress") {
     const halfLength = Math.floor(barLength / 2);
-    result += chalk20.yellow(FILLED_BAR_CHAR.repeat(halfLength));
-    result += chalk20.dim(EMPTY_BAR_CHAR.repeat(barLength - halfLength));
+    result += chalk16.yellow(FILLED_BAR_CHAR.repeat(halfLength));
+    result += chalk16.dim(EMPTY_BAR_CHAR.repeat(barLength - halfLength));
   } else {
-    result += chalk20.dim(EMPTY_BAR_CHAR.repeat(barLength));
+    result += chalk16.dim(EMPTY_BAR_CHAR.repeat(barLength));
   }
   const trailingSpace = totalChars - barEnd;
   if (trailingSpace > 0) {
@@ -4459,18 +4324,157 @@ function renderTimelineBar(spec, startDate, endDate, weeks, today) {
   }
   return result;
 }
-
-// src/commands/viewer.ts
-import * as fs14 from "fs/promises";
-import * as path19 from "path";
-import chalk21 from "chalk";
-import { marked } from "marked";
-import { markedTerminal } from "marked-terminal";
-import { spawn } from "child_process";
+async function tokensCommand(specPath, options = {}) {
+  await autoCheckIfEnabled();
+  const counter = new TokenCounter();
+  try {
+    const config = await loadConfig();
+    const cwd = process.cwd();
+    const specsDir = path2.join(cwd, config.specsDir);
+    const resolvedPath = await resolveSpecPath(specPath, cwd, specsDir);
+    if (!resolvedPath) {
+      throw new Error(`Spec not found: ${sanitizeUserInput(specPath)}`);
+    }
+    const specName = path2.basename(resolvedPath);
+    const result = await counter.countSpec(resolvedPath, {
+      detailed: options.detailed,
+      includeSubSpecs: options.includeSubSpecs
+    });
+    if (options.json) {
+      console.log(JSON.stringify({
+        spec: specName,
+        path: resolvedPath,
+        ...result
+      }, null, 2));
+      return;
+    }
+    console.log(chalk16.bold.cyan(`\u{1F4CA} Token Count: ${specName}`));
+    console.log("");
+    const indicators = counter.getPerformanceIndicators(result.total);
+    const levelEmoji = indicators.level === "excellent" ? "\u2705" : indicators.level === "good" ? "\u{1F44D}" : indicators.level === "warning" ? "\u26A0\uFE0F" : "\u{1F534}";
+    console.log(`  Total: ${chalk16.cyan(result.total.toLocaleString())} tokens ${levelEmoji}`);
+    console.log("");
+    if (result.files.length > 1 || options.detailed) {
+      console.log(chalk16.bold("Files:"));
+      console.log("");
+      for (const file of result.files) {
+        const lineInfo = file.lines ? chalk16.dim(` (${file.lines} lines)`) : "";
+        console.log(`  ${file.path.padEnd(25)}  ${chalk16.cyan(file.tokens.toLocaleString().padStart(6))} tokens${lineInfo}`);
+      }
+      console.log("");
+    }
+    if (options.detailed && result.breakdown) {
+      const b = result.breakdown;
+      const total = b.code + b.prose + b.tables + b.frontmatter;
+      console.log(chalk16.bold("Content Breakdown:"));
+      console.log("");
+      console.log(`  Prose       ${chalk16.cyan(b.prose.toLocaleString().padStart(6))} tokens  ${chalk16.dim(`(${Math.round(b.prose / total * 100)}%)`)}`);
+      console.log(`  Code        ${chalk16.cyan(b.code.toLocaleString().padStart(6))} tokens  ${chalk16.dim(`(${Math.round(b.code / total * 100)}%)`)}`);
+      console.log(`  Tables      ${chalk16.cyan(b.tables.toLocaleString().padStart(6))} tokens  ${chalk16.dim(`(${Math.round(b.tables / total * 100)}%)`)}`);
+      console.log(`  Frontmatter ${chalk16.cyan(b.frontmatter.toLocaleString().padStart(6))} tokens  ${chalk16.dim(`(${Math.round(b.frontmatter / total * 100)}%)`)}`);
+      console.log("");
+    }
+    console.log(chalk16.bold("Performance Indicators:"));
+    console.log("");
+    const costColor = indicators.costMultiplier < 2 ? chalk16.green : indicators.costMultiplier < 4 ? chalk16.yellow : chalk16.red;
+    const effectivenessColor = indicators.effectiveness >= 95 ? chalk16.green : indicators.effectiveness >= 85 ? chalk16.yellow : chalk16.red;
+    console.log(`  Cost multiplier:  ${costColor(`${indicators.costMultiplier}x`)} ${chalk16.dim("vs 1,200 token baseline")}`);
+    console.log(`  AI effectiveness: ${effectivenessColor(`~${indicators.effectiveness}%`)} ${chalk16.dim("(hypothesis)")}`);
+    console.log(`  Context Economy:  ${levelEmoji} ${indicators.recommendation}`);
+    console.log("");
+    if (!options.includeSubSpecs && result.files.length === 1) {
+      console.log(chalk16.dim("\u{1F4A1} Use `--include-sub-specs` to count all sub-spec files"));
+    }
+  } finally {
+    counter.dispose();
+  }
+}
+async function tokensAllCommand(options = {}) {
+  await autoCheckIfEnabled();
+  const specs = await withSpinner(
+    "Loading specs...",
+    () => loadAllSpecs({ includeArchived: false })
+  );
+  if (specs.length === 0) {
+    console.log("No specs found.");
+    return;
+  }
+  const counter = new TokenCounter();
+  const results = [];
+  try {
+    for (const spec of specs) {
+      const result = await counter.countSpec(spec.fullPath, {
+        includeSubSpecs: options.includeSubSpecs
+      });
+      const indicators = counter.getPerformanceIndicators(result.total);
+      const totalLines = result.files.reduce((sum, f) => sum + (f.lines || 0), 0);
+      results.push({
+        name: spec.name,
+        path: spec.fullPath,
+        tokens: result.total,
+        lines: totalLines,
+        level: indicators.level
+      });
+    }
+  } finally {
+    counter.dispose();
+  }
+  const sortBy = options.sortBy || "tokens";
+  results.sort((a, b) => {
+    if (sortBy === "tokens") return b.tokens - a.tokens;
+    if (sortBy === "lines") return b.lines - a.lines;
+    return a.name.localeCompare(b.name);
+  });
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  console.log(chalk16.bold.cyan("\u{1F4CA} Token Counts"));
+  console.log("");
+  console.log(chalk16.dim(`Sorted by: ${sortBy}`));
+  console.log("");
+  const totalTokens = results.reduce((sum, r) => sum + r.tokens, 0);
+  const avgTokens = Math.round(totalTokens / results.length);
+  const warningCount = results.filter((r) => r.level === "warning" || r.level === "problem").length;
+  console.log(chalk16.bold("Summary:"));
+  console.log("");
+  console.log(`  Total specs:    ${chalk16.cyan(results.length)}`);
+  console.log(`  Total tokens:   ${chalk16.cyan(totalTokens.toLocaleString())}`);
+  console.log(`  Average tokens: ${chalk16.cyan(avgTokens.toLocaleString())}`);
+  if (warningCount > 0) {
+    console.log(`  Needs review:   ${chalk16.yellow(warningCount)} specs ${chalk16.dim("(\u26A0\uFE0F  or \u{1F534})")}`);
+  }
+  console.log("");
+  const nameCol = 35;
+  const tokensCol = 10;
+  const linesCol = 8;
+  console.log(chalk16.bold(
+    "Spec".padEnd(nameCol) + "Tokens".padStart(tokensCol) + "Lines".padStart(linesCol) + "  Status"
+  ));
+  console.log(chalk16.dim("\u2500".repeat(nameCol + tokensCol + linesCol + 10)));
+  const displayCount = options.all ? results.length : Math.min(20, results.length);
+  for (let i = 0; i < displayCount; i++) {
+    const r = results[i];
+    const emoji = r.level === "excellent" ? "\u2705" : r.level === "good" ? "\u{1F44D}" : r.level === "warning" ? "\u26A0\uFE0F" : "\u{1F534}";
+    const tokensColor = r.level === "excellent" || r.level === "good" ? chalk16.cyan : r.level === "warning" ? chalk16.yellow : chalk16.red;
+    const name = r.name.length > nameCol - 2 ? r.name.substring(0, nameCol - 3) + "\u2026" : r.name;
+    console.log(
+      name.padEnd(nameCol) + tokensColor(r.tokens.toLocaleString().padStart(tokensCol)) + chalk16.dim(r.lines.toString().padStart(linesCol)) + `  ${emoji}`
+    );
+  }
+  if (results.length > displayCount) {
+    console.log("");
+    console.log(chalk16.dim(`... and ${results.length - displayCount} more specs`));
+    console.log(chalk16.dim(`Use --all to show all specs`));
+  }
+  console.log("");
+  console.log(chalk16.dim("Legend: \u2705 excellent (<2K) | \u{1F44D} good (<3.5K) | \u26A0\uFE0F  warning (<5K) | \u{1F534} problem (>5K)"));
+  console.log("");
+}
 marked.use(markedTerminal());
 async function readSpecContent(specPath, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
-  const specsDir = path19.join(cwd, config.specsDir);
+  const specsDir = path2.join(cwd, config.specsDir);
   let resolvedPath = null;
   let targetFile = null;
   const pathParts = specPath.split("/").filter((p) => p);
@@ -4479,9 +4483,9 @@ async function readSpecContent(specPath, cwd = process.cwd()) {
     const filePart = pathParts[pathParts.length - 1];
     resolvedPath = await resolveSpecPath(specPart, cwd, specsDir);
     if (resolvedPath) {
-      targetFile = path19.join(resolvedPath, filePart);
+      targetFile = path2.join(resolvedPath, filePart);
       try {
-        await fs14.access(targetFile);
+        await fs9.access(targetFile);
       } catch {
         return null;
       }
@@ -4500,8 +4504,8 @@ async function readSpecContent(specPath, cwd = process.cwd()) {
   if (!targetFile) {
     return null;
   }
-  const rawContent = await fs14.readFile(targetFile, "utf-8");
-  const fileName = path19.basename(targetFile);
+  const rawContent = await fs9.readFile(targetFile, "utf-8");
+  const fileName = path2.basename(targetFile);
   const isSubSpec = fileName !== config.structure.defaultFile;
   let frontmatter = null;
   if (!isSubSpec) {
@@ -4530,7 +4534,7 @@ async function readSpecContent(specPath, cwd = process.cwd()) {
     }
   }
   const content = lines.slice(contentStartIndex).join("\n").trim();
-  const specName = path19.basename(resolvedPath);
+  const specName = path2.basename(resolvedPath);
   const displayName = isSubSpec ? `${specName}/${fileName}` : specName;
   return {
     frontmatter,
@@ -4551,7 +4555,7 @@ function formatFrontmatter(frontmatter) {
     archived: "\u{1F4E6}"
   };
   const statusEmoji = statusEmojis[frontmatter.status] || "\u{1F4C4}";
-  lines.push(chalk21.bold(`${statusEmoji} Status: `) + chalk21.cyan(frontmatter.status));
+  lines.push(chalk16.bold(`${statusEmoji} Status: `) + chalk16.cyan(frontmatter.status));
   if (frontmatter.priority) {
     const priorityEmojis = {
       low: "\u{1F7E2}",
@@ -4560,25 +4564,25 @@ function formatFrontmatter(frontmatter) {
       critical: "\u{1F534}"
     };
     const priorityEmoji = priorityEmojis[frontmatter.priority] || "";
-    lines.push(chalk21.bold(`${priorityEmoji} Priority: `) + chalk21.yellow(frontmatter.priority));
+    lines.push(chalk16.bold(`${priorityEmoji} Priority: `) + chalk16.yellow(frontmatter.priority));
   }
   if (frontmatter.created) {
-    lines.push(chalk21.bold("\u{1F4C6} Created: ") + chalk21.gray(String(frontmatter.created)));
+    lines.push(chalk16.bold("\u{1F4C6} Created: ") + chalk16.gray(String(frontmatter.created)));
   }
   if (frontmatter.tags && frontmatter.tags.length > 0) {
-    const tagStr = frontmatter.tags.map((tag) => chalk21.blue(`#${tag}`)).join(" ");
-    lines.push(chalk21.bold("\u{1F3F7}\uFE0F  Tags: ") + tagStr);
+    const tagStr = frontmatter.tags.map((tag) => chalk16.blue(`#${tag}`)).join(" ");
+    lines.push(chalk16.bold("\u{1F3F7}\uFE0F  Tags: ") + tagStr);
   }
   if (frontmatter.assignee) {
-    lines.push(chalk21.bold("\u{1F464} Assignee: ") + chalk21.green(frontmatter.assignee));
+    lines.push(chalk16.bold("\u{1F464} Assignee: ") + chalk16.green(frontmatter.assignee));
   }
   const standardFields = ["status", "priority", "created", "tags", "assignee"];
   const customFields = Object.entries(frontmatter).filter(([key]) => !standardFields.includes(key)).filter(([_, value]) => value !== void 0 && value !== null);
   if (customFields.length > 0) {
     lines.push("");
-    lines.push(chalk21.bold("Custom Fields:"));
+    lines.push(chalk16.bold("Custom Fields:"));
     for (const [key, value] of customFields) {
-      lines.push(`  ${chalk21.gray(key)}: ${chalk21.white(String(value))}`);
+      lines.push(`  ${chalk16.gray(key)}: ${chalk16.white(String(value))}`);
     }
   }
   return lines.join("\n");
@@ -4586,11 +4590,11 @@ function formatFrontmatter(frontmatter) {
 function displayFormattedSpec(spec) {
   const output = [];
   output.push("");
-  output.push(chalk21.bold.cyan(`\u2501\u2501\u2501 ${spec.name} \u2501\u2501\u2501`));
+  output.push(chalk16.bold.cyan(`\u2501\u2501\u2501 ${spec.name} \u2501\u2501\u2501`));
   output.push("");
   output.push(formatFrontmatter(spec.frontmatter));
   output.push("");
-  output.push(chalk21.gray("\u2500".repeat(60)));
+  output.push(chalk16.gray("\u2500".repeat(60)));
   output.push("");
   return output.join("\n");
 }
@@ -4620,7 +4624,7 @@ async function viewCommand(specPath, options = {}) {
 async function openCommand(specPath, options = {}) {
   const cwd = process.cwd();
   const config = await loadConfig(cwd);
-  const specsDir = path19.join(cwd, config.specsDir);
+  const specsDir = path2.join(cwd, config.specsDir);
   let resolvedPath = null;
   let targetFile = null;
   const pathParts = specPath.split("/").filter((p) => p);
@@ -4629,9 +4633,9 @@ async function openCommand(specPath, options = {}) {
     const filePart = pathParts[pathParts.length - 1];
     resolvedPath = await resolveSpecPath(specPart, cwd, specsDir);
     if (resolvedPath) {
-      targetFile = path19.join(resolvedPath, filePart);
+      targetFile = path2.join(resolvedPath, filePart);
       try {
-        await fs14.access(targetFile);
+        await fs9.access(targetFile);
       } catch {
         targetFile = null;
       }
@@ -4649,7 +4653,6 @@ async function openCommand(specPath, options = {}) {
   } else if (!targetFile) {
     throw new Error(`Sub-spec file not found: ${specPath}`);
   }
-  const specFile = targetFile;
   let editor = options.editor;
   if (!editor) {
     editor = process.env.VISUAL || process.env.EDITOR;
@@ -4664,7 +4667,7 @@ async function openCommand(specPath, options = {}) {
       editor = "xdg-open";
     }
   }
-  console.log(chalk21.gray(`Opening ${targetFile} with ${editor}...`));
+  console.log(chalk16.gray(`Opening ${targetFile} with ${editor}...`));
   const child = spawn(editor, [targetFile], {
     stdio: "inherit",
     shell: true
@@ -4694,9 +4697,6 @@ async function openCommand(specPath, options = {}) {
     });
   }
 }
-
-// src/commands/mcp.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 async function mcpCommand() {
   try {
     const server = await createMcpServer();
@@ -4708,15 +4708,10 @@ async function mcpCommand() {
     process.exit(1);
   }
 }
-
-// src/mcp-server.ts
-import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join18 } from "path";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname3 = dirname3(__filename2);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename);
 var packageJson = JSON.parse(
-  readFileSync(join18(__dirname3, "../package.json"), "utf-8")
+  readFileSync(join(__dirname2, "../package.json"), "utf-8")
 );
 function formatErrorMessage(prefix, error) {
   const errorMsg = error instanceof Error ? error.message : String(error);
@@ -5626,31 +5621,6 @@ Please search for this topic and show me the dependencies between related specs.
   return server;
 }
 
-export {
-  checkSpecs,
-  createSpec,
-  archiveSpec,
-  listSpecs,
-  updateSpec,
-  backfillTimestamps,
-  listTemplates,
-  showTemplate,
-  addTemplate,
-  removeTemplate,
-  copyTemplate,
-  initProject,
-  filesCommand,
-  validateCommand,
-  migrateCommand,
-  boardCommand,
-  statsCommand,
-  searchCommand,
-  depsCommand,
-  timelineCommand,
-  ganttCommand,
-  viewCommand,
-  openCommand,
-  createMcpServer,
-  mcpCommand
-};
-//# sourceMappingURL=chunk-J7ZSZ5VJ.js.map
+export { addTemplate, archiveSpec, backfillTimestamps, boardCommand, checkSpecs, copyTemplate, createMcpServer, createSpec, depsCommand, filesCommand, ganttCommand, initProject, listSpecs, listTemplates, mcpCommand, migrateCommand, openCommand, removeTemplate, searchCommand, showTemplate, statsCommand, timelineCommand, tokensAllCommand, tokensCommand, updateSpec, validateCommand, viewCommand };
+//# sourceMappingURL=chunk-ER23B6KS.js.map
+//# sourceMappingURL=chunk-ER23B6KS.js.map