lean-spec 0.2.0 → 0.2.2

package/dist/{chunk-J7ZSZ5VJ.js → chunk-7MCDTSVE.js}

@@ -1,23 +1,25 @@
-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 { readFile, writeFile } from 'fs/promises';
+import * as path2 from 'path';
+import { dirname, join } from 'path';
+import chalk16 from 'chalk';
+import matter4 from 'gray-matter';
+import yaml3 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 { encoding_for_model } from 'tiktoken';
+import dayjs3 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 +41,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 +53,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,22 +138,22 @@ 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 stat6 = await fs9.stat(filePath);
       const ext = path2.extname(entry.name).toLowerCase();
       const isDocument = ext === ".md";
       const subFile = {
         name: entry.name,
         path: filePath,
-        size: stat5.size,
+        size: stat6.size,
         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 +173,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 +214,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 +289,7 @@ async function getSpec(specPath) {
     fullPath = path2.join(specsDir, specPath);
   }
   try {
-    await fs2.access(fullPath);
+    await fs9.access(fullPath);
   } catch {
     return null;
   }
@@ -295,7 +297,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 +312,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 +321,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 +332,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 +349,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 +383,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 +406,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 +422,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 +443,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 +525,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 +545,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 +554,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 +574,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 +618,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 +639,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,17 +662,17 @@ 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 });
     content = resolveVariables(template, varContext);
-    const parsed = matter(content, {
+    const parsed = matter4(content, {
       engines: {
-        yaml: (str) => yaml.load(str, { schema: yaml.FAILSAFE_SCHEMA })
+        yaml: (str) => yaml3.load(str, { schema: yaml3.FAILSAFE_SCHEMA })
       }
     });
     normalizeDateFields(parsed.data);
@@ -722,9 +695,9 @@ async function createSpec(name, options = {}) {
       frontmatter: parsed.data
     };
     parsed.content = resolveVariables(parsed.content, contextWithFrontmatter);
-    const { enrichWithTimestamps } = await import("./frontmatter-26SOQGYM.js");
-    enrichWithTimestamps(parsed.data);
-    content = matter.stringify(parsed.content, parsed.data);
+    const { enrichWithTimestamps: enrichWithTimestamps2 } = await import('./frontmatter-R2DANL5X.js');
+    enrichWithTimestamps2(parsed.data);
+    content = matter4.stringify(parsed.content, parsed.data);
     if (options.description) {
       content = content.replace(
         /## Overview\s+<!-- What are we solving\? Why now\? -->/,
@@ -736,21 +709,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 +727,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 +758,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 +829,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 +854,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 +870,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 +880,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 +888,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 +928,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 +936,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 +980,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 +1000,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 +1011,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 +1022,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 +1043,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 +1055,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 +1103,7 @@ function extractGitTimestamps(filePath, options = {}) {
 }
 function fileExistsInGit(filePath) {
   try {
-    execSync2(
+    execSync(
       `git log -n 1 -- "${filePath}"`,
       { stdio: "ignore", encoding: "utf-8" }
     );
@@ -1176,7 +1126,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 +1298,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 sizeKB = (stat5.size / 1024).toFixed(1);
+    const filePath = path2.join(templatesDir, file);
+    const stat6 = await fs9.stat(filePath);
+    const sizeKB = (stat6.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 +1380,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 +1444,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 +1453,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 +1466,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 +1498,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 +1523,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 +1543,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 +1565,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 +1573,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 +1627,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 +1677,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 +1705,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 +1743,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 +1775,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 +1789,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 +1815,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 +1827,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 +1841,9 @@ var FrontmatterValidator = class {
     const warnings = [];
     let parsed;
     try {
-      parsed = matter2(content, {
+      parsed = matter4(content, {
         engines: {
-          yaml: (str) => yaml2.load(str, { schema: yaml2.FAILSAFE_SCHEMA })
+          yaml: (str) => yaml3.load(str, { schema: yaml3.FAILSAFE_SCHEMA })
         }
       });
     } catch (error) {
@@ -2078,9 +1957,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 +1971,7 @@ var StructureValidator = class {
     const warnings = [];
     let parsed;
     try {
-      parsed = matter3(content);
+      parsed = matter4(content);
     } catch (error) {
       errors.push({
         message: "Failed to parse frontmatter",
@@ -2112,33 +1988,6 @@ var StructureValidator = class {
       });
     }
     const headings = this.extractHeadings(body);
-    for (const requiredSection of this.requiredSections) {
-      const found = headings.some(
-        (h) => h.level === 2 && h.text.toLowerCase() === requiredSection.toLowerCase()
-      );
-      if (!found) {
-        if (this.strict) {
-          errors.push({
-            message: `Missing required section: ## ${requiredSection}`,
-            suggestion: `Add ## ${requiredSection} section to the spec`
-          });
-        } else {
-          warnings.push({
-            message: `Recommended section missing: ## ${requiredSection}`,
-            suggestion: `Consider adding ## ${requiredSection} section`
-          });
-        }
-      }
-    }
-    const emptySections = this.findEmptySections(body, headings);
-    for (const section of emptySections) {
-      if (this.requiredSections.some((req) => req.toLowerCase() === section.toLowerCase())) {
-        warnings.push({
-          message: `Empty required section: ## ${section}`,
-          suggestion: "Add content to this section or remove it"
-        });
-      }
-    }
     const duplicates = this.findDuplicateHeaders(headings);
     for (const dup of duplicates) {
       errors.push({
@@ -2424,226 +2273,1307 @@ 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;
-  warningThreshold;
-  checkCrossReferences;
-  constructor(options = {}) {
-    this.maxLines = options.maxLines ?? 400;
-    this.warningThreshold = options.warningThreshold ?? 300;
-    this.checkCrossReferences = options.checkCrossReferences ?? true;
+function normalizeDateFields2(data) {
+  const dateFields = ["created", "completed", "updated", "due"];
+  for (const field of dateFields) {
+    if (data[field] instanceof Date) {
+      data[field] = data[field].toISOString().split("T")[0];
+    }
   }
-  async validate(spec, content) {
-    const errors = [];
-    const warnings = [];
-    const subFiles = await loadSubFiles(spec.fullPath, { includeContent: true });
-    const subSpecs = subFiles.filter((f) => f.type === "document");
-    if (subSpecs.length === 0) {
-      return { passed: true, errors, warnings };
+}
+function enrichWithTimestamps(data, previousData) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (!data.created_at) {
+    data.created_at = now;
+  }
+  if (previousData) {
+    data.updated_at = now;
+  }
+  if (data.status === "complete" && previousData?.status !== "complete" && !data.completed_at) {
+    data.completed_at = now;
+    if (!data.completed) {
+      data.completed = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     }
-    this.validateNamingConventions(subSpecs, warnings);
-    await this.validateLineCounts(subSpecs, errors, warnings);
-    this.checkOrphanedSubSpecs(subSpecs, content, warnings);
-    if (this.checkCrossReferences) {
-      await this.validateCrossReferences(subSpecs, spec, warnings);
+  }
+  if (previousData && data.status !== previousData.status) {
+    if (!Array.isArray(data.transitions)) {
+      data.transitions = [];
     }
-    return {
-      passed: errors.length === 0,
-      errors,
-      warnings
-    };
+    data.transitions.push({
+      status: data.status,
+      at: now
+    });
   }
-  /**
-   * Validate sub-spec naming conventions
-   * Convention: Uppercase filenames (e.g., DESIGN.md, TESTING.md, IMPLEMENTATION.md)
-   */
-  validateNamingConventions(subSpecs, warnings) {
-    for (const subSpec of subSpecs) {
-      const baseName = path15.basename(subSpec.name, ".md");
-      if (baseName !== baseName.toUpperCase()) {
-        warnings.push({
-          message: `Sub-spec filename should be uppercase: ${subSpec.name}`,
-          suggestion: `Consider renaming to ${baseName.toUpperCase()}.md`
-        });
+}
+function normalizeTagsField(data) {
+  if (data.tags && typeof data.tags === "string") {
+    try {
+      const parsed = JSON.parse(data.tags);
+      if (Array.isArray(parsed)) {
+        data.tags = parsed;
       }
+    } catch {
+      data.tags = data.tags.split(",").map((t) => t.trim());
     }
   }
-  /**
-   * Validate line counts for each sub-spec file
-   */
-  async validateLineCounts(subSpecs, errors, warnings) {
-    for (const subSpec of subSpecs) {
-      if (!subSpec.content) {
-        continue;
+}
+function validateCustomFields(frontmatter, config) {
+  {
+    return frontmatter;
+  }
+}
+function parseFrontmatterFromString(content, filePath, config) {
+  try {
+    const parsed = matter4(content, {
+      engines: {
+        yaml: (str) => yaml3.load(str, { schema: yaml3.FAILSAFE_SCHEMA })
       }
-      const lines = subSpec.content.split("\n").length;
-      if (lines > this.maxLines) {
-        errors.push({
-          message: `Sub-spec ${subSpec.name} exceeds ${this.maxLines} lines (${lines} lines)`,
-          suggestion: "Consider further splitting or simplification"
-        });
-      } else if (lines > this.warningThreshold) {
-        warnings.push({
-          message: `Sub-spec ${subSpec.name} approaching limit (${lines}/${this.maxLines} lines)`,
-          suggestion: "Consider simplification"
-        });
+    });
+    if (!parsed.data || Object.keys(parsed.data).length === 0) {
+      return parseFallbackFields(content);
+    }
+    if (!parsed.data.status) {
+      if (filePath) ;
+      return null;
+    }
+    if (!parsed.data.created) {
+      if (filePath) ;
+      return null;
+    }
+    const validStatuses = ["planned", "in-progress", "complete", "archived"];
+    if (!validStatuses.includes(parsed.data.status)) {
+      if (filePath) ;
+    }
+    if (parsed.data.priority) {
+      const validPriorities = ["low", "medium", "high", "critical"];
+      if (!validPriorities.includes(parsed.data.priority)) {
+        if (filePath) ;
       }
     }
+    normalizeTagsField(parsed.data);
+    const knownFields = [
+      "status",
+      "created",
+      "tags",
+      "priority",
+      "related",
+      "depends_on",
+      "updated",
+      "completed",
+      "assignee",
+      "reviewer",
+      "issue",
+      "pr",
+      "epic",
+      "breaking",
+      "due",
+      "created_at",
+      "updated_at",
+      "completed_at",
+      "transitions"
+    ];
+    const customFields = config?.frontmatter?.custom ? Object.keys(config.frontmatter.custom) : [];
+    const allKnownFields = [...knownFields, ...customFields];
+    const unknownFields = Object.keys(parsed.data).filter((k) => !allKnownFields.includes(k));
+    if (unknownFields.length > 0 && filePath) ;
+    const validatedData = validateCustomFields(parsed.data, config);
+    return validatedData;
+  } catch (error) {
+    console.error(`Error parsing frontmatter${""}:`, error);
+    return null;
   }
-  /**
-   * Check for orphaned sub-specs not referenced in README.md
-   */
-  checkOrphanedSubSpecs(subSpecs, readmeContent, warnings) {
-    for (const subSpec of subSpecs) {
-      const fileName = subSpec.name;
-      const escapedFileName = fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const linkPattern = new RegExp(`\\[([^\\]]+)\\]\\((?:\\.\\/)?${escapedFileName}\\)`, "gi");
-      const isReferenced = linkPattern.test(readmeContent);
-      if (!isReferenced) {
-        warnings.push({
-          message: `Orphaned sub-spec: ${fileName} (not linked from README.md)`,
-          suggestion: `Add a link to ${fileName} in README.md to document its purpose`
-        });
-      }
+}
+function parseFallbackFields(content) {
+  const statusMatch = content.match(/\*\*Status\*\*:\s*(?:📅\s*)?(\w+(?:-\w+)?)/i);
+  const createdMatch = content.match(/\*\*Created\*\*:\s*(\d{4}-\d{2}-\d{2})/);
+  if (statusMatch && createdMatch) {
+    const status = statusMatch[1].toLowerCase().replace(/\s+/g, "-");
+    const created = createdMatch[1];
+    return {
+      status,
+      created
+    };
+  }
+  return null;
+}
+function createUpdatedFrontmatter(existingContent, updates) {
+  const parsed = matter4(existingContent, {
+    engines: {
+      yaml: (str) => yaml3.load(str, { schema: yaml3.FAILSAFE_SCHEMA })
     }
+  });
+  const previousData = { ...parsed.data };
+  const newData = { ...parsed.data, ...updates };
+  normalizeDateFields2(newData);
+  enrichWithTimestamps(newData, previousData);
+  if (updates.status === "complete" && !newData.completed) {
+    newData.completed = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  }
+  if ("updated" in parsed.data) {
+    newData.updated = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  }
+  let updatedContent = parsed.content;
+  updatedContent = updateVisualMetadata(updatedContent, newData);
+  const newContent = matter4.stringify(updatedContent, newData);
+  return {
+    content: newContent,
+    frontmatter: newData
+  };
+}
+function updateVisualMetadata(content, frontmatter) {
+  const statusEmoji = getStatusEmojiPlain(frontmatter.status);
+  const statusLabel = frontmatter.status.charAt(0).toUpperCase() + frontmatter.status.slice(1).replace("-", " ");
+  const created = frontmatter.created;
+  let metadataLine = `> **Status**: ${statusEmoji} ${statusLabel}`;
+  if (frontmatter.priority) {
+    const priorityLabel = frontmatter.priority.charAt(0).toUpperCase() + frontmatter.priority.slice(1);
+    metadataLine += ` \xB7 **Priority**: ${priorityLabel}`;
   }
-  /**
-   * Validate cross-document references between sub-specs
-   */
-  async validateCrossReferences(subSpecs, spec, warnings) {
-    const validFileNames = new Set(subSpecs.map((s) => s.name));
-    validFileNames.add("README.md");
-    for (const subSpec of subSpecs) {
-      if (!subSpec.content) {
-        continue;
-      }
-      const linkRegex = /\[([^\]]+)\]\((?:\.\/)?(([^)]+)\.md)\)/g;
-      let match;
-      while ((match = linkRegex.exec(subSpec.content)) !== null) {
-        const referencedFile = match[2];
-        if (!validFileNames.has(referencedFile)) {
-          warnings.push({
-            message: `Broken reference in ${subSpec.name}: ${referencedFile} not found`,
-            suggestion: `Check if ${referencedFile} exists or update the link`
-          });
-        }
-      }
+  metadataLine += ` \xB7 **Created**: ${created}`;
+  if (frontmatter.tags && frontmatter.tags.length > 0) {
+    metadataLine += ` \xB7 **Tags**: ${frontmatter.tags.join(", ")}`;
+  }
+  let secondLine = "";
+  if (frontmatter.assignee || frontmatter.reviewer) {
+    const assignee = frontmatter.assignee || "TBD";
+    const reviewer = frontmatter.reviewer || "TBD";
+    secondLine = `
+> **Assignee**: ${assignee} \xB7 **Reviewer**: ${reviewer}`;
+  }
+  const metadataPattern = /^>\s+\*\*Status\*\*:.*(?:\n>\s+\*\*Assignee\*\*:.*)?/m;
+  if (metadataPattern.test(content)) {
+    return content.replace(metadataPattern, metadataLine + secondLine);
+  } else {
+    const titleMatch = content.match(/^#\s+.+$/m);
+    if (titleMatch) {
+      const insertPos = titleMatch.index + titleMatch[0].length;
+      return content.slice(0, insertPos) + "\n\n" + metadataLine + secondLine + "\n" + content.slice(insertPos);
     }
   }
-};
-
-// src/utils/validate-formatter.ts
-import chalk13 from "chalk";
-function groupIssuesByFile(results) {
-  const fileMap = /* @__PURE__ */ new Map();
-  const addIssue = (filePath, issue, spec) => {
-    if (!fileMap.has(filePath)) {
-      fileMap.set(filePath, { issues: [], spec });
+  return content;
+}
+function getStatusEmojiPlain(status) {
+  switch (status) {
+    case "planned":
+      return "\u{1F4C5}";
+    case "in-progress":
+      return "\u23F3";
+    case "complete":
+      return "\u2705";
+    case "archived":
+      return "\u{1F4E6}";
+    default:
+      return "\u{1F4C4}";
+  }
+}
+function parseMarkdownSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  const sectionStack = [];
+  let inCodeBlock = false;
+  let currentLineNum = 1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    currentLineNum = i + 1;
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
     }
-    fileMap.get(filePath).issues.push(issue);
-  };
-  for (const { spec, validatorName, result } of results) {
-    for (const error of result.errors) {
-      addIssue(spec.filePath, {
-        severity: "error",
-        message: error.message,
-        suggestion: error.suggestion,
-        ruleName: validatorName,
-        filePath: spec.filePath,
-        spec
-      }, spec);
+    if (inCodeBlock) {
+      continue;
     }
-    for (const warning of result.warnings) {
-      addIssue(spec.filePath, {
-        severity: "warning",
-        message: warning.message,
-        suggestion: warning.suggestion,
-        ruleName: validatorName,
-        filePath: spec.filePath,
-        spec
-      }, spec);
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const title = headingMatch[2].trim();
+      while (sectionStack.length > 0 && sectionStack[sectionStack.length - 1].level >= level) {
+        const closedSection = sectionStack.pop();
+        closedSection.endLine = currentLineNum - 1;
+        closedSection.lineCount = closedSection.endLine - closedSection.startLine + 1;
+      }
+      const newSection = {
+        title,
+        level,
+        startLine: currentLineNum,
+        endLine: lines.length,
+        // Will be updated when section closes
+        lineCount: 0,
+        // Will be calculated when section closes
+        subsections: []
+      };
+      if (sectionStack.length > 0) {
+        sectionStack[sectionStack.length - 1].subsections.push(newSection);
+      } else {
+        sections.push(newSection);
+      }
+      sectionStack.push(newSection);
     }
   }
-  const fileResults = [];
-  for (const [filePath, data] of fileMap.entries()) {
-    data.issues.sort((a, b) => {
-      if (a.severity === b.severity) return 0;
-      return a.severity === "error" ? -1 : 1;
-    });
-    fileResults.push({ filePath, issues: data.issues, spec: data.spec });
+  while (sectionStack.length > 0) {
+    const closedSection = sectionStack.pop();
+    closedSection.endLine = lines.length;
+    closedSection.lineCount = closedSection.endLine - closedSection.startLine + 1;
   }
-  fileResults.sort((a, b) => {
-    if (a.spec?.name && b.spec?.name) {
-      return a.spec.name.localeCompare(b.spec.name);
-    }
-    return a.filePath.localeCompare(b.filePath);
-  });
-  return fileResults;
+  return sections;
 }
-function normalizeFilePath(filePath) {
-  const cwd = process.cwd();
-  if (filePath.startsWith(cwd)) {
-    return filePath.substring(cwd.length + 1);
-  } else if (filePath.includes("/specs/")) {
-    const specsIndex = filePath.indexOf("/specs/");
-    return filePath.substring(specsIndex + 1);
+function flattenSections(sections) {
+  const result = [];
+  for (const section of sections) {
+    result.push(section);
+    result.push(...flattenSections(section.subsections));
   }
-  return filePath;
+  return result;
 }
-function formatFileIssues(fileResult, specsDir) {
-  const lines = [];
-  const relativePath = normalizeFilePath(fileResult.filePath);
-  const isMainSpec = relativePath.endsWith("README.md");
-  if (isMainSpec && fileResult.spec) {
-    const specName = fileResult.spec.name;
-    const status = fileResult.spec.frontmatter.status;
-    const priority = fileResult.spec.frontmatter.priority || "medium";
-    const statusBadge = formatStatusBadge(status);
-    const priorityBadge = formatPriorityBadge(priority);
-    lines.push(chalk13.bold.cyan(`${specName} ${statusBadge} ${priorityBadge}`));
-  } else {
-    lines.push(chalk13.cyan.underline(relativePath));
+function extractLines(content, startLine, endLine) {
+  const lines = content.split("\n");
+  if (startLine < 1 || endLine < startLine || startLine > lines.length || endLine > lines.length) {
+    throw new Error(`Invalid line range: ${startLine}-${endLine}`);
   }
-  for (const issue of fileResult.issues) {
-    const severityColor = issue.severity === "error" ? chalk13.red : chalk13.yellow;
-    const severityText = severityColor(issue.severity.padEnd(9));
-    const ruleText = chalk13.gray(issue.ruleName);
-    lines.push(`  ${severityText}${issue.message.padEnd(60)} ${ruleText}`);
-    if (issue.suggestion) {
-      lines.push(chalk13.gray(`           \u2192 ${issue.suggestion}`));
-    }
+  const extracted = lines.slice(startLine - 1, endLine);
+  return extracted.join("\n");
+}
+function removeLines(content, startLine, endLine) {
+  const lines = content.split("\n");
+  if (startLine < 1 || endLine < startLine || startLine > lines.length) {
+    throw new Error(`Invalid line range: ${startLine}-${endLine}`);
   }
-  lines.push("");
+  lines.splice(startLine - 1, endLine - startLine + 1);
   return lines.join("\n");
 }
-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(
-      `\u2716 ${errorCount} ${errorText}, ${warningCount} ${warningText} (${totalSpecs} specs checked, ${cleanCount} clean)`
+function countLines(content) {
+  return content.split("\n").length;
+}
+function analyzeMarkdownStructure(content) {
+  const lines = content.split("\n");
+  const sections = parseMarkdownSections(content);
+  const allSections = flattenSections(sections);
+  const levelCounts = { h1: 0, h2: 0, h3: 0, h4: 0, h5: 0, h6: 0, total: 0 };
+  for (const section of allSections) {
+    levelCounts[`h${section.level}`]++;
+    levelCounts.total++;
+  }
+  let codeBlocks = 0;
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      if (!inCodeBlock) {
+        codeBlocks++;
+      }
+      inCodeBlock = !inCodeBlock;
+    }
+  }
+  let maxNesting = 0;
+  function calculateNesting(secs, depth) {
+    for (const section of secs) {
+      maxNesting = Math.max(maxNesting, depth);
+      calculateNesting(section.subsections, depth + 1);
+    }
+  }
+  calculateNesting(sections, 1);
+  return {
+    lines: lines.length,
+    sections,
+    allSections,
+    sectionsByLevel: levelCounts,
+    codeBlocks,
+    maxNesting
+  };
+}
+var TokenCounter = class {
+  encoding;
+  constructor() {
+    this.encoding = encoding_for_model("gpt-4");
+  }
+  /**
+   * Clean up resources (important to prevent memory leaks)
+   */
+  dispose() {
+    this.encoding.free();
+  }
+  /**
+   * Count tokens in a string
+   */
+  countString(text) {
+    const tokens = this.encoding.encode(text);
+    return tokens.length;
+  }
+  /**
+   * Count tokens in content (convenience method for analyze command)
+   * Alias for countString - provided for clarity in command usage
+   */
+  async countTokensInContent(content) {
+    return this.countString(content);
+  }
+  /**
+   * Count tokens in a single file
+   */
+  async countFile(filePath, options = {}) {
+    const content = await fs9.readFile(filePath, "utf-8");
+    const tokens = this.countString(content);
+    const lines = content.split("\n").length;
+    const result = {
+      total: tokens,
+      files: [{
+        path: filePath,
+        tokens,
+        lines
+      }]
+    };
+    if (options.detailed) {
+      result.breakdown = await this.analyzeBreakdown(content);
+    }
+    return result;
+  }
+  /**
+   * Count tokens in a spec (including sub-specs if requested)
+   */
+  async countSpec(specPath, options = {}) {
+    const stats = await fs9.stat(specPath);
+    if (stats.isFile()) {
+      return this.countFile(specPath, options);
+    }
+    const files = await fs9.readdir(specPath);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    const filesToCount = [];
+    if (mdFiles.includes("README.md")) {
+      filesToCount.push("README.md");
+    }
+    if (options.includeSubSpecs) {
+      mdFiles.forEach((f) => {
+        if (f !== "README.md") {
+          filesToCount.push(f);
+        }
+      });
+    }
+    const fileCounts = [];
+    let totalTokens = 0;
+    let totalBreakdown;
+    if (options.detailed) {
+      totalBreakdown = {
+        code: 0,
+        prose: 0,
+        tables: 0,
+        frontmatter: 0
+      };
+    }
+    for (const file of filesToCount) {
+      const filePath = path2.join(specPath, file);
+      const content = await fs9.readFile(filePath, "utf-8");
+      const tokens = this.countString(content);
+      const lines = content.split("\n").length;
+      fileCounts.push({
+        path: file,
+        tokens,
+        lines
+      });
+      totalTokens += tokens;
+      if (options.detailed && totalBreakdown) {
+        const breakdown = await this.analyzeBreakdown(content);
+        totalBreakdown.code += breakdown.code;
+        totalBreakdown.prose += breakdown.prose;
+        totalBreakdown.tables += breakdown.tables;
+        totalBreakdown.frontmatter += breakdown.frontmatter;
+      }
+    }
+    return {
+      total: totalTokens,
+      files: fileCounts,
+      breakdown: totalBreakdown
+    };
+  }
+  /**
+   * Analyze token breakdown by content type
+   */
+  async analyzeBreakdown(content) {
+    const breakdown = {
+      code: 0,
+      prose: 0,
+      tables: 0,
+      frontmatter: 0
+    };
+    let body = content;
+    let frontmatterContent = "";
+    try {
+      const parsed = matter4(content);
+      body = parsed.content;
+      frontmatterContent = parsed.matter;
+      breakdown.frontmatter = this.countString(frontmatterContent);
+    } catch {
+    }
+    let inCodeBlock = false;
+    let inTable = false;
+    const lines = body.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (trimmed.startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+        breakdown.code += this.countString(line + "\n");
+        continue;
+      }
+      if (inCodeBlock) {
+        breakdown.code += this.countString(line + "\n");
+        continue;
+      }
+      const isTableSeparator = trimmed.includes("|") && /[-:]{3,}/.test(trimmed);
+      const isTableRow = trimmed.includes("|") && trimmed.startsWith("|");
+      if (isTableSeparator || inTable && isTableRow) {
+        inTable = true;
+        breakdown.tables += this.countString(line + "\n");
+        continue;
+      } else if (inTable && !isTableRow) {
+        inTable = false;
+      }
+      breakdown.prose += this.countString(line + "\n");
+    }
+    return breakdown;
+  }
+  /**
+   * Check if content fits within token limit
+   */
+  isWithinLimit(count, limit) {
+    return count.total <= limit;
+  }
+  /**
+   * Format token count for display
+   */
+  formatCount(count, verbose = false) {
+    if (!verbose) {
+      return `${count.total.toLocaleString()} tokens`;
+    }
+    const lines = [
+      `Total: ${count.total.toLocaleString()} tokens`,
+      "",
+      "Files:"
+    ];
+    for (const file of count.files) {
+      const lineInfo = file.lines ? ` (${file.lines} lines)` : "";
+      lines.push(`  ${file.path}: ${file.tokens.toLocaleString()} tokens${lineInfo}`);
+    }
+    if (count.breakdown) {
+      const b = count.breakdown;
+      const total = b.code + b.prose + b.tables + b.frontmatter;
+      lines.push("");
+      lines.push("Content Breakdown:");
+      lines.push(`  Prose:       ${b.prose.toLocaleString()} tokens (${Math.round(b.prose / total * 100)}%)`);
+      lines.push(`  Code:        ${b.code.toLocaleString()} tokens (${Math.round(b.code / total * 100)}%)`);
+      lines.push(`  Tables:      ${b.tables.toLocaleString()} tokens (${Math.round(b.tables / total * 100)}%)`);
+      lines.push(`  Frontmatter: ${b.frontmatter.toLocaleString()} tokens (${Math.round(b.frontmatter / total * 100)}%)`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get performance indicators based on token count
+   * Based on research from spec 066
+   */
+  getPerformanceIndicators(tokenCount) {
+    const baselineTokens = 1200;
+    const costMultiplier = Math.round(tokenCount / baselineTokens * 10) / 10;
+    if (tokenCount < 2e3) {
+      return {
+        level: "excellent",
+        costMultiplier,
+        effectiveness: 100,
+        recommendation: "Optimal size for Context Economy"
+      };
+    } else if (tokenCount < 3500) {
+      return {
+        level: "good",
+        costMultiplier,
+        effectiveness: 95,
+        recommendation: "Good size, no action needed"
+      };
+    } else if (tokenCount < 5e3) {
+      return {
+        level: "warning",
+        costMultiplier,
+        effectiveness: 85,
+        recommendation: "Consider simplification or sub-specs"
+      };
+    } else {
+      return {
+        level: "problem",
+        costMultiplier,
+        effectiveness: 70,
+        recommendation: "Should split - elevated token count"
+      };
+    }
+  }
+};
+async function countTokens(input, options) {
+  const counter = new TokenCounter();
+  try {
+    if (typeof input === "string") {
+      return {
+        total: counter.countString(input),
+        files: []
+      };
+    } else if ("content" in input) {
+      return {
+        total: counter.countString(input.content),
+        files: []
+      };
+    } else if ("filePath" in input) {
+      return await counter.countFile(input.filePath, options);
+    } else if ("specPath" in input) {
+      return await counter.countSpec(input.specPath, options);
+    }
+    throw new Error("Invalid input type");
+  } finally {
+    counter.dispose();
+  }
+}
+var ComplexityValidator = class {
+  name = "complexity";
+  description = "Direct token threshold validation with independent structure checks";
+  excellentThreshold;
+  goodThreshold;
+  warningThreshold;
+  maxLines;
+  warningLines;
+  constructor(options = {}) {
+    this.excellentThreshold = options.excellentThreshold ?? 2e3;
+    this.goodThreshold = options.goodThreshold ?? 3500;
+    this.warningThreshold = options.warningThreshold ?? 5e3;
+    this.maxLines = options.maxLines ?? 500;
+    this.warningLines = options.warningLines ?? 400;
+  }
+  async validate(spec, content) {
+    const errors = [];
+    const warnings = [];
+    const metrics = await this.analyzeComplexity(content, spec);
+    const tokenValidation = this.validateTokens(metrics.tokenCount);
+    if (tokenValidation.level === "error") {
+      errors.push({
+        message: tokenValidation.message,
+        suggestion: "Consider splitting for Context Economy (attention and cognitive load)"
+      });
+    } else if (tokenValidation.level === "warning") {
+      warnings.push({
+        message: tokenValidation.message,
+        suggestion: "Consider simplification or splitting into sub-specs"
+      });
+    }
+    const structureChecks = this.checkStructure(metrics);
+    for (const check of structureChecks) {
+      if (!check.passed && check.message) {
+        warnings.push({
+          message: check.message,
+          suggestion: check.suggestion
+        });
+      }
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Validate token count with direct thresholds
+   */
+  validateTokens(tokens) {
+    if (tokens > this.warningThreshold) {
+      return {
+        level: "error",
+        message: `Spec has ${tokens.toLocaleString()} tokens (threshold: ${this.warningThreshold.toLocaleString()}) - should split`
+      };
+    }
+    if (tokens > this.goodThreshold) {
+      return {
+        level: "warning",
+        message: `Spec has ${tokens.toLocaleString()} tokens (threshold: ${this.goodThreshold.toLocaleString()})`
+      };
+    }
+    if (tokens > this.excellentThreshold) {
+      return {
+        level: "info",
+        message: `Spec has ${tokens.toLocaleString()} tokens - acceptable, watch for growth`
+      };
+    }
+    return {
+      level: "excellent",
+      message: `Spec has ${tokens.toLocaleString()} tokens - excellent`
+    };
+  }
+  /**
+   * Check structure quality independently
+   */
+  checkStructure(metrics) {
+    const checks = [];
+    if (metrics.hasSubSpecs) {
+      if (metrics.tokenCount > this.excellentThreshold) {
+        checks.push({
+          passed: true,
+          message: `Uses ${metrics.subSpecCount} sub-spec file${metrics.subSpecCount > 1 ? "s" : ""} for progressive disclosure`
+        });
+      }
+    } else if (metrics.tokenCount > this.goodThreshold) {
+      checks.push({
+        passed: false,
+        message: "Consider using sub-spec files (DESIGN.md, IMPLEMENTATION.md, etc.)",
+        suggestion: "Progressive disclosure reduces cognitive load for large specs"
+      });
+    }
+    if (metrics.sectionCount >= 15 && metrics.sectionCount <= 35) {
+      if (metrics.tokenCount > this.excellentThreshold) {
+        checks.push({
+          passed: true,
+          message: `Good sectioning (${metrics.sectionCount} sections) enables cognitive chunking`
+        });
+      }
+    } else if (metrics.sectionCount < 8 && metrics.lineCount > 200) {
+      checks.push({
+        passed: false,
+        message: `Only ${metrics.sectionCount} sections - too monolithic`,
+        suggestion: "Break into 15-35 sections for better readability (7\xB12 cognitive chunks)"
+      });
+    }
+    if (metrics.codeBlockCount > 20) {
+      checks.push({
+        passed: false,
+        message: `High code block density (${metrics.codeBlockCount} blocks)`,
+        suggestion: "Consider moving examples to separate files or sub-specs"
+      });
+    }
+    return checks;
+  }
+  /**
+   * Analyze complexity metrics from spec content
+   */
+  async analyzeComplexity(content, spec) {
+    let body;
+    try {
+      const parsed = matter4(content);
+      body = parsed.content;
+    } catch {
+      body = content;
+    }
+    const lines = 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 codeBlockCount = Math.floor((content.match(/```/g) || []).length / 2);
+    const listItemCount = lines.filter((line) => line.match(/^[\s]*[-*]\s/) || line.match(/^[\s]*\d+\.\s/)).length;
+    const tableCount = lines.filter((line) => line.includes("|") && line.match(/[-:]{3,}/)).length;
+    const counter = new TokenCounter();
+    const tokenCount = counter.countString(content);
+    counter.dispose();
+    let hasSubSpecs = false;
+    let subSpecCount = 0;
+    try {
+      const specDir = path2.dirname(spec.filePath);
+      const files = await fs9.readdir(specDir);
+      const mdFiles = files.filter(
+        (f) => f.endsWith(".md") && f !== "README.md"
+      );
+      hasSubSpecs = mdFiles.length > 0;
+      subSpecCount = mdFiles.length;
+    } catch (error) {
+      hasSubSpecs = /\b(DESIGN|IMPLEMENTATION|TESTING|CONFIGURATION|API|MIGRATION)\.md\b/.test(content);
+      const subSpecMatches = content.match(/\b[A-Z-]+\.md\b/g) || [];
+      const uniqueSubSpecs = new Set(subSpecMatches.filter((m) => m !== "README.md"));
+      subSpecCount = uniqueSubSpecs.size;
+    }
+    const averageSectionLength = sectionCount > 0 ? Math.round(lineCount / sectionCount) : 0;
+    return {
+      lineCount,
+      tokenCount,
+      sectionCount,
+      codeBlockCount,
+      listItemCount,
+      tableCount,
+      hasSubSpecs,
+      subSpecCount,
+      averageSectionLength
+    };
+  }
+};
+var FIELD_WEIGHTS = {
+  title: 100,
+  name: 70,
+  tags: 70,
+  description: 50,
+  content: 10
+};
+function calculateMatchScore(match, queryTerms, totalMatches, matchPosition) {
+  let score = FIELD_WEIGHTS[match.field];
+  match.text.toLowerCase();
+  const hasExactMatch = queryTerms.some((term) => {
+    const regex = new RegExp(`\\b${escapeRegex(term)}\\b`, "i");
+    return regex.test(match.text);
+  });
+  if (hasExactMatch) {
+    score *= 2;
+  }
+  const positionBonus = Math.max(1, 1.5 - matchPosition * 0.1);
+  score *= positionBonus;
+  const frequencyFactor = Math.min(1, 3 / totalMatches);
+  score *= frequencyFactor;
+  return Math.min(100, score * 10);
+}
+function calculateSpecScore(matches) {
+  if (matches.length === 0) return 0;
+  const fieldScores = {};
+  for (const match of matches) {
+    const field = match.field;
+    const currentScore = fieldScores[field] || 0;
+    fieldScores[field] = Math.max(currentScore, match.score);
+  }
+  let totalScore = 0;
+  let totalWeight = 0;
+  for (const [field, score] of Object.entries(fieldScores)) {
+    const weight = FIELD_WEIGHTS[field] || 1;
+    totalScore += score * weight;
+    totalWeight += weight;
+  }
+  return totalWeight > 0 ? Math.round(totalScore / totalWeight) : 0;
+}
+function containsAllTerms(text, queryTerms) {
+  const textLower = text.toLowerCase();
+  return queryTerms.every((term) => textLower.includes(term));
+}
+function countOccurrences(text, queryTerms) {
+  const textLower = text.toLowerCase();
+  let count = 0;
+  for (const term of queryTerms) {
+    const regex = new RegExp(escapeRegex(term), "gi");
+    const matches = textLower.match(regex);
+    count += matches ? matches.length : 0;
+  }
+  return count;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findMatchPositions(text, queryTerms) {
+  const positions = [];
+  const textLower = text.toLowerCase();
+  for (const term of queryTerms) {
+    const termLower = term.toLowerCase();
+    let index = 0;
+    while ((index = textLower.indexOf(termLower, index)) !== -1) {
+      positions.push([index, index + term.length]);
+      index += term.length;
+    }
+  }
+  positions.sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const pos of positions) {
+    if (merged.length === 0) {
+      merged.push(pos);
+    } else {
+      const last = merged[merged.length - 1];
+      if (pos[0] <= last[1]) {
+        last[1] = Math.max(last[1], pos[1]);
+      } else {
+        merged.push(pos);
+      }
+    }
+  }
+  return merged;
+}
+function extractContext(text, matchIndex, queryTerms, contextLength = 80) {
+  const lines = text.split("\n");
+  const matchLine = lines[matchIndex] || "";
+  if (matchLine.length <= contextLength * 2) {
+    const highlights2 = findMatchPositions(matchLine, queryTerms);
+    return { text: matchLine, highlights: highlights2 };
+  }
+  const matchLineLower = matchLine.toLowerCase();
+  let firstMatchPos = matchLine.length;
+  for (const term of queryTerms) {
+    const pos = matchLineLower.indexOf(term.toLowerCase());
+    if (pos !== -1 && pos < firstMatchPos) {
+      firstMatchPos = pos;
+    }
+  }
+  const start = Math.max(0, firstMatchPos - contextLength);
+  const end = Math.min(matchLine.length, firstMatchPos + contextLength);
+  let contextText = matchLine.substring(start, end);
+  if (start > 0) contextText = "..." + contextText;
+  if (end < matchLine.length) contextText = contextText + "...";
+  const highlights = findMatchPositions(contextText, queryTerms);
+  return { text: contextText, highlights };
+}
+function extractSmartContext(text, matchIndex, queryTerms, contextLength = 80) {
+  const lines = text.split("\n");
+  const matchLine = lines[matchIndex] || "";
+  if (matchLine.length <= contextLength * 2) {
+    return extractContext(text, matchIndex, queryTerms, contextLength);
+  }
+  const matchLineLower = matchLine.toLowerCase();
+  let firstMatchPos = matchLine.length;
+  for (const term of queryTerms) {
+    const pos = matchLineLower.indexOf(term.toLowerCase());
+    if (pos !== -1 && pos < firstMatchPos) {
+      firstMatchPos = pos;
+    }
+  }
+  let start = Math.max(0, firstMatchPos - contextLength);
+  let end = Math.min(matchLine.length, firstMatchPos + contextLength);
+  const beforeText = matchLine.substring(0, start);
+  const lastSentence = beforeText.lastIndexOf(". ");
+  if (lastSentence !== -1 && start - lastSentence < 20) {
+    start = lastSentence + 2;
+  }
+  const afterText = matchLine.substring(end);
+  const nextSentence = afterText.indexOf(". ");
+  if (nextSentence !== -1 && nextSentence < 20) {
+    end = end + nextSentence + 1;
+  }
+  let contextText = matchLine.substring(start, end);
+  if (start > 0) contextText = "..." + contextText;
+  if (end < matchLine.length) contextText = contextText + "...";
+  const highlights = findMatchPositions(contextText, queryTerms);
+  return { text: contextText, highlights };
+}
+function deduplicateMatches(matches, minDistance = 3) {
+  if (matches.length === 0) return matches;
+  const sorted = [...matches].sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return (a.lineNumber || 0) - (b.lineNumber || 0);
+  });
+  const deduplicated = [];
+  const usedLines = /* @__PURE__ */ new Set();
+  for (const match of sorted) {
+    if (match.field !== "content") {
+      deduplicated.push(match);
+      continue;
+    }
+    const lineNum = match.lineNumber || 0;
+    let tooClose = false;
+    for (let i = lineNum - minDistance; i <= lineNum + minDistance; i++) {
+      if (usedLines.has(i)) {
+        tooClose = true;
+        break;
+      }
+    }
+    if (!tooClose) {
+      deduplicated.push(match);
+      usedLines.add(lineNum);
+    }
+  }
+  return deduplicated.sort((a, b) => {
+    const fieldOrder = { title: 0, name: 1, tags: 2, description: 3, content: 4 };
+    const orderA = fieldOrder[a.field];
+    const orderB = fieldOrder[b.field];
+    if (orderA !== orderB) return orderA - orderB;
+    return b.score - a.score;
+  });
+}
+function limitMatches(matches, maxMatches = 5) {
+  if (matches.length <= maxMatches) return matches;
+  const fieldMatches = {
+    title: [],
+    name: [],
+    tags: [],
+    description: [],
+    content: []
+  };
+  for (const match of matches) {
+    fieldMatches[match.field].push(match);
+  }
+  const nonContent = [
+    ...fieldMatches.title,
+    ...fieldMatches.name,
+    ...fieldMatches.tags,
+    ...fieldMatches.description
+  ];
+  const contentMatches = fieldMatches.content.sort((a, b) => b.score - a.score).slice(0, Math.max(0, maxMatches - nonContent.length));
+  return [...nonContent, ...contentMatches];
+}
+function searchSpecs(query, specs, options = {}) {
+  const startTime = Date.now();
+  const queryTerms = query.trim().toLowerCase().split(/\s+/).filter((term) => term.length > 0);
+  if (queryTerms.length === 0) {
+    return {
+      results: [],
+      metadata: {
+        totalResults: 0,
+        searchTime: Date.now() - startTime,
+        query,
+        specsSearched: specs.length
+      }
+    };
+  }
+  const maxMatchesPerSpec = options.maxMatchesPerSpec || 5;
+  const contextLength = options.contextLength || 80;
+  const results = [];
+  for (const spec of specs) {
+    const matches = searchSpec(spec, queryTerms, contextLength);
+    if (matches.length > 0) {
+      let processedMatches = deduplicateMatches(matches, 3);
+      processedMatches = limitMatches(processedMatches, maxMatchesPerSpec);
+      const score = calculateSpecScore(processedMatches);
+      results.push({
+        spec: specToSearchResult(spec),
+        score,
+        totalMatches: matches.length,
+        matches: processedMatches
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return {
+    results,
+    metadata: {
+      totalResults: results.length,
+      searchTime: Date.now() - startTime,
+      query,
+      specsSearched: specs.length
+    }
+  };
+}
+function searchSpec(spec, queryTerms, contextLength) {
+  const matches = [];
+  if (spec.title && containsAllTerms(spec.title, queryTerms)) {
+    const occurrences = countOccurrences(spec.title, queryTerms);
+    const highlights = findMatchPositions(spec.title, queryTerms);
+    const score = calculateMatchScore(
+      { field: "title", text: spec.title },
+      queryTerms,
+      1,
+      0
+    );
+    matches.push({
+      field: "title",
+      text: spec.title,
+      score,
+      highlights,
+      occurrences
+    });
+  }
+  if (spec.name && containsAllTerms(spec.name, queryTerms)) {
+    const occurrences = countOccurrences(spec.name, queryTerms);
+    const highlights = findMatchPositions(spec.name, queryTerms);
+    const score = calculateMatchScore(
+      { field: "name", text: spec.name },
+      queryTerms,
+      1,
+      0
+    );
+    matches.push({
+      field: "name",
+      text: spec.name,
+      score,
+      highlights,
+      occurrences
+    });
+  }
+  if (spec.tags && spec.tags.length > 0) {
+    for (const tag of spec.tags) {
+      if (containsAllTerms(tag, queryTerms)) {
+        const occurrences = countOccurrences(tag, queryTerms);
+        const highlights = findMatchPositions(tag, queryTerms);
+        const score = calculateMatchScore(
+          { field: "tags", text: tag },
+          queryTerms,
+          spec.tags.length,
+          spec.tags.indexOf(tag)
+        );
+        matches.push({
+          field: "tags",
+          text: tag,
+          score,
+          highlights,
+          occurrences
+        });
+      }
+    }
+  }
+  if (spec.description && containsAllTerms(spec.description, queryTerms)) {
+    const occurrences = countOccurrences(spec.description, queryTerms);
+    const highlights = findMatchPositions(spec.description, queryTerms);
+    const score = calculateMatchScore(
+      { field: "description", text: spec.description },
+      queryTerms,
+      1,
+      0
+    );
+    matches.push({
+      field: "description",
+      text: spec.description,
+      score,
+      highlights,
+      occurrences
+    });
+  }
+  if (spec.content) {
+    const contentMatches = searchContent(
+      spec.content,
+      queryTerms,
+      contextLength
+    );
+    matches.push(...contentMatches);
+  }
+  return matches;
+}
+function searchContent(content, queryTerms, contextLength) {
+  const matches = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (containsAllTerms(line, queryTerms)) {
+      const occurrences = countOccurrences(line, queryTerms);
+      const { text, highlights } = extractSmartContext(
+        content,
+        i,
+        queryTerms,
+        contextLength
+      );
+      const score = calculateMatchScore(
+        { field: "content", text: line },
+        queryTerms,
+        lines.length,
+        i
+      );
+      matches.push({
+        field: "content",
+        text,
+        lineNumber: i + 1,
+        // 1-based line numbers
+        score,
+        highlights,
+        occurrences
+      });
+    }
+  }
+  return matches;
+}
+function specToSearchResult(spec) {
+  return {
+    name: spec.name,
+    path: spec.path,
+    status: spec.status,
+    priority: spec.priority,
+    tags: spec.tags,
+    title: spec.title,
+    description: spec.description
+  };
+}
+
+// src/validators/sub-spec.ts
+var SubSpecValidator = class {
+  name = "sub-specs";
+  description = "Validate sub-spec files using direct token thresholds (spec 071)";
+  excellentThreshold;
+  goodThreshold;
+  warningThreshold;
+  maxLines;
+  constructor(options = {}) {
+    this.excellentThreshold = options.excellentThreshold ?? 2e3;
+    this.goodThreshold = options.goodThreshold ?? 3500;
+    this.warningThreshold = options.warningThreshold ?? 5e3;
+    this.maxLines = options.maxLines ?? 500;
+  }
+  async validate(spec, content) {
+    const errors = [];
+    const warnings = [];
+    const subFiles = await loadSubFiles(spec.fullPath, { includeContent: true });
+    const subSpecs = subFiles.filter((f) => f.type === "document");
+    if (subSpecs.length === 0) {
+      return { passed: true, errors, warnings };
+    }
+    this.validateNamingConventions(subSpecs, warnings);
+    await this.validateComplexity(subSpecs, errors, warnings);
+    this.checkOrphanedSubSpecs(subSpecs, content, warnings);
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Validate sub-spec naming conventions
+   * Convention: Uppercase filenames (e.g., DESIGN.md, TESTING.md, IMPLEMENTATION.md)
+   */
+  validateNamingConventions(subSpecs, warnings) {
+    for (const subSpec of subSpecs) {
+      const baseName = path2.basename(subSpec.name, ".md");
+      if (baseName !== baseName.toUpperCase()) {
+        warnings.push({
+          message: `Sub-spec filename should be uppercase: ${subSpec.name}`,
+          suggestion: `Consider renaming to ${baseName.toUpperCase()}.md`
+        });
+      }
+    }
+  }
+  /**
+   * Validate complexity for each sub-spec file using direct token thresholds
+   * Same approach as ComplexityValidator (spec 071)
+   */
+  async validateComplexity(subSpecs, errors, warnings) {
+    for (const subSpec of subSpecs) {
+      if (!subSpec.content) {
+        continue;
+      }
+      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} 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)"
+        });
+      }
+    }
+  }
+  /**
+   * Check for orphaned sub-specs not referenced in README.md
+   */
+  checkOrphanedSubSpecs(subSpecs, readmeContent, warnings) {
+    for (const subSpec of subSpecs) {
+      const fileName = subSpec.name;
+      const escapedFileName = fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const linkPattern = new RegExp(`\\[([^\\]]+)\\]\\((?:\\.\\/)?${escapedFileName}\\)`, "gi");
+      const isReferenced = linkPattern.test(readmeContent);
+      if (!isReferenced) {
+        warnings.push({
+          message: `Orphaned sub-spec: ${fileName} (not linked from README.md)`,
+          suggestion: `Add a link to ${fileName} in README.md to document its purpose`
+        });
+      }
+    }
+  }
+};
+function groupIssuesByFile(results) {
+  const fileMap = /* @__PURE__ */ new Map();
+  const addIssue = (filePath, issue, spec) => {
+    if (!fileMap.has(filePath)) {
+      fileMap.set(filePath, { issues: [], spec });
+    }
+    fileMap.get(filePath).issues.push(issue);
+  };
+  for (const { spec, validatorName, result } of results) {
+    for (const error of result.errors) {
+      addIssue(spec.filePath, {
+        severity: "error",
+        message: error.message,
+        suggestion: error.suggestion,
+        ruleName: validatorName,
+        filePath: spec.filePath,
+        spec
+      }, spec);
+    }
+    for (const warning of result.warnings) {
+      addIssue(spec.filePath, {
+        severity: "warning",
+        message: warning.message,
+        suggestion: warning.suggestion,
+        ruleName: validatorName,
+        filePath: spec.filePath,
+        spec
+      }, spec);
+    }
+  }
+  const fileResults = [];
+  for (const [filePath, data] of fileMap.entries()) {
+    data.issues.sort((a, b) => {
+      if (a.severity === b.severity) return 0;
+      return a.severity === "error" ? -1 : 1;
+    });
+    fileResults.push({ filePath, issues: data.issues, spec: data.spec });
+  }
+  fileResults.sort((a, b) => {
+    if (a.spec?.name && b.spec?.name) {
+      return a.spec.name.localeCompare(b.spec.name);
+    }
+    return a.filePath.localeCompare(b.filePath);
+  });
+  return fileResults;
+}
+function normalizeFilePath(filePath) {
+  const cwd = process.cwd();
+  if (filePath.startsWith(cwd)) {
+    return filePath.substring(cwd.length + 1);
+  } else if (filePath.includes("/specs/")) {
+    const specsIndex = filePath.indexOf("/specs/");
+    return filePath.substring(specsIndex + 1);
+  }
+  return filePath;
+}
+function formatFileIssues(fileResult, specsDir) {
+  const lines = [];
+  const relativePath = normalizeFilePath(fileResult.filePath);
+  const isMainSpec = relativePath.endsWith("README.md");
+  if (isMainSpec && fileResult.spec) {
+    const specName = fileResult.spec.name;
+    const status = fileResult.spec.frontmatter.status;
+    const priority = fileResult.spec.frontmatter.priority || "medium";
+    const statusBadge = formatStatusBadge(status);
+    const priorityBadge = formatPriorityBadge(priority);
+    lines.push(chalk16.bold.cyan(`${specName} ${statusBadge} ${priorityBadge}`));
+  } else {
+    lines.push(chalk16.cyan.underline(relativePath));
+  }
+  for (const issue of fileResult.issues) {
+    const severityColor = issue.severity === "error" ? chalk16.red : chalk16.yellow;
+    const severityText = severityColor(issue.severity.padEnd(9));
+    const ruleText = chalk16.gray(issue.ruleName);
+    lines.push(`  ${severityText}${issue.message.padEnd(60)} ${ruleText}`);
+    if (issue.suggestion) {
+      lines.push(chalk16.gray(`           \u2192 ${issue.suggestion}`));
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatSummary(totalSpecs, errorCount, warningCount, cleanCount) {
+  if (errorCount > 0) {
+    const errorText = errorCount === 1 ? "error" : "errors";
+    const warningText = warningCount === 1 ? "warning" : "warnings";
+    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 +3619,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 +3646,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 +3663,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 +3683,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 +3694,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 +3724,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 +3755,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 +3778,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 +3897,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 +3934,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 +3941,7 @@ function isCriticalOverdue(spec) {
   if (!spec.frontmatter.due) {
     return false;
   }
-  const isOverdue = dayjs(spec.frontmatter.due).isBefore(dayjs(), "day");
+  const isOverdue = dayjs3(spec.frontmatter.due).isBefore(dayjs3(), "day");
   const isCritical = spec.frontmatter.priority === "critical" || spec.frontmatter.priority === "high";
   return isOverdue && isCritical;
 }
@@ -3028,7 +3953,7 @@ function isLongRunning(spec) {
   if (!updatedAt) {
     return false;
   }
-  const daysSinceUpdate = dayjs().diff(dayjs(updatedAt), "day");
+  const daysSinceUpdate = dayjs3().diff(dayjs3(updatedAt), "day");
   return daysSinceUpdate > 7;
 }
 function calculateCompletion(specs) {
@@ -3071,9 +3996,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;
@@ -3083,8 +4005,8 @@ function calculateCycleTime(spec) {
   if (!createdAt || !completedAt) {
     return null;
   }
-  const created = dayjs2(createdAt);
-  const completed = dayjs2(completedAt);
+  const created = dayjs3(createdAt);
+  const completed = dayjs3(completedAt);
   return completed.diff(created, "day", true);
 }
 function calculateLeadTime(spec, fromStatus, toStatus) {
@@ -3097,12 +4019,12 @@ function calculateLeadTime(spec, fromStatus, toStatus) {
   if (!fromTransition || !toTransition) {
     return null;
   }
-  const from = dayjs2(fromTransition.at);
-  const to = dayjs2(toTransition.at);
+  const from = dayjs3(fromTransition.at);
+  const to = dayjs3(toTransition.at);
   return to.diff(from, "day", true);
 }
 function calculateThroughput(specs, days) {
-  const cutoff = dayjs2().subtract(days, "day");
+  const cutoff = dayjs3().subtract(days, "day");
   return specs.filter((s) => {
     if (s.frontmatter.status !== "complete" && s.frontmatter.status !== "archived") {
       return false;
@@ -3111,19 +4033,19 @@ function calculateThroughput(specs, days) {
     if (!completedAt) {
       return false;
     }
-    return dayjs2(completedAt).isAfter(cutoff);
+    return dayjs3(completedAt).isAfter(cutoff);
   }).length;
 }
-function calculateWIP(specs, date = dayjs2()) {
+function calculateWIP(specs, date = dayjs3()) {
   return specs.filter((s) => {
     const createdAt = s.frontmatter.created_at || s.frontmatter.created;
-    const created = dayjs2(createdAt);
+    const created = dayjs3(createdAt);
     if (created.isAfter(date)) {
       return false;
     }
     const completedAt = s.frontmatter.completed_at || s.frontmatter.completed;
     if (completedAt) {
-      const completed = dayjs2(completedAt);
+      const completed = dayjs3(completedAt);
       return completed.isAfter(date);
     }
     return s.frontmatter.status !== "complete" && s.frontmatter.status !== "archived";
@@ -3140,19 +4062,19 @@ function calculateVelocityMetrics(specs) {
   const avgInProgressToComplete = inProgressToCompleteTimes.length > 0 ? inProgressToCompleteTimes.reduce((sum, t) => sum + t, 0) / inProgressToCompleteTimes.length : 0;
   const throughputWeek = calculateThroughput(specs, 7);
   const throughputMonth = calculateThroughput(specs, 30);
-  const prevWeekStart = dayjs2().subtract(14, "day");
-  const prevWeekEnd = dayjs2().subtract(7, "day");
+  const prevWeekStart = dayjs3().subtract(14, "day");
+  const prevWeekEnd = dayjs3().subtract(7, "day");
   const throughputPrevWeek = specs.filter((s) => {
     const completedAt = s.frontmatter.completed_at || s.frontmatter.completed;
     if (!completedAt) return false;
-    const completed = dayjs2(completedAt);
+    const completed = dayjs3(completedAt);
     return completed.isAfter(prevWeekStart) && !completed.isAfter(prevWeekEnd);
   }).length;
   const throughputTrend = throughputWeek > throughputPrevWeek ? "up" : throughputWeek < throughputPrevWeek ? "down" : "stable";
   const currentWIP = calculateWIP(specs);
   const wipSamples = [];
   for (let i = 0; i < 30; i++) {
-    const sampleDate = dayjs2().subtract(i, "day");
+    const sampleDate = dayjs3().subtract(i, "day");
     wipSamples.push(calculateWIP(specs, sampleDate));
   }
   const avgWIP = wipSamples.length > 0 ? wipSamples.reduce((sum, w) => sum + w, 0) / wipSamples.length : 0;
@@ -3196,7 +4118,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 +4133,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 +4153,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 +4167,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 +4212,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 +4243,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,9 +4276,6 @@ function countSpecsByStatusAndPriority(specs) {
   }
   return { statusCounts, priorityCounts, tagCounts };
 }
-
-// src/utils/insights.ts
-import dayjs3 from "dayjs";
 function generateInsights(specs) {
   const insights = [];
   const criticalOverdue = specs.filter(
@@ -3462,7 +4376,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 +4446,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 && dayjs3(s.frontmatter.due).isBefore(dayjs3(), "day") && s.frontmatter.status !== "complete"
         ).length;
         const parts = [];
         if (criticalPlanned > 0) parts.push(chalk16.dim(`${criticalPlanned} planned`));
@@ -3546,7 +4460,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 && dayjs3(s.frontmatter.due).isBefore(dayjs3(), "day") && s.frontmatter.status !== "complete"
         ).length;
         const parts = [];
         if (highPlanned > 0) parts.push(chalk16.dim(`${highPlanned} planned`));
@@ -3708,18 +4622,18 @@ async function statsCommand(options) {
   }
   if (showTimeline) {
     const days = 30;
-    const today = dayjs4();
+    const today = dayjs3();
     const startDate = today.subtract(days, "day");
     const createdByDate = {};
     const completedByDate = {};
     for (const spec of specs) {
-      const created = dayjs4(spec.frontmatter.created);
+      const created = dayjs3(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 = dayjs3(spec.frontmatter.completed);
         if (completed.isAfter(startDate)) {
           const dateKey = completed.format("YYYY-MM-DD");
           completedByDate[dateKey] = (completedByDate[dateKey] || 0) + 1;
@@ -3838,9 +4752,6 @@ async function statsCommand(options) {
     }
   }
 }
-
-// src/commands/search.ts
-import chalk17 from "chalk";
 async function searchCommand(query, options) {
   await autoCheckIfEnabled();
   const filter = {};
@@ -3861,92 +4772,105 @@ async function searchCommand(query, options) {
     console.log("No specs found matching filters.");
     return;
   }
-  const results = [];
-  const queryLower = query.toLowerCase();
-  for (const spec of specs) {
-    if (!spec.content) continue;
-    const matches = [];
-    const lines = spec.content.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.toLowerCase().includes(queryLower)) {
-        const contextStart = Math.max(0, i - 1);
-        const contextEnd = Math.min(lines.length - 1, i + 1);
-        const context = lines.slice(contextStart, contextEnd + 1);
-        const matchLine = context[i - contextStart];
-        const highlighted = highlightMatch(matchLine, query);
-        matches.push(highlighted);
-      }
-    }
-    if (matches.length > 0) {
-      results.push({ spec, matches });
-    }
-  }
+  const searchableSpecs = specs.map((spec) => ({
+    path: spec.path,
+    name: spec.path,
+    status: spec.frontmatter.status,
+    priority: spec.frontmatter.priority,
+    tags: spec.frontmatter.tags,
+    title: spec.frontmatter.title,
+    description: spec.frontmatter.description,
+    content: spec.content
+  }));
+  const searchResult = searchSpecs(query, searchableSpecs, {
+    maxMatchesPerSpec: 5,
+    contextLength: 80
+  });
+  const { results, metadata } = searchResult;
   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)}"`));
+  console.log(chalk16.gray(`   Searched ${metadata.specsSearched} specs in ${metadata.searchTime}ms`));
   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)}`));
+    const { spec, matches, score, totalMatches } = result;
+    const statusEmoji = spec.status === "in-progress" ? "\u{1F528}" : spec.status === "complete" ? "\u2705" : "\u{1F4C5}";
+    console.log(chalk16.cyan(`${statusEmoji} ${sanitizeUserInput(spec.path)} ${chalk16.gray(`(${score}% match)`)}`));
     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}";
-      meta.push(`${priorityEmoji} ${sanitizeUserInput(spec.frontmatter.priority)}`);
+    if (spec.priority) {
+      const priorityEmoji = spec.priority === "critical" ? "\u{1F534}" : spec.priority === "high" ? "\u{1F7E1}" : spec.priority === "medium" ? "\u{1F7E0}" : "\u{1F7E2}";
+      meta.push(`${priorityEmoji} ${sanitizeUserInput(spec.priority)}`);
     }
-    if (spec.frontmatter.tags && spec.frontmatter.tags.length > 0) {
-      meta.push(`[${spec.frontmatter.tags.map((tag) => sanitizeUserInput(tag)).join(", ")}]`);
+    if (spec.tags && spec.tags.length > 0) {
+      meta.push(`[${spec.tags.map((tag) => sanitizeUserInput(tag)).join(", ")}]`);
     }
     if (meta.length > 0) {
-      console.log(chalk17.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(`   ${meta.join(" \u2022 ")}`));
+    }
+    const titleMatch = matches.find((m) => m.field === "title");
+    if (titleMatch) {
+      console.log(`   ${chalk16.bold("Title:")} ${highlightMatches(titleMatch.text, titleMatch.highlights)}`);
+    }
+    const descMatch = matches.find((m) => m.field === "description");
+    if (descMatch) {
+      console.log(`   ${chalk16.bold("Description:")} ${highlightMatches(descMatch.text, descMatch.highlights)}`);
+    }
+    const tagMatches = matches.filter((m) => m.field === "tags");
+    if (tagMatches.length > 0) {
+      console.log(`   ${chalk16.bold("Tags:")} ${tagMatches.map((m) => highlightMatches(m.text, m.highlights)).join(", ")}`);
+    }
+    const contentMatches = matches.filter((m) => m.field === "content");
+    if (contentMatches.length > 0) {
+      console.log(`   ${chalk16.bold("Content matches:")}`);
+      for (const match of contentMatches) {
+        const lineInfo = match.lineNumber ? chalk16.gray(`[L${match.lineNumber}]`) : "";
+        console.log(`   ${lineInfo} ${highlightMatches(match.text, match.highlights)}`);
+      }
     }
-    if (matches.length > maxMatches) {
-      console.log(chalk17.gray(`  ... and ${matches.length - maxMatches} more match${matches.length - maxMatches === 1 ? "" : "es"}`));
+    if (totalMatches > matches.length) {
+      console.log(chalk16.gray(`   ... and ${totalMatches - matches.length} more match${totalMatches - matches.length === 1 ? "" : "es"}`));
     }
     console.log("");
   }
 }
-function highlightMatch(text, query) {
-  const regex = new RegExp(`(${escapeRegex(query)})`, "gi");
-  return text.replace(regex, chalk17.yellow("$1"));
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function highlightMatches(text, highlights) {
+  if (highlights.length === 0) return text;
+  let result = "";
+  let lastEnd = 0;
+  for (const [start, end] of highlights) {
+    result += text.substring(lastEnd, start);
+    result += chalk16.yellow(text.substring(start, end));
+    lastEnd = end;
+  }
+  result += text.substring(lastEnd);
+  return result;
 }
-
-// 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 +4899,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 +4916,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 +4924,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 +4932,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 +4946,8 @@ function findDependencies(spec, specMap) {
     if (dep) {
       deps.push(dep);
     } else {
-      for (const [path20, s] of specMap.entries()) {
-        if (path20.includes(depPath)) {
+      for (const [path26, s] of specMap.entries()) {
+        if (path26.includes(depPath)) {
           deps.push(s);
           break;
         }
@@ -4055,8 +4979,8 @@ function findRelated(spec, specMap) {
     if (rel) {
       related.push(rel);
     } else {
-      for (const [path20, s] of specMap.entries()) {
-        if (path20.includes(relPath)) {
+      for (const [path26, s] of specMap.entries()) {
+        if (path26.includes(relPath)) {
           related.push(s);
           break;
         }
@@ -4114,7 +5038,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 +5049,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 +5063,13 @@ async function timelineCommand(options) {
     console.log("No specs found.");
     return;
   }
-  const today = dayjs5();
+  const today = dayjs3();
   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 = dayjs3(spec.frontmatter.created);
     if (created.isAfter(startDate)) {
       const dateKey = created.format("YYYY-MM-DD");
       createdByDate[dateKey] = (createdByDate[dateKey] || 0) + 1;
@@ -4157,26 +5077,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 = dayjs3(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 +5105,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 = dayjs3(a[0], "MMM YYYY");
+    const dateB = dayjs3(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 = dayjs3(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 = dayjs3(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 = dayjs3(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 = dayjs3(spec.frontmatter.completed);
             if (completed.isAfter(startDate)) {
               tagStats[tag].completed++;
             }
@@ -4249,9 +5169,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 +5180,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 = dayjs3(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 = dayjs3(spec.frontmatter.completed);
           if (completed.isAfter(startDate)) {
             assigneeStats[assignee].completed++;
           }
@@ -4276,18 +5196,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 +5216,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 +5242,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 +5252,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 +5266,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 dayjs3(a.frontmatter.due).diff(dayjs3(b.frontmatter.due));
       }
       return 0;
     });
   };
-  const today = dayjs6();
+  const today = dayjs3();
   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 && dayjs3(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 +5291,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 +5319,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 +5334,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 +5343,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 = dayjs3(spec.frontmatter.due);
   const specStart = today;
   const startDaysFromStart = specStart.diff(startDate, "day");
   const dueDaysFromStart = due.diff(startDate, "day");
@@ -4445,13 +5357,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 +5371,601 @@ 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("");
+}
+async function analyzeCommand(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 readmePath = path2.join(resolvedPath, "README.md");
+    const content = await readFile(readmePath, "utf-8");
+    const structure = analyzeMarkdownStructure(content);
+    const tokenResult = await counter.countSpec(resolvedPath, {
+      detailed: true,
+      includeSubSpecs: false
+      // Only analyze README.md for structure
+    });
+    const indicators = counter.getPerformanceIndicators(tokenResult.total);
+    const sectionsWithTokens = await Promise.all(
+      structure.allSections.map(async (section) => {
+        const sectionContent = content.split("\n").slice(section.startLine - 1, section.endLine).join("\n");
+        const sectionTokens = await counter.countTokensInContent(sectionContent);
+        return {
+          section: section.title,
+          level: section.level,
+          lineRange: [section.startLine, section.endLine],
+          tokens: sectionTokens,
+          subsections: section.subsections.map((s) => s.title)
+        };
+      })
+    );
+    const recommendation = generateRecommendation(tokenResult.total, structure, indicators.level);
+    const result = {
+      spec: specName,
+      path: resolvedPath,
+      metrics: {
+        tokens: tokenResult.total,
+        lines: structure.lines,
+        characters: content.length,
+        sections: structure.sectionsByLevel,
+        codeBlocks: structure.codeBlocks,
+        maxNesting: structure.maxNesting
+      },
+      threshold: {
+        status: indicators.level,
+        limit: getThresholdLimit(indicators.level),
+        message: indicators.recommendation
+      },
+      structure: sectionsWithTokens,
+      recommendation
+    };
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    displayAnalysis(result, options.verbose);
+  } finally {
+    counter.dispose();
+  }
+}
+function generateRecommendation(tokens, structure, level) {
+  if (tokens < 2e3) {
+    return {
+      action: "none",
+      reason: "Spec is under 2,000 tokens (optimal)",
+      confidence: "high"
+    };
+  }
+  if (tokens < 3500) {
+    return {
+      action: "compact",
+      reason: "Spec could benefit from removing redundancy",
+      confidence: "medium"
+    };
+  }
+  if (tokens < 5e3) {
+    const h2Count = structure.sectionsByLevel.h2;
+    if (h2Count >= 3) {
+      return {
+        action: "split",
+        reason: `Exceeds 3,500 token threshold with ${h2Count} concerns`,
+        confidence: "high"
+      };
+    } else {
+      return {
+        action: "split",
+        reason: "Exceeds 3,500 token threshold",
+        confidence: "medium"
+      };
+    }
+  }
+  return {
+    action: "split",
+    reason: "Critically oversized - must split immediately",
+    confidence: "high"
+  };
+}
+function getThresholdLimit(level) {
+  switch (level) {
+    case "excellent":
+      return 2e3;
+    case "good":
+      return 3500;
+    case "warning":
+      return 5e3;
+    case "problem":
+      return 5e3;
+    default:
+      return 2e3;
+  }
+}
+function displayAnalysis(result, verbose) {
+  console.log(chalk16.bold.cyan(`\u{1F4CA} Spec Analysis: ${result.spec}`));
+  console.log("");
+  const statusEmoji = result.threshold.status === "excellent" ? "\u2705" : result.threshold.status === "good" ? "\u{1F44D}" : result.threshold.status === "warning" ? "\u26A0\uFE0F" : "\u{1F534}";
+  const tokenColor = result.threshold.status === "excellent" || result.threshold.status === "good" ? chalk16.cyan : result.threshold.status === "warning" ? chalk16.yellow : chalk16.red;
+  console.log(chalk16.bold("Token Count:"), tokenColor(result.metrics.tokens.toLocaleString()), "tokens", statusEmoji);
+  console.log(chalk16.dim(`  Threshold: ${result.threshold.limit.toLocaleString()} tokens`));
+  console.log(chalk16.dim(`  Status: ${result.threshold.message}`));
+  console.log("");
+  console.log(chalk16.bold("Structure:"));
+  console.log(`  Lines: ${chalk16.cyan(result.metrics.lines.toLocaleString())}`);
+  console.log(`  Sections: ${chalk16.cyan(result.metrics.sections.total)} (H1:${result.metrics.sections.h1}, H2:${result.metrics.sections.h2}, H3:${result.metrics.sections.h3}, H4:${result.metrics.sections.h4})`);
+  console.log(`  Code blocks: ${chalk16.cyan(result.metrics.codeBlocks)}`);
+  console.log(`  Max nesting: ${chalk16.cyan(result.metrics.maxNesting)} levels`);
+  console.log("");
+  if (verbose && result.structure.length > 0) {
+    const topSections = result.structure.filter((s) => s.level <= 2).sort((a, b) => b.tokens - a.tokens).slice(0, 5);
+    console.log(chalk16.bold("Top Sections by Size:"));
+    console.log("");
+    for (let i = 0; i < topSections.length; i++) {
+      const s = topSections[i];
+      const percentage = Math.round(s.tokens / result.metrics.tokens * 100);
+      const indent = "  ".repeat(s.level - 1);
+      console.log(`  ${i + 1}. ${indent}${s.section}`);
+      console.log(`     ${chalk16.cyan(s.tokens.toLocaleString())} tokens / ${s.lineRange[1] - s.lineRange[0] + 1} lines ${chalk16.dim(`(${percentage}%)`)}`);
+      console.log(chalk16.dim(`     Lines ${s.lineRange[0]}-${s.lineRange[1]}`));
+    }
+    console.log("");
+  }
+  const actionColor = result.recommendation.action === "none" ? chalk16.green : result.recommendation.action === "compact" ? chalk16.yellow : result.recommendation.action === "split" ? chalk16.red : chalk16.blue;
+  console.log(chalk16.bold("Recommendation:"), actionColor(result.recommendation.action.toUpperCase()));
+  console.log(chalk16.dim(`  ${result.recommendation.reason}`));
+  console.log(chalk16.dim(`  Confidence: ${result.recommendation.confidence}`));
+  console.log("");
+  if (result.recommendation.action === "split") {
+    console.log(chalk16.dim("\u{1F4A1} Use `lean-spec split` to partition into sub-specs"));
+    console.log(chalk16.dim("\u{1F4A1} Consider splitting by H2 sections (concerns)"));
+  } else if (result.recommendation.action === "compact") {
+    console.log(chalk16.dim("\u{1F4A1} Use `lean-spec compact` to remove redundancy"));
+  }
+  console.log("");
+}
+async function splitCommand(specPath, options) {
+  await autoCheckIfEnabled();
+  try {
+    if (!options.outputs || options.outputs.length === 0) {
+      throw new Error("At least one --output option is required");
+    }
+    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 readmePath = path2.join(resolvedPath, "README.md");
+    const content = await readFile(readmePath, "utf-8");
+    const parsedOutputs = parseOutputSpecs(options.outputs);
+    validateNoOverlaps(parsedOutputs);
+    const extractions = [];
+    for (const output of parsedOutputs) {
+      const extracted = extractLines(content, output.startLine, output.endLine);
+      const lineCount = countLines(extracted);
+      extractions.push({
+        file: output.file,
+        content: extracted,
+        tokens: 0,
+        // Will be calculated in dry-run or actual execution
+        lines: lineCount
+      });
+    }
+    if (options.dryRun) {
+      await displayDryRun(specName, extractions);
+      return;
+    }
+    await executeSplit(resolvedPath, specName, content, extractions, options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk16.red(`Error: ${error.message}`));
+    }
+    throw error;
+  }
+}
+function parseOutputSpecs(outputs) {
+  const parsed = [];
+  for (const output of outputs) {
+    const match = output.lines.match(/^(\d+)-(\d+)$/);
+    if (!match) {
+      throw new Error(`Invalid line range format: ${output.lines}. Expected format: "1-150"`);
+    }
+    const startLine = parseInt(match[1], 10);
+    const endLine = parseInt(match[2], 10);
+    if (startLine < 1 || endLine < startLine) {
+      throw new Error(`Invalid line range: ${output.lines}`);
+    }
+    parsed.push({
+      file: output.file,
+      startLine,
+      endLine
+    });
+  }
+  return parsed;
+}
+function validateNoOverlaps(outputs) {
+  const sorted = [...outputs].sort((a, b) => a.startLine - b.startLine);
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const current = sorted[i];
+    const next = sorted[i + 1];
+    if (current.endLine >= next.startLine) {
+      throw new Error(
+        `Overlapping line ranges: ${current.file} (${current.startLine}-${current.endLine}) overlaps with ${next.file} (${next.startLine}-${next.endLine})`
+      );
+    }
+  }
+}
+async function displayDryRun(specName, extractions) {
+  console.log(chalk16.bold.cyan(`\u{1F4CB} Split Preview: ${specName}`));
+  console.log("");
+  console.log(chalk16.bold("Would create:"));
+  console.log("");
+  for (const ext of extractions) {
+    console.log(`  ${chalk16.cyan(ext.file)}`);
+    console.log(`    Lines: ${ext.lines}`);
+    const previewLines = ext.content.split("\n").slice(0, 3);
+    console.log(chalk16.dim("    Preview:"));
+    for (const line of previewLines) {
+      console.log(chalk16.dim(`      ${line.substring(0, 60)}${line.length > 60 ? "..." : ""}`));
+    }
+    console.log("");
+  }
+  console.log(chalk16.dim("No files modified (dry run)"));
+  console.log(chalk16.dim("Run without --dry-run to apply changes"));
+  console.log("");
+}
+async function executeSplit(specPath, specName, originalContent, extractions, options) {
+  console.log(chalk16.bold.cyan(`\u2702\uFE0F  Splitting: ${specName}`));
+  console.log("");
+  const frontmatter = parseFrontmatterFromString(originalContent);
+  for (const ext of extractions) {
+    const outputPath = path2.join(specPath, ext.file);
+    let finalContent = ext.content;
+    if (ext.file === "README.md" && frontmatter) {
+      const { content: contentWithFrontmatter } = createUpdatedFrontmatter(
+        ext.content,
+        frontmatter
+      );
+      finalContent = contentWithFrontmatter;
+    }
+    await writeFile(outputPath, finalContent, "utf-8");
+    console.log(chalk16.green(`\u2713 Created ${ext.file} (${ext.lines} lines)`));
+  }
+  if (options.updateRefs) {
+    const readmePath = path2.join(specPath, "README.md");
+    const readmeContent = await readFile(readmePath, "utf-8");
+    const updatedReadme = await addSubSpecLinks(
+      readmeContent,
+      extractions.map((e) => e.file).filter((f) => f !== "README.md")
+    );
+    await writeFile(readmePath, updatedReadme, "utf-8");
+    console.log(chalk16.green(`\u2713 Updated README.md with sub-spec links`));
+  }
+  console.log("");
+  console.log(chalk16.bold.green("Split complete!"));
+  console.log(chalk16.dim(`Created ${extractions.length} files in ${specName}`));
+  console.log("");
+}
+async function addSubSpecLinks(content, subSpecs) {
+  if (subSpecs.length === 0) {
+    return content;
+  }
+  if (content.includes("## Sub-Specs") || content.includes("## Sub-specs")) {
+    return content;
+  }
+  const lines = content.split("\n");
+  let insertIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].toLowerCase();
+    if (line.includes("## implementation") || line.includes("## plan") || line.includes("## test")) {
+      insertIndex = i;
+      break;
+    }
+  }
+  if (insertIndex === -1) {
+    insertIndex = lines.length;
+  }
+  const subSpecsSection = [
+    "",
+    "## Sub-Specs",
+    "",
+    "This spec is organized using sub-spec files:",
+    "",
+    ...subSpecs.map((file) => {
+      const name = file.replace(".md", "");
+      return `- **[${name}](./${file})** - ${getFileDescription(file)}`;
+    }),
+    ""
+  ];
+  lines.splice(insertIndex, 0, ...subSpecsSection);
+  return lines.join("\n");
+}
+function getFileDescription(file) {
+  const lower = file.toLowerCase();
+  if (lower.includes("design")) return "Architecture and design details";
+  if (lower.includes("implementation")) return "Implementation plan and phases";
+  if (lower.includes("testing") || lower.includes("test")) return "Test strategy and cases";
+  if (lower.includes("rationale")) return "Design rationale and decisions";
+  if (lower.includes("api")) return "API specification";
+  if (lower.includes("migration")) return "Migration plan and strategy";
+  if (lower.includes("context")) return "Context and research";
+  return "Additional documentation";
+}
+async function compactCommand(specPath, options) {
+  await autoCheckIfEnabled();
+  try {
+    if (!options.removes || options.removes.length === 0) {
+      throw new Error("At least one --remove option is required");
+    }
+    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 readmePath = path2.join(resolvedPath, "README.md");
+    const content = await readFile(readmePath, "utf-8");
+    const parsedRemoves = parseRemoveSpecs(options.removes);
+    validateNoOverlaps2(parsedRemoves);
+    if (options.dryRun) {
+      await displayDryRun2(specName, content, parsedRemoves);
+      return;
+    }
+    await executeCompact(readmePath, specName, content, parsedRemoves);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk16.red(`Error: ${error.message}`));
+    }
+    throw error;
+  }
+}
+function parseRemoveSpecs(removes) {
+  const parsed = [];
+  for (let i = 0; i < removes.length; i++) {
+    const spec = removes[i];
+    const match = spec.match(/^(\d+)-(\d+)$/);
+    if (!match) {
+      throw new Error(`Invalid line range format: ${spec}. Expected format: "145-153"`);
+    }
+    const startLine = parseInt(match[1], 10);
+    const endLine = parseInt(match[2], 10);
+    if (startLine < 1 || endLine < startLine) {
+      throw new Error(`Invalid line range: ${spec}`);
+    }
+    parsed.push({
+      startLine,
+      endLine,
+      originalIndex: i
+    });
+  }
+  return parsed;
+}
+function validateNoOverlaps2(removes) {
+  const sorted = [...removes].sort((a, b) => a.startLine - b.startLine);
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const current = sorted[i];
+    const next = sorted[i + 1];
+    if (current.endLine >= next.startLine) {
+      throw new Error(
+        `Overlapping line ranges: ${current.startLine}-${current.endLine} overlaps with ${next.startLine}-${next.endLine}`
+      );
+    }
+  }
+}
+async function displayDryRun2(specName, content, removes) {
+  console.log(chalk16.bold.cyan(`\u{1F4CB} Compact Preview: ${specName}`));
+  console.log("");
+  console.log(chalk16.bold("Would remove:"));
+  console.log("");
+  let totalLines = 0;
+  for (const remove of removes) {
+    const lineCount = remove.endLine - remove.startLine + 1;
+    totalLines += lineCount;
+    const removedContent = extractLines(content, remove.startLine, remove.endLine);
+    const previewLines = removedContent.split("\n").slice(0, 3);
+    console.log(`  Lines ${remove.startLine}-${remove.endLine} (${lineCount} lines)`);
+    console.log(chalk16.dim("    Preview:"));
+    for (const line of previewLines) {
+      console.log(chalk16.dim(`      ${line.substring(0, 60)}${line.length > 60 ? "..." : ""}`));
+    }
+    if (removedContent.split("\n").length > 3) {
+      console.log(chalk16.dim(`      ... (${removedContent.split("\n").length - 3} more lines)`));
+    }
+    console.log("");
+  }
+  const originalLines = countLines(content);
+  const remainingLines = originalLines - totalLines;
+  const percentage = Math.round(totalLines / originalLines * 100);
+  console.log(chalk16.bold("Summary:"));
+  console.log(`  Original lines:  ${chalk16.cyan(originalLines)}`);
+  console.log(`  Removing:        ${chalk16.yellow(totalLines)} lines (${percentage}%)`);
+  console.log(`  Remaining lines: ${chalk16.cyan(remainingLines)}`);
+  console.log("");
+  console.log(chalk16.dim("No files modified (dry run)"));
+  console.log(chalk16.dim("Run without --dry-run to apply changes"));
+  console.log("");
+}
+async function executeCompact(readmePath, specName, content, removes) {
+  console.log(chalk16.bold.cyan(`\u{1F5DC}\uFE0F  Compacting: ${specName}`));
+  console.log("");
+  const sorted = [...removes].sort((a, b) => b.startLine - a.startLine);
+  let updatedContent = content;
+  let totalRemoved = 0;
+  for (const remove of sorted) {
+    const lineCount = remove.endLine - remove.startLine + 1;
+    updatedContent = removeLines(updatedContent, remove.startLine, remove.endLine);
+    totalRemoved += lineCount;
+    console.log(chalk16.green(`\u2713 Removed lines ${remove.startLine}-${remove.endLine} (${lineCount} lines)`));
+  }
+  await writeFile(readmePath, updatedContent, "utf-8");
+  const originalLines = countLines(content);
+  const finalLines = countLines(updatedContent);
+  const percentage = Math.round(totalRemoved / originalLines * 100);
+  console.log("");
+  console.log(chalk16.bold.green("Compaction complete!"));
+  console.log(chalk16.dim(`Removed ${totalRemoved} lines (${percentage}%)`));
+  console.log(chalk16.dim(`${originalLines} \u2192 ${finalLines} lines`));
+  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 +5974,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 +5995,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 +6025,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 +6046,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 +6055,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 +6081,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 +6115,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 +6124,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 +6144,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 +6158,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 +6188,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 +6199,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);
@@ -4761,24 +6247,46 @@ async function searchSpecsData(query, options) {
     includeContent: true,
     filter
   });
-  const results = [];
-  const queryLower = query.toLowerCase();
-  for (const spec of specs) {
-    if (!spec.content) continue;
-    const matches = [];
-    const lines = spec.content.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.toLowerCase().includes(queryLower)) {
-        matches.push(line.trim());
-        if (matches.length >= 5) break;
-      }
-    }
-    if (matches.length > 0) {
-      results.push({ spec: specToData(spec), matches });
-    }
-  }
-  return results;
+  const searchableSpecs = specs.map((spec) => ({
+    path: spec.path,
+    name: spec.path,
+    status: spec.frontmatter.status,
+    priority: spec.frontmatter.priority,
+    tags: spec.frontmatter.tags,
+    title: spec.frontmatter.title,
+    description: spec.frontmatter.description,
+    content: spec.content
+  }));
+  const searchResult = searchSpecs(query, searchableSpecs, {
+    maxMatchesPerSpec: 5,
+    contextLength: 80
+  });
+  return {
+    results: searchResult.results.map((result) => ({
+      spec: {
+        name: result.spec.name,
+        path: result.spec.path,
+        status: result.spec.status,
+        created: specs.find((s) => s.path === result.spec.path)?.frontmatter.created || "",
+        title: result.spec.title,
+        tags: result.spec.tags,
+        priority: result.spec.priority,
+        assignee: specs.find((s) => s.path === result.spec.path)?.frontmatter.assignee,
+        description: result.spec.description,
+        customFields: specs.find((s) => s.path === result.spec.path)?.frontmatter.custom
+      },
+      score: result.score,
+      totalMatches: result.totalMatches,
+      matches: result.matches.map((match) => ({
+        field: match.field,
+        text: match.text,
+        lineNumber: match.lineNumber,
+        score: match.score,
+        highlights: match.highlights
+      }))
+    })),
+    metadata: searchResult.metadata
+  };
 }
 async function readSpecData(specPath) {
   const cwd = process.cwd();
@@ -4914,28 +6422,44 @@ async function createMcpServer() {
     "search",
     {
       title: "Search Specs",
-      description: "Full-text search across all specification content. Use this when you need to find specs by keyword, topic, or concept. Returns matching specs with relevant excerpts.",
+      description: "Intelligent relevance-ranked search across all specification content. Uses field-weighted scoring (title > tags > description > content) to return the most relevant specs. Returns matching specs with relevance scores, highlighted excerpts, and metadata.",
       inputSchema: {
-        query: z.string().describe("Search term or phrase to find in spec content. Searches across titles, descriptions, and body text."),
+        query: z.string().describe("Search term or phrase to find in spec content. Multiple terms are combined with AND logic. Searches across titles, tags, descriptions, and body text with intelligent relevance ranking."),
         status: z.enum(["planned", "in-progress", "complete", "archived"]).optional().describe("Limit search to specs with this status."),
         tags: z.array(z.string()).optional().describe("Limit search to specs with these tags."),
         priority: z.enum(["low", "medium", "high", "critical"]).optional().describe("Limit search to specs with this priority.")
       },
       outputSchema: {
-        results: z.array(z.any())
+        results: z.array(z.object({
+          spec: z.any(),
+          score: z.number(),
+          totalMatches: z.number(),
+          matches: z.array(z.object({
+            field: z.string(),
+            text: z.string(),
+            lineNumber: z.number().optional(),
+            score: z.number(),
+            highlights: z.array(z.tuple([z.number(), z.number()]))
+          }))
+        })),
+        metadata: z.object({
+          totalResults: z.number(),
+          searchTime: z.number(),
+          query: z.string(),
+          specsSearched: z.number()
+        })
       }
     },
     async (input) => {
       try {
-        const results = await searchSpecsData(input.query, {
+        const searchResult = await searchSpecsData(input.query, {
           status: input.status,
           tags: input.tags,
           priority: input.priority
         });
-        const output = { results };
         return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
+          content: [{ type: "text", text: JSON.stringify(searchResult, null, 2) }],
+          structuredContent: searchResult
         };
       } catch (error) {
         const errorMessage = formatErrorMessage("Error searching specs", error);
@@ -5447,6 +6971,81 @@ ${result.content}`;
       }
     }
   );
+  server.registerTool(
+    "tokens",
+    {
+      title: "Count Tokens",
+      description: "Count tokens in spec or sub-spec for LLM context management. Use this before loading specs to check if they fit in context budget.",
+      inputSchema: {
+        specPath: z.string().describe('Spec name, number, or file path (e.g., "059", "unified-dashboard", "059/DESIGN.md")'),
+        includeSubSpecs: z.boolean().optional().describe("Include all sub-spec files in count (default: false)"),
+        detailed: z.boolean().optional().describe("Return breakdown by content type (code, prose, tables, frontmatter)")
+      },
+      outputSchema: {
+        spec: z.string(),
+        total: z.number(),
+        files: z.array(z.any()),
+        breakdown: z.any().optional(),
+        performance: z.any().optional(),
+        recommendation: z.string().optional()
+      }
+    },
+    async (input) => {
+      const counter = new TokenCounter();
+      try {
+        const config = await loadConfig();
+        const cwd = process.cwd();
+        const specsDir = path2.join(cwd, config.specsDir);
+        const resolvedPath = await resolveSpecPath(input.specPath, cwd, specsDir);
+        if (!resolvedPath) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              error: `Spec not found: ${input.specPath}`,
+              code: "SPEC_NOT_FOUND"
+            }, null, 2) }],
+            isError: true
+          };
+        }
+        const specName = path2.basename(resolvedPath);
+        const result = await counter.countSpec(resolvedPath, {
+          detailed: input.detailed,
+          includeSubSpecs: input.includeSubSpecs
+        });
+        const output = {
+          spec: specName,
+          total: result.total,
+          files: result.files
+        };
+        if (input.detailed && result.breakdown) {
+          output.breakdown = result.breakdown;
+          const indicators = counter.getPerformanceIndicators(result.total);
+          output.performance = {
+            level: indicators.level,
+            costMultiplier: indicators.costMultiplier,
+            effectiveness: indicators.effectiveness,
+            recommendation: indicators.recommendation
+          };
+        }
+        if (result.total > 5e3) {
+          output.recommendation = "\u26A0\uFE0F Total >5K tokens - consider loading README.md only";
+        } else if (result.total > 3500) {
+          output.recommendation = "\u26A0\uFE0F Total >3.5K tokens - consider loading in sections";
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+          structuredContent: output
+        };
+      } catch (error) {
+        const errorMessage = formatErrorMessage("Error counting tokens", error);
+        return {
+          content: [{ type: "text", text: errorMessage }],
+          isError: true
+        };
+      } finally {
+        counter.dispose();
+      }
+    }
+  );
   server.registerResource(
     "spec",
     new ResourceTemplate("spec://{specPath}", { list: void 0 }),
@@ -5626,31 +7225,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, analyzeCommand, archiveSpec, backfillTimestamps, boardCommand, checkSpecs, compactCommand, copyTemplate, createMcpServer, createSpec, depsCommand, filesCommand, ganttCommand, initProject, listSpecs, listTemplates, mcpCommand, migrateCommand, openCommand, removeTemplate, searchCommand, showTemplate, splitCommand, statsCommand, timelineCommand, tokensAllCommand, tokensCommand, updateSpec, validateCommand, viewCommand };
+//# sourceMappingURL=chunk-7MCDTSVE.js.map
+//# sourceMappingURL=chunk-7MCDTSVE.js.map