lean-spec 0.2.7 → 0.2.9-dev.20251205030455

package/dist/chunk-CJMVV46H.js

@@ -0,0 +1,2990 @@
+import { loadConfig, loadAllSpecs, loadSubFiles } from './chunk-RF5PKL6L.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import chalk3 from 'chalk';
+import { Command } from 'commander';
+import ora from 'ora';
+import stripAnsi from 'strip-ansi';
+import matter3 from 'gray-matter';
+import yaml2 from 'js-yaml';
+import 'dayjs';
+
+function sanitizeUserInput(input) {
+  if (typeof input !== "string") {
+    return "";
+  }
+  if (!input) {
+    return "";
+  }
+  let sanitized = stripAnsi(input);
+  sanitized = sanitized.replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/g, "");
+  return sanitized;
+}
+
+// src/utils/ui.ts
+async function withSpinner(text, fn, options) {
+  const spinner = ora(text).start();
+  try {
+    const result = await fn();
+    spinner.succeed(options?.successText || text);
+    return result;
+  } catch (error) {
+    spinner.fail(options?.failText || `${text} failed`);
+    throw error;
+  }
+}
+var FrontmatterValidator = class {
+  name = "frontmatter";
+  description = "Validate spec frontmatter for required fields and valid values";
+  validStatuses;
+  validPriorities;
+  constructor(options = {}) {
+    this.validStatuses = options.validStatuses ?? ["planned", "in-progress", "complete", "archived"];
+    this.validPriorities = options.validPriorities ?? ["low", "medium", "high", "critical"];
+  }
+  validate(spec, content) {
+    const errors = [];
+    const warnings = [];
+    let parsed;
+    try {
+      parsed = matter3(content, {
+        engines: {
+          yaml: (str) => yaml2.load(str, { schema: yaml2.FAILSAFE_SCHEMA })
+        }
+      });
+    } catch (error) {
+      errors.push({
+        message: "Failed to parse frontmatter YAML",
+        suggestion: "Check for YAML syntax errors in frontmatter"
+      });
+      return { passed: false, errors, warnings };
+    }
+    const frontmatter = parsed.data;
+    if (!frontmatter || Object.keys(frontmatter).length === 0) {
+      errors.push({
+        message: "No frontmatter found",
+        suggestion: "Add YAML frontmatter at the top of the file between --- delimiters"
+      });
+      return { passed: false, errors, warnings };
+    }
+    if (!frontmatter.status) {
+      errors.push({
+        message: "Missing required field: status",
+        suggestion: "Add status field (valid values: planned, in-progress, complete, archived)"
+      });
+    } else {
+      const statusStr = String(frontmatter.status);
+      if (!this.validStatuses.includes(statusStr)) {
+        errors.push({
+          message: `Invalid status: "${statusStr}"`,
+          suggestion: `Valid values: ${this.validStatuses.join(", ")}`
+        });
+      }
+    }
+    if (!frontmatter.created) {
+      errors.push({
+        message: "Missing required field: created",
+        suggestion: "Add created field with date in YYYY-MM-DD format"
+      });
+    } else {
+      const dateValidation = this.validateDateField(frontmatter.created, "created");
+      if (!dateValidation.valid) {
+        errors.push({
+          message: dateValidation.message,
+          suggestion: dateValidation.suggestion
+        });
+      }
+    }
+    if (frontmatter.priority) {
+      const priorityStr = String(frontmatter.priority);
+      if (!this.validPriorities.includes(priorityStr)) {
+        errors.push({
+          message: `Invalid priority: "${priorityStr}"`,
+          suggestion: `Valid values: ${this.validPriorities.join(", ")}`
+        });
+      }
+    }
+    if (frontmatter.tags !== void 0 && frontmatter.tags !== null) {
+      if (!Array.isArray(frontmatter.tags)) {
+        errors.push({
+          message: 'Field "tags" must be an array',
+          suggestion: "Use array format: tags: [tag1, tag2]"
+        });
+      }
+    }
+    const dateFields = ["updated", "completed", "due"];
+    for (const field of dateFields) {
+      if (frontmatter[field]) {
+        const dateValidation = this.validateDateField(frontmatter[field], field);
+        if (!dateValidation.valid) {
+          warnings.push({
+            message: dateValidation.message,
+            suggestion: dateValidation.suggestion
+          });
+        }
+      }
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Validate date field format (ISO 8601: YYYY-MM-DD or full timestamp)
+   */
+  validateDateField(value, fieldName) {
+    if (value instanceof Date) {
+      return { valid: true };
+    }
+    if (typeof value !== "string") {
+      return {
+        valid: false,
+        message: `Field "${fieldName}" must be a string or date`,
+        suggestion: "Use YYYY-MM-DD format (e.g., 2025-11-05)"
+      };
+    }
+    const isoDateRegex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})?)?$/;
+    if (!isoDateRegex.test(value)) {
+      return {
+        valid: false,
+        message: `Field "${fieldName}" has invalid date format: "${value}"`,
+        suggestion: "Use ISO 8601 format: YYYY-MM-DD (e.g., 2025-11-05)"
+      };
+    }
+    const date = new Date(value);
+    if (isNaN(date.getTime())) {
+      return {
+        valid: false,
+        message: `Field "${fieldName}" has invalid date: "${value}"`,
+        suggestion: "Ensure date is valid (e.g., month 01-12, day 01-31)"
+      };
+    }
+    return { valid: true };
+  }
+};
+var StructureValidator = class {
+  name = "structure";
+  description = "Validate spec structure and required sections";
+  requiredSections;
+  strict;
+  constructor(options = {}) {
+    this.requiredSections = options.requiredSections ?? ["Overview", "Design"];
+    this.strict = options.strict ?? false;
+  }
+  async validate(spec, content) {
+    const errors = [];
+    const warnings = [];
+    let parsed;
+    try {
+      parsed = matter3(content);
+    } catch (error) {
+      errors.push({
+        message: "Failed to parse frontmatter",
+        suggestion: "Check YAML frontmatter syntax"
+      });
+      return { passed: false, errors, warnings };
+    }
+    const body = parsed.content;
+    const h1Match = body.match(/^#\s+(.+)$/m);
+    if (!h1Match) {
+      errors.push({
+        message: "Missing H1 title (# Heading)",
+        suggestion: "Add a title as the first heading in the spec"
+      });
+    }
+    const headings = this.extractHeadings(body);
+    const duplicates = this.findDuplicateHeaders(headings);
+    for (const dup of duplicates) {
+      errors.push({
+        message: `Duplicate section header: ${"#".repeat(dup.level)} ${dup.text}`,
+        suggestion: "Remove or rename duplicate section headers"
+      });
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Extract all headings from markdown content (excluding code blocks)
+   */
+  extractHeadings(content) {
+    const headings = [];
+    const lines = content.split("\n");
+    let inCodeBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim().startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+        continue;
+      }
+      if (inCodeBlock) {
+        continue;
+      }
+      const match = line.match(/^(#{1,6})\s+(.+)$/);
+      if (match) {
+        headings.push({
+          level: match[1].length,
+          text: match[2].trim(),
+          line: i + 1
+        });
+      }
+    }
+    return headings;
+  }
+  /**
+   * Find empty sections (sections with no content until next heading)
+   */
+  findEmptySections(content, headings) {
+    const emptySections = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < headings.length; i++) {
+      const heading = headings[i];
+      if (heading.level !== 2) {
+        continue;
+      }
+      let nextSameLevelIndex = i + 1;
+      while (nextSameLevelIndex < headings.length && headings[nextSameLevelIndex].level > heading.level) {
+        nextSameLevelIndex++;
+      }
+      const nextHeading = headings[nextSameLevelIndex];
+      const startLine = heading.line;
+      const endLine = nextHeading ? nextHeading.line - 1 : lines.length;
+      const sectionLines = lines.slice(startLine, endLine);
+      const hasSubsections = headings.some(
+        (h, idx) => idx > i && idx < nextSameLevelIndex && h.level > heading.level
+      );
+      if (hasSubsections) {
+        continue;
+      }
+      const hasContent = sectionLines.some((line) => {
+        const trimmed = line.trim();
+        return trimmed.length > 0 && !trimmed.startsWith("<!--") && !trimmed.startsWith("//");
+      });
+      if (!hasContent) {
+        emptySections.push(heading.text);
+      }
+    }
+    return emptySections;
+  }
+  /**
+   * Find duplicate headers at the same level
+   */
+  findDuplicateHeaders(headings) {
+    const seen = /* @__PURE__ */ new Map();
+    const duplicates = [];
+    for (const heading of headings) {
+      const key = `${heading.level}:${heading.text.toLowerCase()}`;
+      const count = seen.get(key) ?? 0;
+      seen.set(key, count + 1);
+      if (count === 1) {
+        duplicates.push({ level: heading.level, text: heading.text });
+      }
+    }
+    return duplicates;
+  }
+};
+
+// src/validators/corruption.ts
+var CorruptionValidator = class {
+  name = "corruption";
+  description = "Detect file corruption from failed edits";
+  options;
+  constructor(options = {}) {
+    this.options = {
+      checkCodeBlocks: options.checkCodeBlocks ?? true,
+      checkMarkdownStructure: options.checkMarkdownStructure ?? true,
+      checkDuplicateContent: options.checkDuplicateContent ?? true,
+      duplicateBlockSize: options.duplicateBlockSize ?? 8,
+      duplicateMinLength: options.duplicateMinLength ?? 200
+    };
+  }
+  validate(_spec, content) {
+    const errors = [];
+    const warnings = [];
+    const codeBlockRanges = this.parseCodeBlockRanges(content);
+    if (this.options.checkCodeBlocks) {
+      const codeBlockErrors = this.validateCodeBlocks(content);
+      errors.push(...codeBlockErrors);
+    }
+    if (this.options.checkMarkdownStructure) {
+      const markdownErrors = this.validateMarkdownStructure(content, codeBlockRanges);
+      errors.push(...markdownErrors);
+    }
+    if (this.options.checkDuplicateContent) {
+      const duplicateWarnings = this.detectDuplicateContent(content);
+      warnings.push(...duplicateWarnings);
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Parse all code block ranges in the document
+   * Returns array of {start, end} line numbers (1-indexed)
+   */
+  parseCodeBlockRanges(content) {
+    const ranges = [];
+    const lines = content.split("\n");
+    let inCodeBlock = false;
+    let blockStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim().startsWith("```")) {
+        if (!inCodeBlock) {
+          inCodeBlock = true;
+          blockStart = i + 1;
+        } else {
+          ranges.push({
+            start: blockStart,
+            end: i + 1
+            // 1-indexed, inclusive
+          });
+          inCodeBlock = false;
+          blockStart = -1;
+        }
+      }
+    }
+    return ranges;
+  }
+  /**
+   * Check if a line number is inside a code block
+   */
+  isInCodeBlock(lineNumber, codeBlockRanges) {
+    return codeBlockRanges.some(
+      (range) => lineNumber >= range.start && lineNumber <= range.end
+    );
+  }
+  /**
+   * Get content outside code blocks for analysis
+   */
+  getContentOutsideCodeBlocks(content, codeBlockRanges) {
+    const lines = content.split("\n");
+    const filteredLines = lines.filter((_, index) => {
+      const lineNumber = index + 1;
+      return !this.isInCodeBlock(lineNumber, codeBlockRanges);
+    });
+    return filteredLines.join("\n");
+  }
+  /**
+   * Validate code blocks are properly closed
+   * This is the #1 indicator of corruption - causes visible syntax highlighting issues
+   */
+  validateCodeBlocks(content) {
+    const errors = [];
+    const lines = content.split("\n");
+    let inCodeBlock = false;
+    let codeBlockStartLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim().startsWith("```")) {
+        if (!inCodeBlock) {
+          inCodeBlock = true;
+          codeBlockStartLine = i + 1;
+        } else {
+          inCodeBlock = false;
+          codeBlockStartLine = -1;
+        }
+      }
+    }
+    if (inCodeBlock) {
+      errors.push({
+        message: `Unclosed code block starting at line ${codeBlockStartLine}`,
+        suggestion: "Add closing ``` to complete the code block"
+      });
+    }
+    return errors;
+  }
+  /**
+   * Detect duplicate content blocks
+   * Improved tuning to reduce false positives
+   * 
+   * Thresholds:
+   * - Block size: 8 lines - requires substantial duplication
+   * - Min length: 200 chars - ignores short similar sections
+   * - Filters overlapping windows - prevents adjacent line false positives
+   */
+  detectDuplicateContent(content) {
+    const warnings = [];
+    const lines = content.split("\n");
+    const blockSize = this.options.duplicateBlockSize;
+    const minLength = this.options.duplicateMinLength;
+    const blocks = /* @__PURE__ */ new Map();
+    for (let i = 0; i <= lines.length - blockSize; i++) {
+      const block = lines.slice(i, i + blockSize).map((l) => l.trim()).filter((l) => l.length > 0).join("\n");
+      if (block.length >= minLength) {
+        if (!blocks.has(block)) {
+          blocks.set(block, []);
+        }
+        blocks.get(block).push(i + 1);
+      }
+    }
+    for (const [block, lineNumbers] of blocks.entries()) {
+      if (lineNumbers.length > 1) {
+        const nonOverlapping = [];
+        for (const lineNum of lineNumbers) {
+          const isOverlapping = nonOverlapping.some(
+            (existing) => Math.abs(existing - lineNum) < blockSize
+          );
+          if (!isOverlapping) {
+            nonOverlapping.push(lineNum);
+          }
+        }
+        if (nonOverlapping.length > 1) {
+          warnings.push({
+            message: `Duplicate content block found at lines: ${nonOverlapping.join(", ")}`,
+            suggestion: "Check for merge artifacts or failed edits"
+          });
+        }
+      }
+    }
+    return warnings;
+  }
+  /**
+   * Validate markdown structure (excluding code blocks)
+   * Only checks actual content for formatting issues
+   */
+  validateMarkdownStructure(content, codeBlockRanges) {
+    const errors = [];
+    const contentOutsideCodeBlocks = this.getContentOutsideCodeBlocks(content, codeBlockRanges);
+    const lines = contentOutsideCodeBlocks.split("\n");
+    const linesWithoutListMarkers = lines.map((line) => {
+      const trimmed = line.trim();
+      if (trimmed.match(/^[-*+]\s/)) {
+        return line.replace(/^(\s*)([-*+]\s)/, "$1  ");
+      }
+      return line;
+    });
+    let contentWithoutListMarkers = linesWithoutListMarkers.join("\n");
+    contentWithoutListMarkers = contentWithoutListMarkers.replace(/`[^`]*`/g, "");
+    const boldMatches = contentWithoutListMarkers.match(/\*\*/g) || [];
+    const withoutBold = contentWithoutListMarkers.split("**").join("");
+    const italicMatches = withoutBold.match(/\*/g) || [];
+    if (boldMatches.length % 2 !== 0) {
+      errors.push({
+        message: "Unclosed bold formatting (**)",
+        suggestion: "Check for missing closing ** in markdown content (not code blocks)"
+      });
+    }
+    if (italicMatches.length % 2 !== 0) {
+      errors.push({
+        message: "Unclosed italic formatting (*)",
+        suggestion: "Check for missing closing * in markdown content (not code blocks)"
+      });
+    }
+    return errors;
+  }
+};
+function normalizeDateFields(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];
+    }
+  }
+}
+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];
+    }
+  }
+  if (previousData && data.status !== previousData.status) {
+    if (!Array.isArray(data.transitions)) {
+      data.transitions = [];
+    }
+    data.transitions.push({
+      status: data.status,
+      at: now
+    });
+  }
+}
+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());
+    }
+  }
+}
+function validateCustomField(value, expectedType) {
+  switch (expectedType) {
+    case "string":
+      if (typeof value === "string") {
+        return { valid: true, coerced: value };
+      }
+      return { valid: true, coerced: String(value) };
+    case "number":
+      if (typeof value === "number") {
+        return { valid: true, coerced: value };
+      }
+      const num = Number(value);
+      if (!isNaN(num)) {
+        return { valid: true, coerced: num };
+      }
+      return { valid: false, error: `Cannot convert '${value}' to number` };
+    case "boolean":
+      if (typeof value === "boolean") {
+        return { valid: true, coerced: value };
+      }
+      if (value === "true" || value === "yes" || value === "1") {
+        return { valid: true, coerced: true };
+      }
+      if (value === "false" || value === "no" || value === "0") {
+        return { valid: true, coerced: false };
+      }
+      return { valid: false, error: `Cannot convert '${value}' to boolean` };
+    case "array":
+      if (Array.isArray(value)) {
+        return { valid: true, coerced: value };
+      }
+      return { valid: false, error: `Expected array but got ${typeof value}` };
+    default:
+      return { valid: false, error: `Unknown type: ${expectedType}` };
+  }
+}
+function validateCustomFields(frontmatter, config) {
+  if (!config?.frontmatter?.custom) {
+    return frontmatter;
+  }
+  const result = { ...frontmatter };
+  for (const [fieldName, expectedType] of Object.entries(config.frontmatter.custom)) {
+    if (fieldName in result) {
+      const validation = validateCustomField(result[fieldName], expectedType);
+      if (validation.valid) {
+        result[fieldName] = validation.coerced;
+      } else {
+        console.warn(`Warning: Invalid custom field '${fieldName}': ${validation.error}`);
+      }
+    }
+  }
+  return result;
+}
+function parseFrontmatterFromString(content, filePath, config) {
+  try {
+    const parsed = matter3(content, {
+      engines: {
+        yaml: (str) => yaml2.load(str, { schema: yaml2.FAILSAFE_SCHEMA })
+      }
+    });
+    if (!parsed.data || Object.keys(parsed.data).length === 0) {
+      return parseFallbackFields(content);
+    }
+    if (!parsed.data.status) {
+      if (filePath) console.warn(`Warning: Missing required field 'status' in ${filePath}`);
+      return null;
+    }
+    if (!parsed.data.created) {
+      if (filePath) console.warn(`Warning: Missing required field 'created' in ${filePath}`);
+      return null;
+    }
+    const validStatuses = ["planned", "in-progress", "complete", "archived"];
+    if (!validStatuses.includes(parsed.data.status)) {
+      if (filePath) {
+        console.warn(`Warning: Invalid status '${parsed.data.status}' in ${filePath}. Valid values: ${validStatuses.join(", ")}`);
+      }
+    }
+    if (parsed.data.priority) {
+      const validPriorities = ["low", "medium", "high", "critical"];
+      if (!validPriorities.includes(parsed.data.priority)) {
+        if (filePath) {
+          console.warn(`Warning: Invalid priority '${parsed.data.priority}' in ${filePath}. Valid values: ${validPriorities.join(", ")}`);
+        }
+      }
+    }
+    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) {
+      console.warn(`Info: Unknown fields in ${filePath}: ${unknownFields.join(", ")}`);
+    }
+    const validatedData = validateCustomFields(parsed.data, config);
+    return validatedData;
+  } catch (error) {
+    console.error(`Error parsing frontmatter${filePath ? ` from ${filePath}` : ""}:`, error);
+    return null;
+  }
+}
+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 = matter3(existingContent, {
+    engines: {
+      yaml: (str) => yaml2.load(str, { schema: yaml2.FAILSAFE_SCHEMA })
+    }
+  });
+  const previousData = { ...parsed.data };
+  const newData = { ...parsed.data, ...updates };
+  normalizeDateFields(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 = matter3.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}`;
+  }
+  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);
+    }
+  }
+  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;
+    }
+    if (inCodeBlock) {
+      continue;
+    }
+    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);
+    }
+  }
+  while (sectionStack.length > 0) {
+    const closedSection = sectionStack.pop();
+    closedSection.endLine = lines.length;
+    closedSection.lineCount = closedSection.endLine - closedSection.startLine + 1;
+  }
+  return sections;
+}
+function flattenSections(sections) {
+  const result = [];
+  for (const section of sections) {
+    result.push(section);
+    result.push(...flattenSections(section.subsections));
+  }
+  return result;
+}
+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}`);
+  }
+  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.splice(startLine - 1, endLine - startLine + 1);
+  return lines.join("\n");
+}
+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 = null;
+  async getEncoding() {
+    if (!this.encoding) {
+      const { encoding_for_model } = await import('tiktoken');
+      this.encoding = encoding_for_model("gpt-4");
+    }
+    return this.encoding;
+  }
+  /**
+   * Clean up resources (important to prevent memory leaks)
+   */
+  dispose() {
+    if (this.encoding) {
+      this.encoding.free();
+    }
+  }
+  /**
+   * Count tokens in a string
+   */
+  async countString(text) {
+    const encoding = await this.getEncoding();
+    const tokens = 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 fs.readFile(filePath, "utf-8");
+    const tokens = await 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 fs.stat(specPath);
+    if (stats.isFile()) {
+      return this.countFile(specPath, options);
+    }
+    const files = await fs.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 = path.join(specPath, file);
+      const content = await fs.readFile(filePath, "utf-8");
+      const tokens = await 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 = matter3(content);
+      body = parsed.content;
+      frontmatterContent = parsed.matter;
+      breakdown.frontmatter = await 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 += await this.countString(line + "\n");
+        continue;
+      }
+      if (inCodeBlock) {
+        breakdown.code += await 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 += await this.countString(line + "\n");
+        continue;
+      } else if (inTable && !isTableRow) {
+        inTable = false;
+      }
+      breakdown.prose += await 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: await counter.countString(input),
+        files: []
+      };
+    } else if ("content" in input) {
+      return {
+        total: await 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
+        });
+      }
+    }
+    const lineWarning = this.checkLineCounts(metrics.lineCount);
+    if (lineWarning) {
+      warnings.push(lineWarning);
+    }
+    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;
+  }
+  /**
+   * Provide warnings when line counts exceed backstop thresholds
+   */
+  checkLineCounts(lineCount) {
+    if (lineCount > this.maxLines) {
+      return {
+        message: `Spec is very long at ${lineCount.toLocaleString()} lines (limit ${this.maxLines.toLocaleString()})`,
+        suggestion: "Split the document or move details to sub-spec files to keep context manageable"
+      };
+    }
+    if (lineCount > this.warningLines) {
+      return {
+        message: `Spec is ${lineCount.toLocaleString()} lines \u2014 approaching the ${this.warningLines.toLocaleString()} line backstop`,
+        suggestion: "Watch size growth and consider progressive disclosure before hitting hard limits"
+      };
+    }
+    return null;
+  }
+  /**
+   * Analyze complexity metrics from spec content
+   */
+  async analyzeComplexity(content, spec) {
+    let body;
+    try {
+      const parsed = matter3(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 = await counter.countString(content);
+    counter.dispose();
+    let hasSubSpecs = false;
+    let subSpecCount = 0;
+    try {
+      const specDir = path.dirname(spec.filePath);
+      const files = await fs.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 SpecDependencyGraph = class {
+  graph;
+  specs;
+  constructor(allSpecs) {
+    this.graph = /* @__PURE__ */ new Map();
+    this.specs = /* @__PURE__ */ new Map();
+    this.buildGraph(allSpecs);
+  }
+  /**
+   * Build the complete dependency graph from all specs
+   */
+  buildGraph(specs) {
+    for (const spec of specs) {
+      this.specs.set(spec.path, spec);
+      this.graph.set(spec.path, {
+        dependsOn: new Set(spec.frontmatter.depends_on || []),
+        requiredBy: /* @__PURE__ */ new Set()
+      });
+    }
+    for (const [specPath, node] of this.graph.entries()) {
+      for (const dep of node.dependsOn) {
+        const depNode = this.graph.get(dep);
+        if (depNode) {
+          depNode.requiredBy.add(specPath);
+        }
+      }
+    }
+  }
+  /**
+   * Get complete dependency graph for a spec
+   */
+  getCompleteGraph(specPath) {
+    const spec = this.specs.get(specPath);
+    if (!spec) {
+      throw new Error(`Spec not found: ${specPath}`);
+    }
+    const node = this.graph.get(specPath);
+    if (!node) {
+      throw new Error(`Graph node not found: ${specPath}`);
+    }
+    return {
+      current: spec,
+      dependsOn: this.getSpecsByPaths(Array.from(node.dependsOn)),
+      requiredBy: this.getSpecsByPaths(Array.from(node.requiredBy))
+    };
+  }
+  /**
+   * Get upstream dependencies (specs this one depends on)
+   * Recursively traverses the dependsOn chain up to maxDepth
+   */
+  getUpstream(specPath, maxDepth = 3) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const traverse = (path32, depth) => {
+      if (visited.has(path32)) {
+        return;
+      }
+      visited.add(path32);
+      const node = this.graph.get(path32);
+      if (!node) return;
+      for (const dep of node.dependsOn) {
+        if (!visited.has(dep)) {
+          if (depth < maxDepth) {
+            const spec = this.specs.get(dep);
+            if (spec) {
+              result.push(spec);
+              traverse(dep, depth + 1);
+            }
+          }
+        }
+      }
+    };
+    traverse(specPath, 0);
+    return result;
+  }
+  /**
+   * Get downstream dependents (specs that depend on this one)
+   * Recursively traverses the requiredBy chain up to maxDepth
+   */
+  getDownstream(specPath, maxDepth = 3) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const traverse = (path32, depth) => {
+      if (visited.has(path32)) {
+        return;
+      }
+      visited.add(path32);
+      const node = this.graph.get(path32);
+      if (!node) return;
+      for (const dep of node.requiredBy) {
+        if (!visited.has(dep)) {
+          if (depth < maxDepth) {
+            const spec = this.specs.get(dep);
+            if (spec) {
+              result.push(spec);
+              traverse(dep, depth + 1);
+            }
+          }
+        }
+      }
+    };
+    traverse(specPath, 0);
+    return result;
+  }
+  /**
+   * Get impact radius - all specs affected by changes to this spec
+   * Includes upstream dependencies and downstream dependents
+   */
+  getImpactRadius(specPath, maxDepth = 3) {
+    const spec = this.specs.get(specPath);
+    if (!spec) {
+      throw new Error(`Spec not found: ${specPath}`);
+    }
+    return {
+      current: spec,
+      upstream: this.getUpstream(specPath, maxDepth),
+      downstream: this.getDownstream(specPath, maxDepth)
+    };
+  }
+  /**
+   * Check if a circular dependency exists
+   */
+  hasCircularDependency(specPath) {
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const hasCycle = (path32) => {
+      if (recursionStack.has(path32)) {
+        return true;
+      }
+      if (visited.has(path32)) {
+        return false;
+      }
+      visited.add(path32);
+      recursionStack.add(path32);
+      const node = this.graph.get(path32);
+      if (node) {
+        for (const dep of node.dependsOn) {
+          if (hasCycle(dep)) {
+            return true;
+          }
+        }
+      }
+      recursionStack.delete(path32);
+      return false;
+    };
+    return hasCycle(specPath);
+  }
+  /**
+   * Get all specs in the graph
+   */
+  getAllSpecs() {
+    return Array.from(this.specs.values());
+  }
+  /**
+   * Get specs by their paths
+   */
+  getSpecsByPaths(paths) {
+    return paths.map((path32) => this.specs.get(path32)).filter((spec) => spec !== void 0);
+  }
+};
+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 containsAnyTerm(text, queryTerms) {
+  const textLower = text.toLowerCase();
+  return queryTerms.some((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];
+}
+var SUPPORTED_FIELDS = [
+  "status",
+  "tag",
+  "tags",
+  "priority",
+  "assignee",
+  "title",
+  "name",
+  "created",
+  "updated"
+];
+function tokenize(query) {
+  const tokens = [];
+  let position = 0;
+  while (position < query.length) {
+    if (/\s/.test(query[position])) {
+      position++;
+      continue;
+    }
+    if (query[position] === '"') {
+      const start2 = position;
+      position++;
+      let phrase = "";
+      while (position < query.length && query[position] !== '"') {
+        phrase += query[position];
+        position++;
+      }
+      position++;
+      tokens.push({ type: "PHRASE", value: phrase, position: start2 });
+      continue;
+    }
+    if (query[position] === "(") {
+      tokens.push({ type: "LPAREN", value: "(", position });
+      position++;
+      continue;
+    }
+    if (query[position] === ")") {
+      tokens.push({ type: "RPAREN", value: ")", position });
+      position++;
+      continue;
+    }
+    const start = position;
+    let word = "";
+    while (position < query.length && !/[\s()"]/.test(query[position])) {
+      word += query[position];
+      position++;
+    }
+    if (word.length === 0) continue;
+    const upperWord = word.toUpperCase();
+    if (upperWord === "AND") {
+      tokens.push({ type: "AND", value: word, position: start });
+      continue;
+    }
+    if (upperWord === "OR") {
+      tokens.push({ type: "OR", value: word, position: start });
+      continue;
+    }
+    if (upperWord === "NOT") {
+      tokens.push({ type: "NOT", value: word, position: start });
+      continue;
+    }
+    const colonIndex = word.indexOf(":");
+    if (colonIndex > 0) {
+      const fieldName = word.substring(0, colonIndex).toLowerCase();
+      if (SUPPORTED_FIELDS.includes(fieldName)) {
+        tokens.push({ type: "FIELD", value: word, position: start });
+        continue;
+      }
+    }
+    if (word.endsWith("~")) {
+      tokens.push({ type: "FUZZY", value: word.slice(0, -1), position: start });
+      continue;
+    }
+    tokens.push({ type: "TERM", value: word, position: start });
+  }
+  tokens.push({ type: "EOF", value: "", position: query.length });
+  return tokens;
+}
+var QueryParser = class {
+  tokens;
+  current = 0;
+  errors = [];
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  parse() {
+    if (this.tokens.length <= 1) {
+      return { ast: null, errors: [] };
+    }
+    try {
+      const ast = this.parseExpression();
+      return { ast, errors: this.errors };
+    } catch {
+      return { ast: null, errors: this.errors };
+    }
+  }
+  parseExpression() {
+    return this.parseOr();
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    if (!left) return null;
+    while (this.check("OR")) {
+      this.advance();
+      const right = this.parseAnd();
+      if (!right) {
+        this.errors.push("Expected term after OR");
+        break;
+      }
+      left = { type: "OR", left, right };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    if (!left) return null;
+    while (this.check("AND") || this.isTermStart()) {
+      if (this.check("AND")) {
+        this.advance();
+      }
+      const right = this.parseNot();
+      if (!right) break;
+      left = { type: "AND", left, right };
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.check("NOT")) {
+      this.advance();
+      const operand = this.parsePrimary();
+      if (!operand) {
+        this.errors.push("Expected term after NOT");
+        return null;
+      }
+      return { type: "NOT", left: operand };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const token = this.peek();
+    if (token.type === "LPAREN") {
+      this.advance();
+      const expr = this.parseExpression();
+      if (!this.check("RPAREN")) {
+        this.errors.push("Expected closing parenthesis");
+      } else {
+        this.advance();
+      }
+      return expr;
+    }
+    if (token.type === "TERM") {
+      this.advance();
+      return { type: "TERM", value: token.value };
+    }
+    if (token.type === "PHRASE") {
+      this.advance();
+      return { type: "PHRASE", value: token.value };
+    }
+    if (token.type === "FIELD") {
+      this.advance();
+      const colonIndex = token.value.indexOf(":");
+      const field = token.value.substring(0, colonIndex).toLowerCase();
+      const value = token.value.substring(colonIndex + 1);
+      return { type: "FIELD", field, value };
+    }
+    if (token.type === "FUZZY") {
+      this.advance();
+      return { type: "FUZZY", value: token.value };
+    }
+    return null;
+  }
+  isTermStart() {
+    const type = this.peek().type;
+    return type === "TERM" || type === "PHRASE" || type === "FIELD" || type === "FUZZY" || type === "LPAREN" || type === "NOT";
+  }
+  peek() {
+    return this.tokens[this.current] || { type: "EOF", value: "", position: 0 };
+  }
+  check(type) {
+    return this.peek().type === type;
+  }
+  advance() {
+    if (!this.isAtEnd()) {
+      this.current++;
+    }
+    return this.tokens[this.current - 1];
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF";
+  }
+};
+function extractFieldFilters(ast) {
+  if (!ast) return [];
+  const filters = [];
+  function traverse(node) {
+    if (node.type === "FIELD" && node.field && node.value !== void 0) {
+      filters.push({
+        field: node.field,
+        value: node.value,
+        exact: true
+      });
+    }
+    if (node.left) traverse(node.left);
+    if (node.right) traverse(node.right);
+    if (node.children) {
+      for (const child of node.children) {
+        traverse(child);
+      }
+    }
+  }
+  traverse(ast);
+  return filters;
+}
+function extractDateFilters(fieldFilters) {
+  const dateFields = ["created", "updated"];
+  const dateFilters = [];
+  for (const filter of fieldFilters) {
+    if (!dateFields.includes(filter.field)) continue;
+    const value = filter.value;
+    if (value.includes("..")) {
+      const [start, end] = value.split("..");
+      dateFilters.push({
+        field: filter.field,
+        operator: "range",
+        value: start,
+        endValue: end
+      });
+      continue;
+    }
+    if (value.startsWith(">=")) {
+      dateFilters.push({
+        field: filter.field,
+        operator: ">=",
+        value: value.substring(2)
+      });
+    } else if (value.startsWith("<=")) {
+      dateFilters.push({
+        field: filter.field,
+        operator: "<=",
+        value: value.substring(2)
+      });
+    } else if (value.startsWith(">")) {
+      dateFilters.push({
+        field: filter.field,
+        operator: ">",
+        value: value.substring(1)
+      });
+    } else if (value.startsWith("<")) {
+      dateFilters.push({
+        field: filter.field,
+        operator: "<",
+        value: value.substring(1)
+      });
+    } else {
+      dateFilters.push({
+        field: filter.field,
+        operator: "=",
+        value
+      });
+    }
+  }
+  return dateFilters;
+}
+function extractTerms(ast) {
+  if (!ast) return [];
+  const terms = [];
+  function traverse(node) {
+    if (node.type === "TERM" && node.value) {
+      terms.push(node.value.toLowerCase());
+    }
+    if (node.type === "PHRASE" && node.value) {
+      terms.push(node.value.toLowerCase());
+    }
+    if (node.left) traverse(node.left);
+    if (node.right) traverse(node.right);
+    if (node.children) {
+      for (const child of node.children) {
+        traverse(child);
+      }
+    }
+  }
+  traverse(ast);
+  return terms;
+}
+function extractFuzzyTerms(ast) {
+  if (!ast) return [];
+  const fuzzyTerms = [];
+  function traverse(node) {
+    if (node.type === "FUZZY" && node.value) {
+      fuzzyTerms.push(node.value.toLowerCase());
+    }
+    if (node.left) traverse(node.left);
+    if (node.right) traverse(node.right);
+    if (node.children) {
+      for (const child of node.children) {
+        traverse(child);
+      }
+    }
+  }
+  traverse(ast);
+  return fuzzyTerms;
+}
+function hasAdvancedSyntax(tokens) {
+  for (const token of tokens) {
+    if (token.type === "AND" || token.type === "OR" || token.type === "NOT" || token.type === "FIELD" || token.type === "FUZZY" || token.type === "PHRASE" || token.type === "LPAREN") {
+      return true;
+    }
+  }
+  return false;
+}
+function parseQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    return {
+      ast: null,
+      terms: [],
+      fields: [],
+      dateFilters: [],
+      fuzzyTerms: [],
+      hasAdvancedSyntax: false,
+      originalQuery: query,
+      errors: []
+    };
+  }
+  const tokens = tokenize(trimmed);
+  const parser = new QueryParser(tokens);
+  const { ast, errors } = parser.parse();
+  const fields = extractFieldFilters(ast);
+  const dateFilters = extractDateFilters(fields);
+  const terms = extractTerms(ast);
+  const fuzzyTerms = extractFuzzyTerms(ast);
+  return {
+    ast,
+    terms,
+    fields,
+    dateFilters,
+    fuzzyTerms,
+    hasAdvancedSyntax: hasAdvancedSyntax(tokens),
+    originalQuery: query,
+    errors
+  };
+}
+function levenshteinDistance(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function fuzzyMatch(term, text, maxDistance) {
+  const termLower = term.toLowerCase();
+  const textLower = text.toLowerCase();
+  const autoDistance = termLower.length <= 4 ? 1 : 2;
+  const threshold = autoDistance;
+  const words = textLower.split(/\s+/);
+  for (const word of words) {
+    if (levenshteinDistance(termLower, word) <= threshold) {
+      return true;
+    }
+  }
+  return false;
+}
+function getSearchSyntaxHelp() {
+  return `
+Search Syntax:
+  term              Simple term search
+  "exact phrase"    Match exact phrase
+  term1 AND term2   Both terms must match (AND is optional)
+  term1 OR term2    Either term matches
+  NOT term          Exclude specs with term
+
+Field Filters:
+  status:in-progress    Filter by status (planned, in-progress, complete, archived)
+  tag:api               Filter by tag
+  priority:high         Filter by priority (low, medium, high, critical)
+  assignee:marvin       Filter by assignee
+  title:dashboard       Search in title only
+  name:oauth            Search in spec name
+
+Date Filters:
+  created:>2025-11-01             Created after date
+  created:<2025-11-15             Created before date
+  created:2025-11-01..2025-11-15  Created in date range
+  updated:>=2025-11-01            Updated on or after date
+
+Fuzzy Matching:
+  authetication~     Matches "authentication" (typo-tolerant)
+
+Examples:
+  api authentication                 Find specs with both terms
+  tag:api status:planned             API specs that are planned
+  "user session" OR "token refresh"  Either phrase
+  dashboard NOT deprecated           Dashboard specs, exclude deprecated
+  authetication~                     Find despite typo
+`.trim();
+}
+function specContainsAllTerms(spec, queryTerms) {
+  if (queryTerms.length === 0) {
+    return false;
+  }
+  const allText = [
+    spec.title || "",
+    spec.name || "",
+    spec.tags?.join(" ") || "",
+    spec.description || "",
+    spec.content || ""
+  ].join(" ").toLowerCase();
+  return queryTerms.every((term) => allText.includes(term));
+}
+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) {
+    if (!specContainsAllTerms(spec, queryTerms)) {
+      continue;
+    }
+    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 && containsAnyTerm(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 && containsAnyTerm(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 (containsAnyTerm(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 && containsAnyTerm(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 (containsAnyTerm(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
+  };
+}
+function specMatchesFieldFilters(spec, filters) {
+  for (const filter of filters) {
+    const field = filter.field;
+    const filterValue = filter.value.toLowerCase();
+    switch (field) {
+      case "status":
+        if (spec.status.toLowerCase() !== filterValue) return false;
+        break;
+      case "tag":
+      case "tags":
+        if (!spec.tags?.some((tag) => tag.toLowerCase() === filterValue)) return false;
+        break;
+      case "priority":
+        if (spec.priority?.toLowerCase() !== filterValue) return false;
+        break;
+      case "assignee":
+        if (spec.assignee?.toLowerCase() !== filterValue) return false;
+        break;
+      case "title":
+        if (!spec.title?.toLowerCase().includes(filterValue)) return false;
+        break;
+      case "name":
+        if (!spec.name.toLowerCase().includes(filterValue)) return false;
+        break;
+    }
+  }
+  return true;
+}
+function specMatchesDateFilters(spec, filters) {
+  for (const filter of filters) {
+    const field = filter.field;
+    const specDate = field === "created" ? spec.created : spec.updated;
+    if (!specDate) return false;
+    const specDateStr = specDate.substring(0, 10);
+    const filterDateStr = filter.value.substring(0, 10);
+    switch (filter.operator) {
+      case ">":
+        if (specDateStr <= filterDateStr) return false;
+        break;
+      case ">=":
+        if (specDateStr < filterDateStr) return false;
+        break;
+      case "<":
+        if (specDateStr >= filterDateStr) return false;
+        break;
+      case "<=":
+        if (specDateStr > filterDateStr) return false;
+        break;
+      case "=":
+        if (!specDateStr.startsWith(filterDateStr)) return false;
+        break;
+      case "range":
+        if (filter.endValue) {
+          const endDateStr = filter.endValue.substring(0, 10);
+          if (specDateStr < filterDateStr || specDateStr > endDateStr) return false;
+        }
+        break;
+    }
+  }
+  return true;
+}
+function evaluateAST(node, spec) {
+  if (!node) return true;
+  switch (node.type) {
+    case "AND":
+      return evaluateAST(node.left, spec) && evaluateAST(node.right, spec);
+    case "OR":
+      return evaluateAST(node.left, spec) || evaluateAST(node.right, spec);
+    case "NOT":
+      return !evaluateAST(node.left, spec);
+    case "TERM":
+    case "PHRASE":
+      return specContainsAllTerms(spec, [node.value.toLowerCase()]);
+    case "FUZZY":
+      return specContainsFuzzyTerm(spec, node.value);
+    case "FIELD":
+      return specMatchesFieldFilters(spec, [
+        { field: node.field, value: node.value, exact: true }
+      ]);
+    default:
+      return true;
+  }
+}
+function specContainsFuzzyTerm(spec, term) {
+  const allText = [
+    spec.title || "",
+    spec.name || "",
+    spec.tags?.join(" ") || "",
+    spec.description || "",
+    spec.content || ""
+  ].join(" ");
+  return fuzzyMatch(term, allText);
+}
+function advancedSearchSpecs(query, specs, options = {}) {
+  const startTime = Date.now();
+  const parsedQuery = parseQuery(query);
+  if (!parsedQuery.hasAdvancedSyntax && parsedQuery.errors.length === 0) {
+    return searchSpecs(query, specs, options);
+  }
+  const maxMatchesPerSpec = options.maxMatchesPerSpec || 5;
+  const contextLength = options.contextLength || 80;
+  const queryTerms = [
+    ...parsedQuery.terms,
+    ...parsedQuery.fuzzyTerms
+  ];
+  const nonDateFieldFilters = parsedQuery.fields.filter(
+    (f) => f.field !== "created" && f.field !== "updated"
+  );
+  const results = [];
+  for (const spec of specs) {
+    if (!specMatchesFieldFilters(spec, nonDateFieldFilters)) {
+      continue;
+    }
+    if (!specMatchesDateFilters(spec, parsedQuery.dateFilters)) {
+      continue;
+    }
+    if (parsedQuery.ast && !evaluateAST(parsedQuery.ast, spec)) {
+      continue;
+    }
+    const matches = queryTerms.length > 0 ? searchSpec(spec, queryTerms, contextLength) : [];
+    let processedMatches = deduplicateMatches(matches, 3);
+    processedMatches = limitMatches(processedMatches, maxMatchesPerSpec);
+    const score = matches.length > 0 ? calculateSpecScore(processedMatches) : 50;
+    results.push({
+      spec: specToSearchResult(spec),
+      score,
+      totalMatches: matches.length || 1,
+      matches: processedMatches
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return {
+    results,
+    metadata: {
+      totalResults: results.length,
+      searchTime: Date.now() - startTime,
+      query,
+      specsSearched: specs.length
+    }
+  };
+}
+
+// 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;
+  checkCrossRefs;
+  constructor(options = {}) {
+    this.excellentThreshold = options.excellentThreshold ?? 2e3;
+    this.goodThreshold = options.goodThreshold ?? 3500;
+    this.warningThreshold = options.warningThreshold ?? 5e3;
+    this.maxLines = options.maxLines ?? 500;
+    this.checkCrossRefs = options.checkCrossReferences ?? true;
+  }
+  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);
+    if (this.checkCrossRefs) {
+      this.validateCrossReferences(subSpecs, 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 = path.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`
+        });
+      }
+    }
+  }
+  /**
+   * Detect cross-document references that point to missing files
+   */
+  validateCrossReferences(subSpecs, warnings) {
+    const availableFiles = new Set(
+      subSpecs.map((subSpec) => subSpec.name.toLowerCase())
+    );
+    availableFiles.add("readme.md");
+    const linkPattern = /\[[^\]]+\]\(([^)]+)\)/gi;
+    for (const subSpec of subSpecs) {
+      if (!subSpec.content) continue;
+      for (const match of subSpec.content.matchAll(linkPattern)) {
+        const rawTarget = match[1].split("#")[0]?.trim();
+        if (!rawTarget || !rawTarget.toLowerCase().endsWith(".md")) {
+          continue;
+        }
+        const normalized = rawTarget.replace(/^\.\//, "");
+        const normalizedLower = normalized.toLowerCase();
+        if (availableFiles.has(normalizedLower)) {
+          continue;
+        }
+        warnings.push({
+          message: `Broken reference in ${subSpec.name}: ${normalized}`,
+          suggestion: `Ensure ${normalized} exists or update the link`
+        });
+      }
+    }
+  }
+};
+var DEPENDS_ON_PATTERNS = [
+  /depends on[:\s]+.*?\b(\d{3})\b/gi,
+  /blocked by[:\s]+.*?\b(\d{3})\b/gi,
+  /requires[:\s]+.*?spec[:\s]*(\d{3})\b/gi,
+  /prerequisite[:\s]+.*?\b(\d{3})\b/gi,
+  /after[:\s]+.*?spec[:\s]*(\d{3})\b/gi,
+  /builds on[:\s]+.*?\b(\d{3})\b/gi,
+  /extends[:\s]+.*?\b(\d{3})\b/gi
+];
+var DependencyAlignmentValidator = class {
+  name = "dependency-alignment";
+  description = "Detect content references to specs not linked in frontmatter";
+  strict;
+  existingSpecNumbers;
+  constructor(options = {}) {
+    this.strict = options.strict ?? false;
+    this.existingSpecNumbers = options.existingSpecNumbers ?? null;
+  }
+  /**
+   * Set the existing spec numbers to validate against
+   */
+  setExistingSpecNumbers(numbers) {
+    this.existingSpecNumbers = numbers;
+  }
+  validate(spec, content) {
+    const errors = [];
+    const warnings = [];
+    let parsed;
+    try {
+      parsed = matter3(content, {
+        engines: {
+          yaml: (str) => yaml2.load(str, { schema: yaml2.FAILSAFE_SCHEMA })
+        }
+      });
+    } catch {
+      return { passed: true, errors: [], warnings: [] };
+    }
+    const frontmatter = parsed.data;
+    const bodyContent = parsed.content;
+    const currentDependsOn = this.normalizeDeps(frontmatter.depends_on);
+    const selfNumber = this.extractSpecNumber(spec.name);
+    const detectedRefs = this.detectReferences(bodyContent, selfNumber);
+    const missingDependsOn = [];
+    for (const ref of detectedRefs) {
+      if (currentDependsOn.includes(ref.specNumber)) continue;
+      if (this.existingSpecNumbers && !this.existingSpecNumbers.has(ref.specNumber)) continue;
+      missingDependsOn.push(ref);
+    }
+    if (missingDependsOn.length > 0) {
+      const specNumbers = [...new Set(missingDependsOn.map((r) => r.specNumber))];
+      const issue = {
+        message: `Content references dependencies not in frontmatter: ${specNumbers.join(", ")}`,
+        suggestion: `Run: lean-spec link ${spec.name} --depends-on ${specNumbers.join(",")}`
+      };
+      if (this.strict) {
+        errors.push(issue);
+      } else {
+        warnings.push(issue);
+      }
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Normalize dependency field to array of spec numbers
+   */
+  normalizeDeps(deps) {
+    if (!deps) return [];
+    const depArray = Array.isArray(deps) ? deps : [deps];
+    return depArray.map((d) => {
+      const str = String(d);
+      const match = str.match(/(\d{3})/);
+      return match ? match[1] : str;
+    }).filter(Boolean);
+  }
+  /**
+   * Extract spec number from spec name (e.g., "045-unified-dashboard" -> "045")
+   */
+  extractSpecNumber(specName) {
+    const match = specName.match(/^(\d{3})/);
+    return match ? match[1] : null;
+  }
+  /**
+   * Detect spec references in content that indicate dependencies
+   */
+  detectReferences(content, selfNumber) {
+    const refs = [];
+    const seenNumbers = /* @__PURE__ */ new Set();
+    for (const pattern of DEPENDS_ON_PATTERNS) {
+      const matches = content.matchAll(new RegExp(pattern));
+      for (const match of matches) {
+        const specNumber = match[1];
+        if (specNumber && specNumber !== selfNumber && !seenNumbers.has(specNumber)) {
+          seenNumbers.add(specNumber);
+          refs.push({
+            specNumber,
+            type: "depends_on",
+            context: match[0].substring(0, 50)
+          });
+        }
+      }
+    }
+    return refs;
+  }
+};
+var STATUS_CONFIG = {
+  planned: {
+    emoji: "\u{1F4C5}",
+    label: "Planned",
+    colorFn: chalk3.blue,
+    badge: (s = "planned") => chalk3.blue(`[${s}]`)
+  },
+  "in-progress": {
+    emoji: "\u23F3",
+    label: "In Progress",
+    colorFn: chalk3.yellow,
+    badge: (s = "in-progress") => chalk3.yellow(`[${s}]`)
+  },
+  complete: {
+    emoji: "\u2705",
+    label: "Complete",
+    colorFn: chalk3.green,
+    badge: (s = "complete") => chalk3.green(`[${s}]`)
+  },
+  archived: {
+    emoji: "\u{1F4E6}",
+    label: "Archived",
+    colorFn: chalk3.gray,
+    badge: (s = "archived") => chalk3.gray(`[${s}]`)
+  }
+};
+var PRIORITY_CONFIG = {
+  critical: {
+    emoji: "\u{1F534}",
+    colorFn: chalk3.red.bold,
+    badge: (s = "critical") => chalk3.red.bold(`[${s}]`)
+  },
+  high: {
+    emoji: "\u{1F7E0}",
+    colorFn: chalk3.hex("#FFA500"),
+    badge: (s = "high") => chalk3.hex("#FFA500")(`[${s}]`)
+  },
+  medium: {
+    emoji: "\u{1F7E1}",
+    colorFn: chalk3.yellow,
+    badge: (s = "medium") => chalk3.yellow(`[${s}]`)
+  },
+  low: {
+    emoji: "\u{1F7E2}",
+    colorFn: chalk3.gray,
+    badge: (s = "low") => chalk3.gray(`[${s}]`)
+  }
+};
+function formatStatusBadge(status) {
+  return STATUS_CONFIG[status]?.badge() || chalk3.white(`[${status}]`);
+}
+function formatPriorityBadge(priority) {
+  return PRIORITY_CONFIG[priority]?.badge() || chalk3.white(`[${priority}]`);
+}
+function getStatusIndicator(status) {
+  const config = STATUS_CONFIG[status];
+  if (!config) return chalk3.gray("[unknown]");
+  return config.colorFn(`[${status}]`);
+}
+function getStatusEmoji(status) {
+  return STATUS_CONFIG[status]?.emoji || "\u{1F4C4}";
+}
+function getPriorityEmoji(priority) {
+  return priority ? PRIORITY_CONFIG[priority]?.emoji || "" : "";
+}
+
+// src/utils/validate-formatter.ts
+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(chalk3.bold.cyan(`${specName} ${statusBadge} ${priorityBadge}`));
+  } else {
+    lines.push(chalk3.cyan.underline(relativePath));
+  }
+  for (const issue of fileResult.issues) {
+    const severityColor = issue.severity === "error" ? chalk3.red : chalk3.yellow;
+    const severityText = severityColor(issue.severity.padEnd(9));
+    const ruleText = chalk3.gray(issue.ruleName);
+    lines.push(`  ${severityText}${issue.message.padEnd(60)} ${ruleText}`);
+    if (issue.suggestion) {
+      lines.push(chalk3.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 chalk3.red.bold(
+      `\u2716 ${errorCount} ${errorText}, ${warningCount} ${warningText} (${totalSpecs} specs checked, ${cleanCount} clean)`
+    );
+  } else if (warningCount > 0) {
+    const warningText = warningCount === 1 ? "warning" : "warnings";
+    return chalk3.yellow.bold(
+      `\u26A0 ${warningCount} ${warningText} (${totalSpecs} specs checked, ${cleanCount} clean)`
+    );
+  } else {
+    return chalk3.green.bold(`\u2713 All ${totalSpecs} specs passed`);
+  }
+}
+function formatPassingSpecs(specs, specsDir) {
+  const lines = [];
+  lines.push(chalk3.green.bold(`
+\u2713 ${specs.length} specs passed:`));
+  for (const spec of specs) {
+    const relativePath = normalizeFilePath(spec.filePath);
+    lines.push(chalk3.gray(`  ${relativePath}`));
+  }
+  return lines.join("\n");
+}
+function formatJson(fileResults, totalSpecs, errorCount, warningCount) {
+  const output = {
+    summary: {
+      totalSpecs,
+      errorCount,
+      warningCount,
+      cleanCount: totalSpecs - fileResults.length
+    },
+    files: fileResults.map((fr) => ({
+      filePath: fr.filePath,
+      issues: fr.issues.map((issue) => ({
+        severity: issue.severity,
+        message: issue.message,
+        suggestion: issue.suggestion,
+        rule: issue.ruleName
+      }))
+    }))
+  };
+  return JSON.stringify(output, null, 2);
+}
+function formatValidationResults(results, specs, specsDir, options = {}) {
+  const fileResults = groupIssuesByFile(results);
+  const filteredResults = options.rule ? fileResults.map((fr) => ({
+    ...fr,
+    issues: fr.issues.filter((issue) => issue.ruleName === options.rule)
+  })).filter((fr) => fr.issues.length > 0) : fileResults;
+  const displayResults = options.quiet ? filteredResults.map((fr) => ({
+    ...fr,
+    issues: fr.issues.filter((issue) => issue.severity === "error")
+  })).filter((fr) => fr.issues.length > 0) : filteredResults;
+  if (options.format === "json") {
+    const errorCount2 = displayResults.reduce(
+      (sum, fr) => sum + fr.issues.filter((i) => i.severity === "error").length,
+      0
+    );
+    const warningCount2 = displayResults.reduce(
+      (sum, fr) => sum + fr.issues.filter((i) => i.severity === "warning").length,
+      0
+    );
+    return formatJson(displayResults, specs.length, errorCount2, warningCount2);
+  }
+  const lines = [];
+  lines.push(chalk3.bold(`
+Validating ${specs.length} specs...
+`));
+  let previousSpecName;
+  for (const fileResult of displayResults) {
+    if (fileResult.spec && previousSpecName && fileResult.spec.name !== previousSpecName) {
+      lines.push(chalk3.gray("\u2500".repeat(80)));
+      lines.push("");
+    }
+    lines.push(formatFileIssues(fileResult));
+    if (fileResult.spec) {
+      previousSpecName = fileResult.spec.name;
+    }
+  }
+  const errorCount = displayResults.reduce(
+    (sum, fr) => sum + fr.issues.filter((i) => i.severity === "error").length,
+    0
+  );
+  const warningCount = displayResults.reduce(
+    (sum, fr) => sum + fr.issues.filter((i) => i.severity === "warning").length,
+    0
+  );
+  const cleanCount = specs.length - fileResults.length;
+  lines.push(formatSummary(specs.length, errorCount, warningCount, cleanCount));
+  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));
+  }
+  if (!options.verbose && cleanCount > 0 && displayResults.length > 0) {
+    lines.push(chalk3.gray("\nRun with --verbose to see passing specs."));
+  }
+  return lines.join("\n");
+}
+
+// src/commands/validate.ts
+function validateCommand() {
+  return new Command("validate").description("Validate specs for quality issues").argument("[specs...]", "Specific specs to validate (optional)").option("--max-lines <number>", "Custom line limit (default: 400)", parseInt).option("--verbose", "Show passing specs").option("--quiet", "Suppress warnings, only show errors").option("--format <format>", "Output format: default, json, compact", "default").option("--json", "Output as JSON (shorthand for --format json)").option("--rule <rule>", "Filter by specific rule name (e.g., max-lines, frontmatter)").option("--warnings-only", "Treat all issues as warnings, never fail (useful for CI pre-release checks)").option("--check-deps", "Check for content/frontmatter dependency alignment").action(async (specs, options) => {
+    const passed = await validateSpecs({
+      maxLines: options.maxLines,
+      specs: specs && specs.length > 0 ? specs : void 0,
+      verbose: options.verbose,
+      quiet: options.quiet,
+      format: options.json ? "json" : options.format,
+      rule: options.rule,
+      warningsOnly: options.warningsOnly,
+      checkDeps: options.checkDeps
+    });
+    process.exit(passed ? 0 : 1);
+  });
+}
+async function validateSpecs(options = {}) {
+  const config = await loadConfig();
+  let specs;
+  if (options.specs && options.specs.length > 0) {
+    const allSpecs = await loadAllSpecs();
+    specs = [];
+    for (const specPath of options.specs) {
+      const spec = allSpecs.find(
+        (s) => s.path.includes(specPath) || path.basename(s.path).includes(specPath)
+      );
+      if (spec) {
+        specs.push(spec);
+      } else {
+        console.error(chalk3.red(`Error: Spec not found: ${specPath}`));
+        return false;
+      }
+    }
+  } else {
+    specs = await withSpinner(
+      "Loading specs...",
+      () => loadAllSpecs({ includeArchived: false })
+    );
+  }
+  if (specs.length === 0) {
+    console.log("No specs found to validate.");
+    return true;
+  }
+  const validators = [
+    new ComplexityValidator({ maxLines: options.maxLines }),
+    // Token-based complexity (primary), line count (backstop)
+    new FrontmatterValidator(),
+    new StructureValidator(),
+    new CorruptionValidator(),
+    new SubSpecValidator({ maxLines: options.maxLines })
+  ];
+  if (options.checkDeps) {
+    const activeSpecs = await loadAllSpecs({ includeArchived: false });
+    const existingSpecNumbers = /* @__PURE__ */ new Set();
+    for (const s of activeSpecs) {
+      const match = s.name.match(/^(\d{3})/);
+      if (match) {
+        existingSpecNumbers.add(match[1]);
+      }
+    }
+    validators.push(new DependencyAlignmentValidator({ existingSpecNumbers }));
+  }
+  const results = [];
+  for (const spec of specs) {
+    let content;
+    try {
+      content = await fs.readFile(spec.filePath, "utf-8");
+    } catch (error) {
+      console.error(chalk3.red(`Error reading ${spec.filePath}:`), error);
+      continue;
+    }
+    for (const validator of validators) {
+      try {
+        const result = await validator.validate(spec, content);
+        results.push({
+          spec,
+          validatorName: validator.name,
+          result,
+          content
+        });
+      } catch (error) {
+        console.error(chalk3.yellow(`Warning: Validator ${validator.name} failed:`), error instanceof Error ? error.message : error);
+      }
+    }
+  }
+  const formatOptions = {
+    verbose: options.verbose,
+    quiet: options.quiet,
+    format: options.format,
+    rule: options.rule
+  };
+  const output = formatValidationResults(results, specs, config.specsDir, formatOptions);
+  console.log(output);
+  if (options.warningsOnly) {
+    return true;
+  }
+  const hasErrors = results.some((r) => !r.result.passed);
+  return !hasErrors;
+}
+
+export { PRIORITY_CONFIG, STATUS_CONFIG, SpecDependencyGraph, TokenCounter, advancedSearchSpecs, analyzeMarkdownStructure, countLines, countTokens, createUpdatedFrontmatter, extractLines, getPriorityEmoji, getSearchSyntaxHelp, getStatusEmoji, getStatusIndicator, parseFrontmatterFromString, removeLines, sanitizeUserInput, validateCommand, validateSpecs, withSpinner };
+//# sourceMappingURL=chunk-CJMVV46H.js.map
+//# sourceMappingURL=chunk-CJMVV46H.js.map