workflow-agent-cli 2.8.1 → 2.9.1

package/dist/cli/index.js

@@ -10,10 +10,12 @@ import {
   stageAllChanges
 } from "../chunk-6NWQLGHI.js";
 import {
+  applyReferenceFix,
   validateBranchName,
   validateCommitMessage,
+  validateDocumentReferences,
   validatePRTitle
-} from "../chunk-NMHWD2GA.js";
+} from "../chunk-ZLDJ2OGO.js";
 import {
   hasConfig,
   loadConfig,
@@ -29,7 +31,7 @@ import {
   installMandatoryTemplates,
   templateMetadata,
   updateTemplates
-} from "../chunk-2WUPMAH3.js";
+} from "../chunk-YEOQZ7XC.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -316,10 +318,10 @@ async function initCommand(options) {
     try {
       const presetModule = await import(`@workflow/scopes-${preset}`);
       scopes = presetModule.scopes || presetModule.default.scopes;
-      const spinner9 = p.spinner();
-      spinner9.start(`Loading ${presetModule.default?.name || preset} preset`);
+      const spinner10 = p.spinner();
+      spinner10.start(`Loading ${presetModule.default?.name || preset} preset`);
       await new Promise((resolve2) => setTimeout(resolve2, 500));
-      spinner9.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
+      spinner10.stop(`\u2713 Loaded ${scopes.length} scopes from preset`);
     } catch (error) {
       console.log(
         chalk.yellow(
@@ -357,17 +359,17 @@ async function initCommand(options) {
   if (!existsSync(workflowDir)) {
     await mkdir(workflowDir, { recursive: true });
   }
-  const shouldGenerateGuidelines = await p.confirm({
+  const shouldGenerateGuidelines = options.yes || isNonInteractive ? true : await p.confirm({
     message: "Generate workflow guidelines from templates?",
     initialValue: true
   });
-  if (p.isCancel(shouldGenerateGuidelines)) {
+  if (!isNonInteractive && p.isCancel(shouldGenerateGuidelines)) {
     p.cancel("Initialization cancelled");
     process.exit(0);
   }
   if (shouldGenerateGuidelines) {
-    const spinner9 = p.spinner();
-    spinner9.start("Generating guidelines...");
+    const spinner10 = p.spinner();
+    spinner10.start("Generating guidelines...");
     try {
       const templatesDir = join(__dirname, "../../templates");
       await validateTemplateDirectory(templatesDir);
@@ -379,7 +381,7 @@ async function initCommand(options) {
         guidelinesDir,
         context
       );
-      spinner9.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
+      spinner10.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
       const instructionsSpinner = p.spinner();
       instructionsSpinner.start("Generating AI agent instructions...");
       const result = generateCopilotInstructions(cwd, { silent: true });
@@ -389,7 +391,7 @@ async function initCommand(options) {
         instructionsSpinner.stop("\u26A0\uFE0F  Could not generate copilot instructions");
       }
     } catch (error) {
-      spinner9.stop("\u26A0\uFE0F  Could not generate guidelines");
+      spinner10.stop("\u26A0\uFE0F  Could not generate guidelines");
       console.log(
         chalk.yellow(
           `
@@ -401,11 +403,11 @@ Reason: ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
-  const shouldAutoSetup = options.yes ? true : await p.confirm({
+  const shouldAutoSetup = options.yes || isNonInteractive ? true : await p.confirm({
     message: "Set up linting, formatting, testing, and CI automatically?",
     initialValue: true
   });
-  if (p.isCancel(shouldAutoSetup)) {
+  if (!isNonInteractive && p.isCancel(shouldAutoSetup)) {
     p.cancel("Initialization cancelled");
     process.exit(0);
   }
@@ -588,7 +590,204 @@ async function suggestCommand(feedback, options = {}) {
 
 // src/cli/commands/doctor.ts
 import chalk5 from "chalk";
-async function doctorCommand() {
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/utils/hooks.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile, writeFile as writeFile2, unlink, chmod, rename, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+function getGitHooksDir(projectPath = process.cwd()) {
+  return join2(projectPath, ".git", "hooks");
+}
+function hasGitRepo(projectPath = process.cwd()) {
+  return existsSync2(join2(projectPath, ".git"));
+}
+function generatePreCommitHook(config) {
+  const checks = config?.preCommit || ["validate-branch", "check-guidelines"];
+  const checkCommands = checks.map((check) => {
+    switch (check) {
+      case "validate-branch":
+        return "  workflow validate branch";
+      case "validate-commit":
+        return "  workflow validate commit";
+      case "check-guidelines":
+        return "  workflow doctor --check-guidelines-only 2>/dev/null || true";
+      case "validate-scopes":
+        return "  workflow config validate";
+      default:
+        return "";
+    }
+  }).filter(Boolean).join("\n");
+  return `#!/bin/sh
+# Workflow Agent pre-commit hook
+# Auto-generated - do not edit manually
+# To reinstall: workflow hooks install
+# To uninstall: workflow hooks uninstall
+
+# Skip in CI environment
+if [ -n "\${CI:-}" ] || [ -n "\${GITHUB_ACTIONS:-}" ] || [ -n "\${GITLAB_CI:-}" ]; then
+  exit 0
+fi
+
+# Run workflow checks
+${checkCommands}
+
+# Run original hook if it exists
+if [ -f ".git/hooks/pre-commit.original" ]; then
+  .git/hooks/pre-commit.original "$@"
+fi
+`;
+}
+function generateCommitMsgHook(config) {
+  const checks = config?.commitMsg || ["validate-commit"];
+  const checkCommands = checks.map((check) => {
+    switch (check) {
+      case "validate-commit":
+        return '  workflow validate commit "$(cat "$1")"';
+      default:
+        return "";
+    }
+  }).filter(Boolean).join("\n");
+  return `#!/bin/sh
+# Workflow Agent commit-msg hook
+# Auto-generated - do not edit manually
+# To reinstall: workflow hooks install
+# To uninstall: workflow hooks uninstall
+
+# Skip in CI environment
+if [ -n "\${CI:-}" ] || [ -n "\${GITHUB_ACTIONS:-}" ] || [ -n "\${GITLAB_CI:-}" ]; then
+  exit 0
+fi
+
+# Run workflow checks
+${checkCommands}
+
+# Run original hook if it exists
+if [ -f ".git/hooks/commit-msg.original" ]; then
+  .git/hooks/commit-msg.original "$@"
+fi
+`;
+}
+async function isWorkflowHook(hookPath) {
+  try {
+    const content = await readFile(hookPath, "utf-8");
+    return content.includes("Workflow Agent") && content.includes("Auto-generated");
+  } catch {
+    return false;
+  }
+}
+async function getHookStatus(hookType, projectPath = process.cwd()) {
+  const hooksDir = getGitHooksDir(projectPath);
+  const hookPath = join2(hooksDir, hookType);
+  const originalPath = join2(hooksDir, `${hookType}.original`);
+  const status = {
+    installed: false,
+    hookType,
+    hasExistingHook: false,
+    wrappedOriginal: false
+  };
+  if (!existsSync2(hookPath)) {
+    return status;
+  }
+  status.hasExistingHook = true;
+  if (await isWorkflowHook(hookPath)) {
+    status.installed = true;
+    status.wrappedOriginal = existsSync2(originalPath);
+  }
+  return status;
+}
+async function getAllHooksStatus(projectPath = process.cwd()) {
+  return Promise.all([
+    getHookStatus("pre-commit", projectPath),
+    getHookStatus("commit-msg", projectPath)
+  ]);
+}
+async function installSingleHook(hookType, config, projectPath = process.cwd()) {
+  const hooksDir = getGitHooksDir(projectPath);
+  const hookPath = join2(hooksDir, hookType);
+  const originalPath = join2(hooksDir, `${hookType}.original`);
+  const result = {
+    success: false,
+    hookType,
+    wrappedExisting: false
+  };
+  try {
+    if (!existsSync2(hooksDir)) {
+      await mkdir2(hooksDir, { recursive: true });
+    }
+    if (existsSync2(hookPath)) {
+      const isOurs = await isWorkflowHook(hookPath);
+      if (!isOurs) {
+        await rename(hookPath, originalPath);
+        result.wrappedExisting = true;
+      }
+    }
+    const hookContent = hookType === "pre-commit" ? generatePreCommitHook(config) : generateCommitMsgHook(config);
+    await writeFile2(hookPath, hookContent, "utf-8");
+    await chmod(hookPath, 493);
+    result.success = true;
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error);
+  }
+  return result;
+}
+async function installHooks(config, projectPath = process.cwd()) {
+  if (!hasGitRepo(projectPath)) {
+    return [
+      {
+        success: false,
+        hookType: "pre-commit",
+        wrappedExisting: false,
+        error: "No git repository found. Run git init first."
+      }
+    ];
+  }
+  const results = await Promise.all([
+    installSingleHook("pre-commit", config, projectPath),
+    installSingleHook("commit-msg", config, projectPath)
+  ]);
+  return results;
+}
+async function uninstallSingleHook(hookType, projectPath = process.cwd()) {
+  const hooksDir = getGitHooksDir(projectPath);
+  const hookPath = join2(hooksDir, hookType);
+  const originalPath = join2(hooksDir, `${hookType}.original`);
+  const result = {
+    success: false,
+    hookType,
+    wrappedExisting: false
+  };
+  try {
+    if (!existsSync2(hookPath)) {
+      result.success = true;
+      return result;
+    }
+    const isOurs = await isWorkflowHook(hookPath);
+    if (!isOurs) {
+      result.error = "Hook is not managed by Workflow Agent";
+      return result;
+    }
+    await unlink(hookPath);
+    if (existsSync2(originalPath)) {
+      await rename(originalPath, hookPath);
+      result.wrappedExisting = true;
+    }
+    result.success = true;
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error);
+  }
+  return result;
+}
+async function uninstallHooks(projectPath = process.cwd()) {
+  return Promise.all([
+    uninstallSingleHook("pre-commit", projectPath),
+    uninstallSingleHook("commit-msg", projectPath)
+  ]);
+}
+
+// src/cli/commands/doctor.ts
+async function doctorCommand(options) {
   console.log(chalk5.bold.cyan("\n\u{1F3E5} Workflow Agent Health Check\n"));
   const config = await loadConfig();
   if (!config) {
@@ -601,25 +800,72 @@ async function doctorCommand() {
   console.log(chalk5.dim(`  Scopes: ${config.scopes.length} configured`));
   console.log(chalk5.dim(`  Enforcement: ${config.enforcement}`));
   console.log(chalk5.dim(`  Language: ${config.language}`));
-  console.log(chalk5.cyan("\n\u{1F4A1} Suggestions:\n"));
-  console.log(chalk5.dim("  \u2022 Health check analysis coming soon"));
-  console.log(chalk5.dim("  \u2022 Git history analysis coming soon"));
-  console.log(chalk5.dim("  \u2022 Optimization recommendations coming soon"));
+  const cwd = process.cwd();
+  const guidelinesDir = join3(cwd, "guidelines");
+  const mandatoryFiles = getMandatoryTemplateFilenames();
+  const missingFiles = [];
+  console.log(chalk5.cyan("\n\u{1F4DA} Guidelines Check:\n"));
+  for (const filename of mandatoryFiles) {
+    const filePath = join3(guidelinesDir, filename);
+    if (existsSync3(filePath)) {
+      console.log(chalk5.green(`\u2713 ${filename}`));
+    } else {
+      console.log(chalk5.red(`\u2717 ${filename} (missing)`));
+      missingFiles.push(filename);
+    }
+  }
+  if (missingFiles.length === 0) {
+    console.log(
+      chalk5.green(`
+\u2713 All ${mandatoryFiles.length} mandatory guidelines present`)
+    );
+  } else {
+    console.log(
+      chalk5.red(
+        `
+\u2717 Missing ${missingFiles.length} mandatory guideline(s)`
+      )
+    );
+  }
+  if (options?.checkGuidelinesOnly) {
+    process.exit(missingFiles.length > 0 ? 1 : 0);
+  }
+  console.log(chalk5.cyan("\n\u{1F517} Git Hooks Check:\n"));
+  if (!hasGitRepo(cwd)) {
+    console.log(chalk5.yellow("\u26A0 No git repository found"));
+    console.log(chalk5.dim("  Run: git init"));
+  } else {
+    const hooksStatus = getAllHooksStatus(cwd);
+    for (const status of hooksStatus) {
+      if (status.installed) {
+        console.log(chalk5.green(`\u2713 ${status.hookType}: installed`));
+      } else {
+        console.log(chalk5.yellow(`\u26A0 ${status.hookType}: not installed`));
+      }
+    }
+    const allInstalled = hooksStatus.every((s) => s.installed);
+    if (!allInstalled) {
+      console.log(chalk5.dim("\n  Run: workflow hooks install"));
+    }
+  }
+  if (missingFiles.length > 0) {
+    process.exit(1);
+  }
 }
 
 // src/cli/commands/setup.ts
 import * as p3 from "@clack/prompts";
 import chalk6 from "chalk";
-import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import { readFileSync, writeFileSync, existsSync as existsSync4 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 async function setupCommand() {
   p3.intro(chalk6.bgBlue(" workflow-agent setup "));
   const cwd = process.cwd();
-  const packageJsonPath = join2(cwd, "package.json");
-  if (!existsSync2(packageJsonPath)) {
+  const packageJsonPath = join4(cwd, "package.json");
+  if (!existsSync4(packageJsonPath)) {
     p3.cancel("No package.json found in current directory");
     process.exit(1);
   }
@@ -684,8 +930,8 @@ async function setupCommand() {
   console.log(chalk6.dim("\nRun them with:"));
   console.log(chalk6.dim("  pnpm run workflow:init"));
   console.log(chalk6.dim("  npm run workflow:init\n"));
-  const guidelinesDir = join2(cwd, "guidelines");
-  if (!existsSync2(guidelinesDir)) {
+  const guidelinesDir = join4(cwd, "guidelines");
+  if (!existsSync4(guidelinesDir)) {
     const templatesDir = findTemplatesDirectory(__dirname2);
     if (templatesDir) {
       const templateResult = installMandatoryTemplates(cwd, templatesDir, {
@@ -703,7 +949,7 @@ async function setupCommand() {
       }
     }
   }
-  if (existsSync2(guidelinesDir)) {
+  if (existsSync4(guidelinesDir)) {
     const result = generateCopilotInstructions(cwd, { silent: false });
     if (result.success) {
       const status = result.isNew ? "Generated" : "Updated";
@@ -722,14 +968,14 @@ async function setupCommand() {
 // src/cli/commands/scope-create.ts
 import * as p4 from "@clack/prompts";
 import chalk7 from "chalk";
-import { existsSync as existsSync3 } from "fs";
-import { writeFile as writeFile2, mkdir as mkdir2, readFile } from "fs/promises";
-import { join as join3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { writeFile as writeFile3, mkdir as mkdir3, readFile as readFile2 } from "fs/promises";
+import { join as join5 } from "path";
 async function scopeCreateCommand(options) {
   console.log(chalk7.bold.cyan("\n\u{1F3A8} Create Custom Scope Package\n"));
   const cwd = process.cwd();
   const isNonInteractive = !!(options.name && options.scopes && options.presetName);
-  const isMonorepo2 = existsSync3(join3(cwd, "pnpm-workspace.yaml"));
+  const isMonorepo2 = existsSync5(join5(cwd, "pnpm-workspace.yaml"));
   if (isMonorepo2) {
     console.log(chalk7.dim("\u2713 Detected monorepo workspace\n"));
   }
@@ -875,7 +1121,7 @@ async function scopeCreateCommand(options) {
   if (options.outputDir) {
     outputDir = options.outputDir;
   } else if (isMonorepo2) {
-    outputDir = join3(cwd, "packages", `scopes-${packageName}`);
+    outputDir = join5(cwd, "packages", `scopes-${packageName}`);
   } else {
     const customDir = await p4.text({
       message: "Output directory:",
@@ -886,9 +1132,9 @@ async function scopeCreateCommand(options) {
       p4.cancel("Operation cancelled");
       process.exit(0);
     }
-    outputDir = join3(cwd, customDir);
+    outputDir = join5(cwd, customDir);
   }
-  if (existsSync3(outputDir)) {
+  if (existsSync5(outputDir)) {
     const shouldOverwrite = await p4.confirm({
       message: `Directory ${outputDir} already exists. Overwrite?`,
       initialValue: false
@@ -898,10 +1144,10 @@ async function scopeCreateCommand(options) {
       process.exit(0);
     }
   }
-  const spinner9 = p4.spinner();
-  spinner9.start("Creating package structure...");
+  const spinner10 = p4.spinner();
+  spinner10.start("Creating package structure...");
   try {
-    await mkdir2(join3(outputDir, "src"), { recursive: true });
+    await mkdir3(join5(outputDir, "src"), { recursive: true });
     const packageJson = {
       name: `@workflow/scopes-${packageName}`,
       version: "1.0.0",
@@ -941,8 +1187,8 @@ async function scopeCreateCommand(options) {
         access: "public"
       }
     };
-    await writeFile2(
-      join3(outputDir, "package.json"),
+    await writeFile3(
+      join5(outputDir, "package.json"),
       JSON.stringify(packageJson, null, 2),
       "utf-8"
     );
@@ -954,8 +1200,8 @@ async function scopeCreateCommand(options) {
       },
       include: ["src/**/*"]
     };
-    await writeFile2(
-      join3(outputDir, "tsconfig.json"),
+    await writeFile3(
+      join5(outputDir, "tsconfig.json"),
       JSON.stringify(tsconfig, null, 2),
       "utf-8"
     );
@@ -969,7 +1215,7 @@ export default defineConfig({
   sourcemap: true,
 });
 `;
-    await writeFile2(join3(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
+    await writeFile3(join5(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
     const indexTs = `import type { Scope } from '@hawkinside_out/workflow-agent/config';
 
 export const scopes: Scope[] = ${JSON.stringify(scopes, null, 2)};
@@ -983,7 +1229,7 @@ export const preset = {
 
 export default preset;
 `;
-    await writeFile2(join3(outputDir, "src", "index.ts"), indexTs, "utf-8");
+    await writeFile3(join5(outputDir, "src", "index.ts"), indexTs, "utf-8");
     if (!options.noTest) {
       const testFile = `import { describe, it, expect } from 'vitest';
 import { scopes, preset } from './index.js';
@@ -1024,16 +1270,16 @@ describe('${presetName} Scope Preset', () => {
   });
 });
 `;
-      await writeFile2(
-        join3(outputDir, "src", "index.test.ts"),
+      await writeFile3(
+        join5(outputDir, "src", "index.test.ts"),
         testFile,
         "utf-8"
       );
     }
-    spinner9.stop("\u2713 Package structure created");
+    spinner10.stop("\u2713 Package structure created");
     if (isMonorepo2) {
-      const workspaceFile = join3(cwd, "pnpm-workspace.yaml");
-      const workspaceContent = await readFile(workspaceFile, "utf-8");
+      const workspaceFile = join5(cwd, "pnpm-workspace.yaml");
+      const workspaceContent = await readFile2(workspaceFile, "utf-8");
       const packagePath = `packages/scopes-${packageName}`;
       if (!workspaceContent.includes(packagePath) && !workspaceContent.includes("packages/*")) {
         console.log(
@@ -1082,7 +1328,7 @@ describe('${presetName} Scope Preset', () => {
       );
     }
   } catch (error) {
-    spinner9.stop("\u2717 Failed to create package");
+    spinner10.stop("\u2717 Failed to create package");
     console.error(chalk7.red("\nError:"), error);
     process.exit(1);
   }
@@ -1091,9 +1337,9 @@ describe('${presetName} Scope Preset', () => {
 // src/cli/commands/scope-migrate.ts
 import * as p5 from "@clack/prompts";
 import chalk8 from "chalk";
-import { existsSync as existsSync4 } from "fs";
-import { writeFile as writeFile3, mkdir as mkdir3, readFile as readFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile3 } from "fs/promises";
+import { join as join6 } from "path";
 async function scopeMigrateCommand(options) {
   console.log(chalk8.bold.cyan("\n\u{1F504} Migrate Scopes to Custom Package\n"));
   const cwd = process.cwd();
@@ -1137,7 +1383,7 @@ async function scopeMigrateCommand(options) {
     p5.cancel("Migration cancelled");
     process.exit(0);
   }
-  const isMonorepo2 = existsSync4(join4(cwd, "pnpm-workspace.yaml"));
+  const isMonorepo2 = existsSync6(join6(cwd, "pnpm-workspace.yaml"));
   if (isMonorepo2) {
     console.log(chalk8.dim("\n\u2713 Detected monorepo workspace\n"));
   }
@@ -1187,7 +1433,7 @@ async function scopeMigrateCommand(options) {
   if (options.outputDir) {
     outputDir = options.outputDir;
   } else if (isMonorepo2) {
-    outputDir = join4(cwd, "packages", `scopes-${packageName}`);
+    outputDir = join6(cwd, "packages", `scopes-${packageName}`);
   } else {
     const customDir = await p5.text({
       message: "Output directory:",
@@ -1198,9 +1444,9 @@ async function scopeMigrateCommand(options) {
       p5.cancel("Migration cancelled");
       process.exit(0);
     }
-    outputDir = join4(cwd, customDir);
+    outputDir = join6(cwd, customDir);
   }
-  if (existsSync4(outputDir)) {
+  if (existsSync6(outputDir)) {
     const shouldOverwrite = await p5.confirm({
       message: `Directory ${outputDir} already exists. Overwrite?`,
       initialValue: false
@@ -1210,10 +1456,10 @@ async function scopeMigrateCommand(options) {
       process.exit(0);
     }
   }
-  const spinner9 = p5.spinner();
-  spinner9.start("Migrating scopes to package...");
+  const spinner10 = p5.spinner();
+  spinner10.start("Migrating scopes to package...");
   try {
-    await mkdir3(join4(outputDir, "src"), { recursive: true });
+    await mkdir4(join6(outputDir, "src"), { recursive: true });
     const packageJson = {
       name: `@workflow/scopes-${packageName}`,
       version: "1.0.0",
@@ -1253,8 +1499,8 @@ async function scopeMigrateCommand(options) {
         access: "public"
       }
     };
-    await writeFile3(
-      join4(outputDir, "package.json"),
+    await writeFile4(
+      join6(outputDir, "package.json"),
       JSON.stringify(packageJson, null, 2),
       "utf-8"
     );
@@ -1266,8 +1512,8 @@ async function scopeMigrateCommand(options) {
       },
       include: ["src/**/*"]
     };
-    await writeFile3(
-      join4(outputDir, "tsconfig.json"),
+    await writeFile4(
+      join6(outputDir, "tsconfig.json"),
       JSON.stringify(tsconfig, null, 2),
       "utf-8"
     );
@@ -1281,7 +1527,7 @@ export default defineConfig({
   sourcemap: true,
 });
 `;
-    await writeFile3(join4(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
+    await writeFile4(join6(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
     const indexTs = `import type { Scope } from '@hawkinside_out/workflow-agent/config';
 
 export const scopes: Scope[] = ${JSON.stringify(config.scopes, null, 2)};
@@ -1295,7 +1541,7 @@ export const preset = {
 
 export default preset;
 `;
-    await writeFile3(join4(outputDir, "src", "index.ts"), indexTs, "utf-8");
+    await writeFile4(join6(outputDir, "src", "index.ts"), indexTs, "utf-8");
     const testFile = `import { describe, it, expect } from 'vitest';
 import { scopes, preset } from './index.js';
 import { ScopeSchema } from '@hawkinside_out/workflow-agent/config';
@@ -1338,11 +1584,11 @@ describe('${presetName} Scope Preset (Migrated)', () => {
   });
 });
 `;
-    await writeFile3(join4(outputDir, "src", "index.test.ts"), testFile, "utf-8");
-    spinner9.stop("\u2713 Package created from migrated scopes");
+    await writeFile4(join6(outputDir, "src", "index.test.ts"), testFile, "utf-8");
+    spinner10.stop("\u2713 Package created from migrated scopes");
     if (isMonorepo2) {
-      const workspaceFile = join4(cwd, "pnpm-workspace.yaml");
-      const workspaceContent = await readFile2(workspaceFile, "utf-8");
+      const workspaceFile = join6(cwd, "pnpm-workspace.yaml");
+      const workspaceContent = await readFile3(workspaceFile, "utf-8");
       const packagePath = `packages/scopes-${packageName}`;
       if (!workspaceContent.includes(packagePath) && !workspaceContent.includes("packages/*")) {
         console.log(
@@ -1358,7 +1604,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
       initialValue: false
     });
     if (!p5.isCancel(keepConfig) && !keepConfig) {
-      const configPath = join4(cwd, "workflow.config.json");
+      const configPath = join6(cwd, "workflow.config.json");
       const updatedConfig = {
         ...config,
         scopes: [],
@@ -1366,7 +1612,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
         preset: `scopes-${packageName}`
         // Reference the new package
       };
-      await writeFile3(
+      await writeFile4(
         configPath,
         JSON.stringify(updatedConfig, null, 2),
         "utf-8"
@@ -1411,7 +1657,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
       )
     );
   } catch (error) {
-    spinner9.stop("\u2717 Migration failed");
+    spinner10.stop("\u2717 Migration failed");
     console.error(chalk8.red("\nError:"), error);
     process.exit(1);
   }
@@ -1651,14 +1897,14 @@ import chalk10 from "chalk";
 async function autoSetupCommand(options) {
   console.log(chalk10.bold.cyan("\n\u{1F527} Workflow Agent Auto-Setup\n"));
   const cwd = process.cwd();
-  const spinner9 = p6.spinner();
-  spinner9.start("Analyzing project...");
+  const spinner10 = p6.spinner();
+  spinner10.start("Analyzing project...");
   let report;
   try {
     report = await generateAuditReport(cwd);
-    spinner9.stop("\u2713 Project analysis complete");
+    spinner10.stop("\u2713 Project analysis complete");
   } catch (error) {
-    spinner9.stop("\u2717 Failed to analyze project");
+    spinner10.stop("\u2717 Failed to analyze project");
     console.error(
       chalk10.red(
         `Error: ${error instanceof Error ? error.message : String(error)}`
@@ -1794,14 +2040,14 @@ function formatAuditReportColored(report) {
 // src/cli/commands/advisory.ts
 import * as p7 from "@clack/prompts";
 import chalk11 from "chalk";
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
-import { join as join6 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { join as join8 } from "path";
 
 // src/utils/advisory-analyzer.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join7 } from "path";
 import fg from "fast-glob";
 var AdvisoryAnalyzer = class {
   options;
@@ -2245,11 +2491,11 @@ var AdvisoryAnalyzer = class {
   // Helper Methods
   // ============================================================================
   async readPackageJson() {
-    const pkgPath = join5(this.options.cwd, "package.json");
-    if (!existsSync5(pkgPath)) {
+    const pkgPath = join7(this.options.cwd, "package.json");
+    if (!existsSync7(pkgPath)) {
       throw new Error("package.json not found");
     }
-    const content = await readFile3(pkgPath, "utf-8");
+    const content = await readFile4(pkgPath, "utf-8");
     return JSON.parse(content);
   }
   async countFiles() {
@@ -2834,7 +3080,7 @@ var QuestionGenerator = class {
         category: "Platform Strategy",
         question: `Are our platform choices (${technology.platforms.join(", ")}) aligned with target market and growth plans?`,
         context: `Currently deployed on ${technology.platforms.join(" + ")}`,
-        findings: technology.platforms.map((p12) => `Supports ${p12} platform`),
+        findings: technology.platforms.map((p13) => `Supports ${p13} platform`),
         recommendations: [
           "Validate platform coverage matches user demographics",
           "Assess cross-platform development efficiency",
@@ -2896,7 +3142,7 @@ var QuestionGenerator = class {
         category: "Business Alignment",
         question: `How is our authentication solution (${authCat.packages.join(", ")}) supporting user onboarding and security requirements?`,
         context: `Using ${authCat.packages.join(" + ")} for authentication`,
-        findings: authCat.packages.map((p12) => `Auth provider: ${p12}`),
+        findings: authCat.packages.map((p13) => `Auth provider: ${p13}`),
         recommendations: [
           "Measure authentication success rates and friction points",
           "Ensure compliance with security standards (SOC2, GDPR, etc.)",
@@ -2948,12 +3194,12 @@ var QuestionGenerator = class {
       });
     }
     if (packages.outdated && packages.outdated.length > 10) {
-      const breakingCount = packages.outdated.filter((p12) => p12.breaking).length;
+      const breakingCount = packages.outdated.filter((p13) => p13.breaking).length;
       questions.push({
         category: "Technical Debt",
         question: `How should we prioritize updating ${packages.outdated.length} outdated packages${breakingCount > 0 ? ` (${breakingCount} with breaking changes)` : ""}?`,
         context: "Dependency audit found outdated packages",
-        findings: packages.outdated.slice(0, 5).map((p12) => `${p12.name}: ${p12.current} \u2192 ${p12.latest}`),
+        findings: packages.outdated.slice(0, 5).map((p13) => `${p13.name}: ${p13.current} \u2192 ${p13.latest}`),
         recommendations: [
           "Create update roadmap starting with non-breaking changes",
           "Test breaking changes in feature branches",
@@ -3263,10 +3509,10 @@ var ReportComparator = class {
    */
   comparePackages() {
     const baselineProduction = new Map(
-      this.baseline.packages.production.map((p12) => [p12.name, p12])
+      this.baseline.packages.production.map((p13) => [p13.name, p13])
     );
     const currentProduction = new Map(
-      this.current.packages.production.map((p12) => [p12.name, p12])
+      this.current.packages.production.map((p13) => [p13.name, p13])
     );
     const added = [];
     const removed = [];
@@ -3298,10 +3544,10 @@ var ReportComparator = class {
       }
     }
     const baselineDev = new Map(
-      this.baseline.packages.development.map((p12) => [p12.name, p12])
+      this.baseline.packages.development.map((p13) => [p13.name, p13])
     );
     const currentDev = new Map(
-      this.current.packages.development.map((p12) => [p12.name, p12])
+      this.current.packages.development.map((p13) => [p13.name, p13])
     );
     for (const [name, pkg] of currentDev) {
       if (!baselineDev.has(name)) {
@@ -3589,20 +3835,20 @@ async function advisoryCommand(options) {
     includeHealth,
     excludePatterns: advisoryConfig?.excludePatterns
   });
-  const spinner9 = p7.spinner();
+  const spinner10 = p7.spinner();
   const depthLabels = {
     executive: "executive summary",
     quick: "quick scan",
     standard: "standard analysis",
     comprehensive: "comprehensive analysis"
   };
-  spinner9.start(`Running ${depthLabels[depth]}...`);
+  spinner10.start(`Running ${depthLabels[depth]}...`);
   let analysis;
   try {
     analysis = await analyzer.analyze();
-    spinner9.stop(`\u2713 Analysis complete`);
+    spinner10.stop(`\u2713 Analysis complete`);
   } catch (error) {
-    spinner9.stop("\u2717 Analysis failed");
+    spinner10.stop("\u2717 Analysis failed");
     console.error(
       chalk11.red(
         `Error: ${error instanceof Error ? error.message : String(error)}`
@@ -3617,19 +3863,19 @@ async function advisoryCommand(options) {
   let comparisonReport;
   let comparator;
   if (options.compare) {
-    const comparisonPath = options.compare.endsWith(".json") ? join6(cwd, options.compare) : join6(cwd, options.compare, "analysis.json");
-    if (existsSync6(comparisonPath)) {
-      spinner9.start("Comparing with previous report...");
+    const comparisonPath = options.compare.endsWith(".json") ? join8(cwd, options.compare) : join8(cwd, options.compare, "analysis.json");
+    if (existsSync8(comparisonPath)) {
+      spinner10.start("Comparing with previous report...");
       try {
-        const previousContent = await readFile4(comparisonPath, "utf-8");
+        const previousContent = await readFile5(comparisonPath, "utf-8");
         const previousAnalysis = JSON.parse(previousContent);
         comparator = new ReportComparator(previousAnalysis, analysis);
         comparisonReport = comparator.compare();
-        spinner9.stop("\u2713 Comparison complete");
+        spinner10.stop("\u2713 Comparison complete");
         console.log("");
         displayComparisonSummary(comparisonReport);
       } catch (error) {
-        spinner9.stop("\u26A0 Comparison failed");
+        spinner10.stop("\u26A0 Comparison failed");
         console.warn(chalk11.yellow(`Could not compare reports: ${error}`));
       }
     } else {
@@ -3646,9 +3892,9 @@ async function advisoryCommand(options) {
     console.log(chalk11.dim("\n--dry-run mode: No files written.\n"));
     return;
   }
-  const fullOutputDir = join6(cwd, outputDir);
-  await mkdir4(fullOutputDir, { recursive: true });
-  spinner9.start("Generating reports...");
+  const fullOutputDir = join8(cwd, outputDir);
+  await mkdir5(fullOutputDir, { recursive: true });
+  spinner10.start("Generating reports...");
   try {
     const timestamp = options.timestamp ? (/* @__PURE__ */ new Date()).toISOString().split("T")[0] : "";
     if (options.format === "json") {
@@ -3662,9 +3908,9 @@ async function advisoryCommand(options) {
         timestamp
       );
     }
-    spinner9.stop("\u2713 Reports generated");
+    spinner10.stop("\u2713 Reports generated");
   } catch (error) {
-    spinner9.stop("\u2717 Failed to write reports");
+    spinner10.stop("\u2717 Failed to write reports");
     console.error(chalk11.red(`Error: ${error}`));
     process.exit(1);
   }
@@ -3672,24 +3918,24 @@ async function advisoryCommand(options) {
   console.log(chalk11.green("\u{1F4DD} Reports written to:"));
   const suffix = options.timestamp ? `-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}` : "";
   if (options.format === "json") {
-    console.log(chalk11.dim(`   ${join6(outputDir, `analysis${suffix}.json`)}`));
-    console.log(chalk11.dim(`   ${join6(outputDir, `questions${suffix}.json`)}`));
+    console.log(chalk11.dim(`   ${join8(outputDir, `analysis${suffix}.json`)}`));
+    console.log(chalk11.dim(`   ${join8(outputDir, `questions${suffix}.json`)}`));
   } else {
     console.log(
-      chalk11.dim(`   ${join6(outputDir, `EXECUTIVE_SUMMARY${suffix}.md`)}`)
+      chalk11.dim(`   ${join8(outputDir, `EXECUTIVE_SUMMARY${suffix}.md`)}`)
     );
     console.log(
-      chalk11.dim(`   ${join6(outputDir, `TECHNOLOGY_AUDIT${suffix}.md`)}`)
+      chalk11.dim(`   ${join8(outputDir, `TECHNOLOGY_AUDIT${suffix}.md`)}`)
     );
     console.log(
-      chalk11.dim(`   ${join6(outputDir, `STRATEGIC_ROADMAP${suffix}.md`)}`)
+      chalk11.dim(`   ${join8(outputDir, `STRATEGIC_ROADMAP${suffix}.md`)}`)
     );
     console.log(
-      chalk11.dim(`   ${join6(outputDir, `BOARD_QUESTIONS${suffix}.md`)}`)
+      chalk11.dim(`   ${join8(outputDir, `BOARD_QUESTIONS${suffix}.md`)}`)
     );
     if (comparisonReport) {
       console.log(
-        chalk11.dim(`   ${join6(outputDir, `DIFF_REPORT${suffix}.md`)}`)
+        chalk11.dim(`   ${join8(outputDir, `DIFF_REPORT${suffix}.md`)}`)
       );
     }
   }
@@ -3782,47 +4028,47 @@ function displayComparisonSummary(comparison) {
 }
 async function writeAnalysisJson(outputDir, analysis, questions, timestamp) {
   const suffix = timestamp ? `-${timestamp}` : "";
-  await writeFile4(
-    join6(outputDir, `analysis${suffix}.json`),
+  await writeFile5(
+    join8(outputDir, `analysis${suffix}.json`),
     JSON.stringify(analysis, null, 2),
     "utf-8"
   );
-  await writeFile4(
-    join6(outputDir, `questions${suffix}.json`),
+  await writeFile5(
+    join8(outputDir, `questions${suffix}.json`),
     JSON.stringify(questions, null, 2),
     "utf-8"
   );
 }
 async function writeMarkdownReports(outputDir, analysis, questions, comparator, timestamp) {
   const suffix = timestamp ? `-${timestamp}` : "";
-  await writeFile4(
-    join6(outputDir, `analysis.json`),
+  await writeFile5(
+    join8(outputDir, `analysis.json`),
     JSON.stringify(analysis, null, 2),
     "utf-8"
   );
-  await writeFile4(
-    join6(outputDir, `EXECUTIVE_SUMMARY${suffix}.md`),
+  await writeFile5(
+    join8(outputDir, `EXECUTIVE_SUMMARY${suffix}.md`),
     generateExecutiveSummary(analysis, questions),
     "utf-8"
   );
-  await writeFile4(
-    join6(outputDir, `TECHNOLOGY_AUDIT${suffix}.md`),
+  await writeFile5(
+    join8(outputDir, `TECHNOLOGY_AUDIT${suffix}.md`),
     generateTechnologyAudit(analysis),
     "utf-8"
   );
-  await writeFile4(
-    join6(outputDir, `STRATEGIC_ROADMAP${suffix}.md`),
+  await writeFile5(
+    join8(outputDir, `STRATEGIC_ROADMAP${suffix}.md`),
     generateStrategicRoadmap(analysis, questions),
     "utf-8"
   );
-  await writeFile4(
-    join6(outputDir, `BOARD_QUESTIONS${suffix}.md`),
+  await writeFile5(
+    join8(outputDir, `BOARD_QUESTIONS${suffix}.md`),
     generateBoardQuestions(questions),
     "utf-8"
   );
   if (comparator) {
-    await writeFile4(
-      join6(outputDir, `DIFF_REPORT${suffix}.md`),
+    await writeFile5(
+      join8(outputDir, `DIFF_REPORT${suffix}.md`),
       comparator.generateMarkdownSummary(),
       "utf-8"
     );
@@ -4439,20 +4685,20 @@ function checkCIThresholds(analysis, config) {
 // src/cli/commands/generate-instructions.ts
 import * as p8 from "@clack/prompts";
 import chalk12 from "chalk";
-import { existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
 async function generateInstructionsCommand(options) {
   p8.intro(chalk12.bgBlue(" workflow-agent generate-instructions "));
   const cwd = process.cwd();
-  const guidelinesDir = join7(cwd, "guidelines");
-  const outputPath = join7(cwd, ".github", "copilot-instructions.md");
-  if (!existsSync7(guidelinesDir)) {
+  const guidelinesDir = join9(cwd, "guidelines");
+  const outputPath = join9(cwd, ".github", "copilot-instructions.md");
+  if (!existsSync9(guidelinesDir)) {
     p8.cancel(
       "No guidelines directory found. Run 'workflow init' first to generate guidelines."
     );
     process.exit(1);
   }
-  if (existsSync7(outputPath) && !options.force) {
+  if (existsSync9(outputPath) && !options.force) {
     const shouldRegenerate = await p8.confirm({
       message: ".github/copilot-instructions.md already exists. Regenerate? (Custom content will be preserved)",
       initialValue: true
@@ -4462,8 +4708,8 @@ async function generateInstructionsCommand(options) {
       process.exit(0);
     }
   }
-  const spinner9 = p8.spinner();
-  spinner9.start("Generating AI agent instructions from guidelines...");
+  const spinner10 = p8.spinner();
+  spinner10.start("Generating AI agent instructions from guidelines...");
   try {
     const result = generateCopilotInstructions(cwd, {
       force: true,
@@ -4471,7 +4717,7 @@ async function generateInstructionsCommand(options) {
     });
     if (result.success) {
       const status = result.isNew ? "Generated" : "Regenerated";
-      spinner9.stop(
+      spinner10.stop(
         chalk12.green(
           `\u2713 ${status} .github/copilot-instructions.md from ${result.guidelinesCount} guidelines`
         )
@@ -4487,12 +4733,12 @@ async function generateInstructionsCommand(options) {
         )
       );
     } else {
-      spinner9.stop(chalk12.red("\u2717 Failed to generate instructions"));
+      spinner10.stop(chalk12.red("\u2717 Failed to generate instructions"));
       console.log(chalk12.yellow(`
 Reason: ${result.error}`));
     }
   } catch (error) {
-    spinner9.stop(chalk12.red("\u2717 Error generating instructions"));
+    spinner10.stop(chalk12.red("\u2717 Error generating instructions"));
     console.log(
       chalk12.yellow(
         `
@@ -4512,8 +4758,8 @@ Reason: ${error instanceof Error ? error.message : String(error)}`
 // src/cli/commands/update-templates.ts
 import * as p9 from "@clack/prompts";
 import chalk13 from "chalk";
-import { existsSync as existsSync8 } from "fs";
-import { join as join8, dirname as dirname3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join10, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname3(__filename3);
@@ -4521,13 +4767,13 @@ async function updateTemplatesCommand(options) {
   const { force = false, skip = false } = options;
   p9.intro(chalk13.bgBlue(" workflow-agent update-templates "));
   const cwd = process.cwd();
-  const guidelinesDir = join8(cwd, "guidelines");
+  const guidelinesDir = join10(cwd, "guidelines");
   const templatesDir = findTemplatesDirectory(__dirname3);
   if (!templatesDir) {
     p9.cancel("Could not find templates directory");
     process.exit(1);
   }
-  const guidelinesExist = existsSync8(guidelinesDir);
+  const guidelinesExist = existsSync10(guidelinesDir);
   if (!guidelinesExist) {
     console.log(chalk13.yellow("\n\u26A0\uFE0F  No guidelines directory found."));
     console.log(chalk13.dim("Run 'workflow-agent init' to set up guidelines.\n"));
@@ -4575,8 +4821,8 @@ async function updateTemplatesCommand(options) {
       process.exit(0);
     }
   }
-  const spinner9 = p9.spinner();
-  spinner9.start("Updating templates...");
+  const spinner10 = p9.spinner();
+  spinner10.start("Updating templates...");
   let result;
   try {
     result = updateTemplates(cwd, templatesDir, {
@@ -4584,7 +4830,7 @@ async function updateTemplatesCommand(options) {
       silent: true
     });
   } catch (error) {
-    spinner9.stop("\u274C Failed to update templates");
+    spinner10.stop("\u274C Failed to update templates");
     console.log(
       chalk13.red(
         `
@@ -4595,7 +4841,7 @@ Error: ${error instanceof Error ? error.message : String(error)}`
   }
   const totalChanges = result.installed.length + result.updated.length;
   if (totalChanges === 0 && result.skipped.length > 0) {
-    spinner9.stop("No changes needed");
+    spinner10.stop("No changes needed");
     console.log(
       chalk13.dim(
         `
@@ -4603,7 +4849,7 @@ Error: ${error instanceof Error ? error.message : String(error)}`
       )
     );
   } else {
-    spinner9.stop(`\u2713 Template update complete`);
+    spinner10.stop(`\u2713 Template update complete`);
     if (result.installed.length > 0) {
       console.log(chalk13.green(`
   New templates installed:`));
@@ -4649,9 +4895,292 @@ Error: ${error instanceof Error ? error.message : String(error)}`
   p9.outro(chalk13.green("Done!"));
 }
 
-// src/cli/commands/learn.ts
-import chalk14 from "chalk";
+// src/cli/commands/docs-validate.ts
 import * as p10 from "@clack/prompts";
+import chalk14 from "chalk";
+import { relative } from "path";
+async function docsValidateCommand(options) {
+  const { fix = false, patterns, ignore } = options;
+  p10.intro(chalk14.bgBlue(" workflow-agent docs:validate "));
+  const cwd = process.cwd();
+  const spinner10 = p10.spinner();
+  spinner10.start("Scanning markdown files for broken references...");
+  try {
+    const result = await validateDocumentReferences(cwd, {
+      patterns,
+      ignore
+    });
+    spinner10.stop("Scan complete");
+    console.log("");
+    console.log(
+      chalk14.cyan(
+        `\u{1F4C4} Scanned ${result.scannedFiles} file(s), found ${result.totalReferences} reference(s)`
+      )
+    );
+    if (result.errors.length > 0) {
+      console.log("");
+      console.log(chalk14.red("\u274C Errors during validation:"));
+      for (const error of result.errors) {
+        console.log(chalk14.red(`   ${error}`));
+      }
+      p10.outro(chalk14.red("Validation failed"));
+      process.exit(1);
+    }
+    if (result.valid) {
+      console.log("");
+      console.log(chalk14.green("\u2705 All document references are valid!"));
+      p10.outro(chalk14.green("No broken links found"));
+      return;
+    }
+    console.log("");
+    console.log(
+      chalk14.yellow(
+        `\u26A0\uFE0F  Found ${result.brokenReferences.length} broken reference(s):`
+      )
+    );
+    console.log("");
+    for (const broken of result.brokenReferences) {
+      const relativePath = relative(cwd, broken.file);
+      console.log(
+        chalk14.red(
+          `  ${relativePath}:${broken.line}:${broken.column} - ${broken.type}`
+        )
+      );
+      console.log(chalk14.dim(`    ${broken.rawLink}`));
+      console.log(chalk14.dim(`    Target: ${broken.targetPath}`));
+      if (broken.suggestions.length > 0) {
+        console.log(chalk14.dim(`    Suggestions: ${broken.suggestions.slice(0, 3).join(", ")}`));
+      }
+      console.log("");
+    }
+    if (!fix) {
+      console.log(
+        chalk14.yellow("\u{1F4A1} Run with --fix flag to interactively fix broken references")
+      );
+      p10.outro(chalk14.red("Validation failed"));
+      process.exit(1);
+    }
+    console.log(chalk14.cyan("\u{1F527} Interactive fix mode\n"));
+    let fixedCount = 0;
+    let skippedCount = 0;
+    for (const broken of result.brokenReferences) {
+      const relativePath = relative(cwd, broken.file);
+      console.log(chalk14.bold(`
+${relativePath}:${broken.line}`));
+      console.log(chalk14.dim(`  ${broken.rawLink}`));
+      console.log(chalk14.yellow(`  \u274C Broken: ${broken.targetPath}
+`));
+      const options2 = [];
+      if (broken.suggestions.length > 0) {
+        options2.push(
+          ...broken.suggestions.slice(0, 8).map((suggestion) => ({
+            value: suggestion,
+            label: `\u{1F4C4} ${suggestion}`
+          }))
+        );
+      }
+      options2.push({
+        value: "__custom__",
+        label: "\u270F\uFE0F  Enter custom path"
+      });
+      options2.push({
+        value: "__skip__",
+        label: "\u23ED\uFE0F  Skip this reference"
+      });
+      const choice = await p10.select({
+        message: "Choose correct path:",
+        options: options2
+      });
+      if (p10.isCancel(choice)) {
+        console.log("");
+        p10.cancel("Fix operation cancelled");
+        console.log(
+          chalk14.dim(`
+Fixed: ${fixedCount}, Skipped: ${skippedCount}`)
+        );
+        process.exit(0);
+      }
+      if (choice === "__skip__") {
+        skippedCount++;
+        continue;
+      }
+      let newPath;
+      if (choice === "__custom__") {
+        const customPath = await p10.text({
+          message: "Enter the correct path:",
+          placeholder: broken.targetPath,
+          validate: (value) => {
+            if (!value || value.trim().length === 0) {
+              return "Path cannot be empty";
+            }
+          }
+        });
+        if (p10.isCancel(customPath)) {
+          console.log("");
+          p10.cancel("Fix operation cancelled");
+          console.log(
+            chalk14.dim(`
+Fixed: ${fixedCount}, Skipped: ${skippedCount}`)
+          );
+          process.exit(0);
+        }
+        newPath = customPath;
+      } else {
+        newPath = choice;
+      }
+      try {
+        await applyReferenceFix(broken.file, broken.rawLink, newPath);
+        console.log(chalk14.green(`  \u2705 Fixed: ${broken.targetPath} \u2192 ${newPath}`));
+        fixedCount++;
+      } catch (error) {
+        console.log(
+          chalk14.red(
+            `  \u274C Failed to fix: ${error instanceof Error ? error.message : "Unknown error"}`
+          )
+        );
+        skippedCount++;
+      }
+    }
+    console.log("");
+    console.log(chalk14.cyan(`\u{1F4CA} Summary:`));
+    console.log(chalk14.green(`   Fixed: ${fixedCount}`));
+    if (skippedCount > 0) {
+      console.log(chalk14.yellow(`   Skipped: ${skippedCount}`));
+    }
+    if (fixedCount > 0) {
+      p10.outro(chalk14.green("Document references fixed!"));
+    } else {
+      p10.outro(chalk14.yellow("No references were fixed"));
+    }
+  } catch (error) {
+    spinner10.stop("Scan failed");
+    console.log("");
+    p10.cancel(
+      `Validation error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/hooks.ts
+import chalk15 from "chalk";
+async function hooksCommand(action) {
+  const cwd = process.cwd();
+  switch (action) {
+    case "install":
+      await installHooksAction(cwd);
+      break;
+    case "uninstall":
+      await uninstallHooksAction(cwd);
+      break;
+    case "status":
+      await statusHooksAction(cwd);
+      break;
+    default:
+      console.error(chalk15.red(`Unknown action: ${action}`));
+      console.log(chalk15.dim("Available actions: install, uninstall, status"));
+      process.exit(1);
+  }
+}
+async function installHooksAction(cwd) {
+  console.log(chalk15.bold.cyan("\n\u{1F517} Installing Workflow Agent Git Hooks\n"));
+  if (!hasGitRepo(cwd)) {
+    console.error(chalk15.red("\u2717 No git repository found"));
+    console.log(chalk15.yellow("  Run: git init"));
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  const hooksConfig = config?.hooks;
+  const results = await installHooks(hooksConfig, cwd);
+  let hasErrors = false;
+  for (const result of results) {
+    if (result.success) {
+      if (result.wrappedExisting) {
+        console.log(
+          chalk15.green(
+            `\u2713 Installed ${result.hookType} hook (wrapped existing hook)`
+          )
+        );
+      } else {
+        console.log(chalk15.green(`\u2713 Installed ${result.hookType} hook`));
+      }
+    } else {
+      console.error(
+        chalk15.red(`\u2717 Failed to install ${result.hookType}: ${result.error}`)
+      );
+      hasErrors = true;
+    }
+  }
+  if (!hasErrors) {
+    console.log(chalk15.green("\n\u2713 Git hooks installed successfully"));
+    console.log(chalk15.dim("\nHooks will run automatically on commit."));
+    console.log(chalk15.dim("They will be skipped in CI environments."));
+  } else {
+    process.exit(1);
+  }
+}
+async function uninstallHooksAction(cwd) {
+  console.log(chalk15.bold.cyan("\n\u{1F513} Uninstalling Workflow Agent Git Hooks\n"));
+  if (!hasGitRepo(cwd)) {
+    console.error(chalk15.red("\u2717 No git repository found"));
+    process.exit(1);
+  }
+  const results = await uninstallHooks(cwd);
+  let hasErrors = false;
+  for (const result of results) {
+    if (result.success) {
+      if (result.wrappedExisting) {
+        console.log(
+          chalk15.green(`\u2713 Removed ${result.hookType} hook (restored original)`)
+        );
+      } else {
+        console.log(chalk15.green(`\u2713 Removed ${result.hookType} hook`));
+      }
+    } else if (result.error) {
+      console.error(
+        chalk15.red(`\u2717 Failed to remove ${result.hookType}: ${result.error}`)
+      );
+      hasErrors = true;
+    }
+  }
+  if (!hasErrors) {
+    console.log(chalk15.green("\n\u2713 Git hooks uninstalled successfully"));
+  } else {
+    process.exit(1);
+  }
+}
+async function statusHooksAction(cwd) {
+  console.log(chalk15.bold.cyan("\n\u{1F4CA} Workflow Agent Git Hooks Status\n"));
+  if (!hasGitRepo(cwd)) {
+    console.error(chalk15.red("\u2717 No git repository found"));
+    process.exit(1);
+  }
+  const statuses = await getAllHooksStatus(cwd);
+  for (const status of statuses) {
+    const icon = status.installed ? "\u2713" : "\u2717";
+    const color = status.installed ? chalk15.green : chalk15.yellow;
+    let message = `${icon} ${status.hookType}`;
+    if (status.installed) {
+      message += " - installed";
+      if (status.wrappedOriginal) {
+        message += " (wrapping original hook)";
+      }
+    } else if (status.hasExistingHook) {
+      message += " - existing hook (not managed by Workflow Agent)";
+    } else {
+      message += " - not installed";
+    }
+    console.log(color(message));
+  }
+  const allInstalled = statuses.every((s) => s.installed);
+  if (!allInstalled) {
+    console.log(chalk15.dim("\nTo install hooks: workflow hooks install"));
+  }
+}
+
+// src/cli/commands/learn.ts
+import chalk16 from "chalk";
+import * as p11 from "@clack/prompts";
 import {
   PatternStore as PatternStore2,
   ContributorManager as ContributorManager2,
@@ -4674,10 +5203,10 @@ function formatTags(tags) {
 async function learnRecordCommand(options) {
   const cwd = getWorkspacePath();
   const store = new PatternStore2(cwd);
-  console.log(chalk14.cyan("\n\u{1F4DA} Record a Learning Pattern\n"));
+  console.log(chalk16.cyan("\n\u{1F4DA} Record a Learning Pattern\n"));
   let patternType = options.type;
   if (!patternType) {
-    const typeChoice = await p10.select({
+    const typeChoice = await p11.select({
       message: "What type of pattern are you recording?",
       options: [
         {
@@ -4690,15 +5219,15 @@ async function learnRecordCommand(options) {
         }
       ]
     });
-    if (p10.isCancel(typeChoice)) {
-      p10.cancel("Recording cancelled");
+    if (p11.isCancel(typeChoice)) {
+      p11.cancel("Recording cancelled");
       process.exit(0);
     }
     patternType = typeChoice;
   }
   let name = options.name;
   if (!name) {
-    const nameInput = await p10.text({
+    const nameInput = await p11.text({
       message: "Pattern name:",
       placeholder: "e.g., Next.js App Router Migration",
       validate: (value) => {
@@ -4708,15 +5237,15 @@ async function learnRecordCommand(options) {
         return void 0;
       }
     });
-    if (p10.isCancel(nameInput)) {
-      p10.cancel("Recording cancelled");
+    if (p11.isCancel(nameInput)) {
+      p11.cancel("Recording cancelled");
       process.exit(0);
     }
     name = nameInput;
   }
   let description = options.description;
   if (!description) {
-    const descInput = await p10.text({
+    const descInput = await p11.text({
       message: "Description:",
       placeholder: "What does this pattern solve?",
       validate: (value) => {
@@ -4727,40 +5256,40 @@ async function learnRecordCommand(options) {
         return void 0;
       }
     });
-    if (p10.isCancel(descInput)) {
-      p10.cancel("Recording cancelled");
+    if (p11.isCancel(descInput)) {
+      p11.cancel("Recording cancelled");
       process.exit(0);
     }
     description = descInput;
   }
   let framework = options.framework;
   if (!framework) {
-    const fwInput = await p10.text({
+    const fwInput = await p11.text({
       message: "Framework:",
       placeholder: "e.g., next, react, vue, express"
     });
-    if (p10.isCancel(fwInput)) {
-      p10.cancel("Recording cancelled");
+    if (p11.isCancel(fwInput)) {
+      p11.cancel("Recording cancelled");
       process.exit(0);
     }
     framework = fwInput;
   }
   let version = options.version;
   if (!version) {
-    const versionInput = await p10.text({
+    const versionInput = await p11.text({
       message: "Framework version (semver range):",
       placeholder: "e.g., >=14.0.0, ^18.0.0",
       initialValue: ">=1.0.0"
     });
-    if (p10.isCancel(versionInput)) {
-      p10.cancel("Recording cancelled");
+    if (p11.isCancel(versionInput)) {
+      p11.cancel("Recording cancelled");
       process.exit(0);
     }
     version = versionInput;
   }
   let category = options.category;
   if (patternType === "fix" && !category) {
-    const catChoice = await p10.select({
+    const catChoice = await p11.select({
       message: "Category:",
       options: [
         { value: "migration", label: "\u{1F504} Migration" },
@@ -4775,8 +5304,8 @@ async function learnRecordCommand(options) {
         { value: "other", label: "\u{1F4E6} Other" }
       ]
     });
-    if (p10.isCancel(catChoice)) {
-      p10.cancel("Recording cancelled");
+    if (p11.isCancel(catChoice)) {
+      p11.cancel("Recording cancelled");
       process.exit(0);
     }
     category = catChoice;
@@ -4839,14 +5368,14 @@ async function learnRecordCommand(options) {
     };
     const result = await store.saveFixPattern(fixPattern);
     if (result.success) {
-      console.log(chalk14.green("\n\u2705 Fix pattern recorded successfully!\n"));
-      console.log(chalk14.dim(`  ID: ${fixPattern.id}`));
-      console.log(chalk14.dim(`  Name: ${name}`));
-      console.log(chalk14.dim(`  Category: ${category}`));
-      console.log(chalk14.dim(`  Framework: ${framework} ${version}`));
+      console.log(chalk16.green("\n\u2705 Fix pattern recorded successfully!\n"));
+      console.log(chalk16.dim(`  ID: ${fixPattern.id}`));
+      console.log(chalk16.dim(`  Name: ${name}`));
+      console.log(chalk16.dim(`  Category: ${category}`));
+      console.log(chalk16.dim(`  Framework: ${framework} ${version}`));
     } else {
-      console.log(chalk14.red("\n\u274C Failed to record pattern"));
-      console.log(chalk14.dim(`  Error: ${result.error}`));
+      console.log(chalk16.red("\n\u274C Failed to record pattern"));
+      console.log(chalk16.dim(`  Error: ${result.error}`));
       process.exit(1);
     }
   } else {
@@ -4893,13 +5422,13 @@ async function learnRecordCommand(options) {
     };
     const result = await store.saveBlueprint(blueprint);
     if (result.success) {
-      console.log(chalk14.green("\n\u2705 Blueprint recorded successfully!\n"));
-      console.log(chalk14.dim(`  ID: ${blueprint.id}`));
-      console.log(chalk14.dim(`  Name: ${name}`));
-      console.log(chalk14.dim(`  Framework: ${framework} ${version}`));
+      console.log(chalk16.green("\n\u2705 Blueprint recorded successfully!\n"));
+      console.log(chalk16.dim(`  ID: ${blueprint.id}`));
+      console.log(chalk16.dim(`  Name: ${name}`));
+      console.log(chalk16.dim(`  Framework: ${framework} ${version}`));
     } else {
-      console.log(chalk14.red("\n\u274C Failed to record blueprint"));
-      console.log(chalk14.dim(`  Error: ${result.error}`));
+      console.log(chalk16.red("\n\u274C Failed to record blueprint"));
+      console.log(chalk16.dim(`  Error: ${result.error}`));
       process.exit(1);
     }
   }
@@ -4909,7 +5438,7 @@ async function learnListCommand(options) {
   const store = new PatternStore2(cwd);
   const patternType = options.type ?? "all";
   const showDeprecated = options.deprecated ?? false;
-  console.log(chalk14.cyan("\n\u{1F4DA} Recorded Learning Patterns\n"));
+  console.log(chalk16.cyan("\n\u{1F4DA} Recorded Learning Patterns\n"));
   if (patternType === "all" || patternType === "fix") {
     const fixResult = await store.listFixPatterns({
       tags: options.tag ? [{ category: "framework", name: options.tag }] : void 0,
@@ -4917,29 +5446,29 @@ async function learnListCommand(options) {
       includeDeprecated: showDeprecated
     });
     if (fixResult.success && fixResult.data && fixResult.data.length > 0) {
-      console.log(chalk14.bold.yellow("\u{1F527} Fix Patterns:\n"));
+      console.log(chalk16.bold.yellow("\u{1F527} Fix Patterns:\n"));
       for (const pattern of fixResult.data) {
         const isDeprecated = pattern.deprecatedAt !== void 0;
         const statusIcon = isDeprecated ? "\u26A0\uFE0F" : "\u2713";
-        const nameColor = isDeprecated ? chalk14.dim : chalk14.white;
+        const nameColor = isDeprecated ? chalk16.dim : chalk16.white;
         console.log(`  ${statusIcon} ${nameColor(pattern.name)}`);
-        console.log(chalk14.dim(`     ID: ${pattern.id}`));
-        console.log(chalk14.dim(`     Category: ${pattern.category}`));
+        console.log(chalk16.dim(`     ID: ${pattern.id}`));
+        console.log(chalk16.dim(`     Category: ${pattern.category}`));
         console.log(
-          chalk14.dim(`     Created: ${formatDate(pattern.createdAt)}`)
+          chalk16.dim(`     Created: ${formatDate(pattern.createdAt)}`)
         );
         console.log(
-          chalk14.dim(
+          chalk16.dim(
             `     Success Rate: ${(pattern.metrics.successRate * 100).toFixed(0)}% (${pattern.metrics.successes}/${pattern.metrics.applications})`
           )
         );
         if (pattern.tags.length > 0) {
-          console.log(chalk14.dim(`     Tags: ${formatTags(pattern.tags)}`));
+          console.log(chalk16.dim(`     Tags: ${formatTags(pattern.tags)}`));
         }
         console.log("");
       }
     } else if (patternType === "fix") {
-      console.log(chalk14.dim("  No fix patterns found.\n"));
+      console.log(chalk16.dim("  No fix patterns found.\n"));
     }
   }
   if (patternType === "all" || patternType === "blueprint") {
@@ -4949,46 +5478,46 @@ async function learnListCommand(options) {
       includeDeprecated: showDeprecated
     });
     if (bpResult.success && bpResult.data && bpResult.data.length > 0) {
-      console.log(chalk14.bold.blue("\u{1F4D0} Blueprints:\n"));
+      console.log(chalk16.bold.blue("\u{1F4D0} Blueprints:\n"));
       for (const blueprint of bpResult.data) {
         const isDeprecated = blueprint.deprecatedAt !== void 0;
         const statusIcon = isDeprecated ? "\u26A0\uFE0F" : "\u2713";
-        const nameColor = isDeprecated ? chalk14.dim : chalk14.white;
+        const nameColor = isDeprecated ? chalk16.dim : chalk16.white;
         console.log(`  ${statusIcon} ${nameColor(blueprint.name)}`);
-        console.log(chalk14.dim(`     ID: ${blueprint.id}`));
-        console.log(chalk14.dim(`     Language: ${blueprint.stack.language}`));
+        console.log(chalk16.dim(`     ID: ${blueprint.id}`));
+        console.log(chalk16.dim(`     Language: ${blueprint.stack.language}`));
         console.log(
-          chalk14.dim(`     Created: ${formatDate(blueprint.createdAt)}`)
+          chalk16.dim(`     Created: ${formatDate(blueprint.createdAt)}`)
         );
         console.log(
-          chalk14.dim(
+          chalk16.dim(
             `     Success Rate: ${(blueprint.metrics.successRate * 100).toFixed(0)}% (${blueprint.metrics.successes}/${blueprint.metrics.applications})`
           )
         );
         if (blueprint.tags.length > 0) {
-          console.log(chalk14.dim(`     Tags: ${formatTags(blueprint.tags)}`));
+          console.log(chalk16.dim(`     Tags: ${formatTags(blueprint.tags)}`));
         }
         console.log("");
       }
     } else if (patternType === "blueprint") {
-      console.log(chalk14.dim("  No blueprints found.\n"));
+      console.log(chalk16.dim("  No blueprints found.\n"));
     }
   }
   const stats = await store.getStats();
   const totalPatterns = stats.totalFixes + stats.totalBlueprints;
   const totalDeprecated = stats.deprecatedFixes + stats.deprecatedBlueprints;
-  console.log(chalk14.dim("\u2501".repeat(40)));
-  console.log(chalk14.dim(`Total: ${totalPatterns} patterns`));
-  console.log(chalk14.dim(`  Fix Patterns: ${stats.totalFixes}`));
-  console.log(chalk14.dim(`  Blueprints: ${stats.totalBlueprints}`));
-  console.log(chalk14.dim(`  Deprecated: ${totalDeprecated}`));
+  console.log(chalk16.dim("\u2501".repeat(40)));
+  console.log(chalk16.dim(`Total: ${totalPatterns} patterns`));
+  console.log(chalk16.dim(`  Fix Patterns: ${stats.totalFixes}`));
+  console.log(chalk16.dim(`  Blueprints: ${stats.totalBlueprints}`));
+  console.log(chalk16.dim(`  Deprecated: ${totalDeprecated}`));
   console.log("");
 }
 async function learnApplyCommand(patternId, options) {
   const cwd = getWorkspacePath();
   const store = new PatternStore2(cwd);
   const telemetry = new TelemetryCollector2(cwd);
-  console.log(chalk14.cyan("\n\u{1F527} Apply Learning Pattern\n"));
+  console.log(chalk16.cyan("\n\u{1F527} Apply Learning Pattern\n"));
   let pattern = await store.getFixPattern(patternId);
   let patternType = "fix";
   if (!pattern.success || !pattern.data) {
@@ -4997,21 +5526,21 @@ async function learnApplyCommand(patternId, options) {
       pattern = bpResult;
       patternType = "blueprint";
     } else {
-      console.log(chalk14.red(`
+      console.log(chalk16.red(`
 \u274C Pattern not found: ${patternId}`));
       console.log(
-        chalk14.dim("  Use 'workflow learn:list' to see available patterns")
+        chalk16.dim("  Use 'workflow learn:list' to see available patterns")
       );
       process.exit(1);
     }
   }
   const patternData = pattern.data;
-  console.log(chalk14.white(`  Pattern: ${patternData.name}`));
-  console.log(chalk14.dim(`  Type: ${patternType}`));
-  console.log(chalk14.dim(`  Description: ${patternData.description}`));
+  console.log(chalk16.white(`  Pattern: ${patternData.name}`));
+  console.log(chalk16.dim(`  Type: ${patternType}`));
+  console.log(chalk16.dim(`  Description: ${patternData.description}`));
   if (options.dryRun) {
     console.log(
-      chalk14.yellow("\n\u{1F4CB} DRY-RUN MODE: No changes will be applied\n")
+      chalk16.yellow("\n\u{1F4CB} DRY-RUN MODE: No changes will be applied\n")
     );
   }
   const framework = options.framework ?? patternData.compatibility.frameworks[0]?.name ?? "unknown";
@@ -5019,44 +5548,44 @@ async function learnApplyCommand(patternId, options) {
   await telemetry.recordApplication(patternId, patternType, framework, version);
   if (patternType === "fix") {
     const fixPattern = patternData;
-    console.log(chalk14.cyan("\n\u{1F4CB} Solution Steps:\n"));
+    console.log(chalk16.cyan("\n\u{1F4CB} Solution Steps:\n"));
     if (fixPattern.solution.steps) {
       for (let i = 0; i < fixPattern.solution.steps.length; i++) {
         const step = fixPattern.solution.steps[i];
         console.log(
-          chalk14.white(`  ${i + 1}. [${step.action}] ${step.description}`)
+          chalk16.white(`  ${i + 1}. [${step.action}] ${step.description}`)
         );
         if (step.file) {
-          console.log(chalk14.dim(`     File: ${step.file}`));
+          console.log(chalk16.dim(`     File: ${step.file}`));
         }
       }
     }
   } else {
     const blueprint = patternData;
-    console.log(chalk14.cyan("\n\u{1F4CB} Setup Steps:\n"));
+    console.log(chalk16.cyan("\n\u{1F4CB} Setup Steps:\n"));
     if (blueprint.setup.steps) {
       for (let i = 0; i < blueprint.setup.steps.length; i++) {
         const step = blueprint.setup.steps[i];
-        console.log(chalk14.white(`  ${i + 1}. ${step.description}`));
+        console.log(chalk16.white(`  ${i + 1}. ${step.description}`));
         if (step.command) {
-          console.log(chalk14.dim(`     Command: ${step.command}`));
+          console.log(chalk16.dim(`     Command: ${step.command}`));
         }
       }
     }
   }
   if (!options.dryRun) {
-    const confirmed = await p10.confirm({
+    const confirmed = await p11.confirm({
       message: "Mark this pattern as successfully applied?",
       initialValue: true
     });
-    if (p10.isCancel(confirmed)) {
-      p10.cancel("Application cancelled");
+    if (p11.isCancel(confirmed)) {
+      p11.cancel("Application cancelled");
       process.exit(0);
     }
     if (confirmed) {
       await store.updatePatternMetrics(patternId, patternType, true);
       await telemetry.recordSuccess(patternId, patternType, framework, version);
-      console.log(chalk14.green("\n\u2705 Pattern marked as successfully applied!"));
+      console.log(chalk16.green("\n\u2705 Pattern marked as successfully applied!"));
     } else {
       await store.updatePatternMetrics(patternId, patternType, false);
       await telemetry.recordFailure(
@@ -5067,7 +5596,7 @@ async function learnApplyCommand(patternId, options) {
         "unknown"
       );
       console.log(
-        chalk14.yellow("\n\u26A0\uFE0F Pattern application marked as unsuccessful.")
+        chalk16.yellow("\n\u26A0\uFE0F Pattern application marked as unsuccessful.")
       );
     }
   }
@@ -5075,32 +5604,32 @@ async function learnApplyCommand(patternId, options) {
 async function learnSyncCommand(options) {
   const cwd = getWorkspacePath();
   const contributorManager = new ContributorManager2(cwd);
-  console.log(chalk14.cyan("\n\u{1F504} Sync Learning Patterns\n"));
+  console.log(chalk16.cyan("\n\u{1F504} Sync Learning Patterns\n"));
   const config = await contributorManager.getConfig();
   if (!config.success || !config.data?.syncOptIn) {
-    console.log(chalk14.yellow("\u26A0\uFE0F Sync is not enabled.\n"));
-    console.log(chalk14.dim("  To enable sync, run:"));
-    console.log(chalk14.dim("    workflow learn:config --enable-sync\n"));
+    console.log(chalk16.yellow("\u26A0\uFE0F Sync is not enabled.\n"));
+    console.log(chalk16.dim("  To enable sync, run:"));
+    console.log(chalk16.dim("    workflow learn:config --enable-sync\n"));
     console.log(
-      chalk14.dim(
+      chalk16.dim(
         "  This allows you to share anonymized patterns with the community."
       )
     );
     process.exit(0);
   }
   if (options.dryRun) {
-    console.log(chalk14.yellow("\u{1F4CB} DRY-RUN MODE: No changes will be synced\n"));
+    console.log(chalk16.yellow("\u{1F4CB} DRY-RUN MODE: No changes will be synced\n"));
   }
   const store = new PatternStore2(cwd);
   const anonymizer = new PatternAnonymizer();
   const { fixes, blueprints } = await store.getPatternsForSync();
   console.log(
-    chalk14.dim(
+    chalk16.dim(
       `  Patterns ready to sync: ${fixes.length} fixes, ${blueprints.length} blueprints`
     )
   );
   if (options.push) {
-    console.log(chalk14.cyan("\n\u{1F4E4} Pushing patterns...\n"));
+    console.log(chalk16.cyan("\n\u{1F4E4} Pushing patterns...\n"));
     let anonymizedFixes = 0;
     let anonymizedBlueprints = 0;
     for (const fix of fixes) {
@@ -5108,7 +5637,7 @@ async function learnSyncCommand(options) {
       if (result.success) {
         anonymizedFixes++;
         if (!options.dryRun) {
-          console.log(chalk14.dim(`  \u2713 Anonymized: ${fix.name}`));
+          console.log(chalk16.dim(`  \u2713 Anonymized: ${fix.name}`));
         }
       }
     }
@@ -5117,117 +5646,117 @@ async function learnSyncCommand(options) {
       if (result.success) {
         anonymizedBlueprints++;
         if (!options.dryRun) {
-          console.log(chalk14.dim(`  \u2713 Anonymized: ${bp.name}`));
+          console.log(chalk16.dim(`  \u2713 Anonymized: ${bp.name}`));
         }
       }
     }
     console.log(
-      chalk14.green(
+      chalk16.green(
         `
 \u2705 Ready to push ${anonymizedFixes} fixes and ${anonymizedBlueprints} blueprints`
       )
     );
-    console.log(chalk14.dim("  (Registry push not yet implemented)"));
+    console.log(chalk16.dim("  (Registry push not yet implemented)"));
   }
   if (options.pull) {
-    console.log(chalk14.cyan("\n\u{1F4E5} Pulling patterns from registry...\n"));
-    console.log(chalk14.dim("  (Registry pull not yet implemented)"));
+    console.log(chalk16.cyan("\n\u{1F4E5} Pulling patterns from registry...\n"));
+    console.log(chalk16.dim("  (Registry pull not yet implemented)"));
   }
   if (!options.push && !options.pull) {
     console.log(
-      chalk14.dim("  Specify --push to upload or --pull to download patterns.\n")
+      chalk16.dim("  Specify --push to upload or --pull to download patterns.\n")
     );
   }
 }
 async function learnConfigCommand(options) {
   const cwd = getWorkspacePath();
   const contributorManager = new ContributorManager2(cwd);
-  console.log(chalk14.cyan("\n\u2699\uFE0F Learning Configuration\n"));
+  console.log(chalk16.cyan("\n\u2699\uFE0F Learning Configuration\n"));
   if (options.enableSync) {
     const result = await contributorManager.enableSync();
     if (result.success) {
-      console.log(chalk14.green("\u2705 Sync enabled"));
+      console.log(chalk16.green("\u2705 Sync enabled"));
       console.log(
-        chalk14.dim("  Your patterns will be anonymized before sharing.")
+        chalk16.dim("  Your patterns will be anonymized before sharing.")
       );
     } else {
-      console.log(chalk14.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk16.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.disableSync) {
     const result = await contributorManager.disableSync();
     if (result.success) {
-      console.log(chalk14.green("\u2705 Sync disabled"));
+      console.log(chalk16.green("\u2705 Sync disabled"));
     } else {
-      console.log(chalk14.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk16.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.enableTelemetry) {
     const result = await contributorManager.enableTelemetry();
     if (result.success) {
-      console.log(chalk14.green("\u2705 Telemetry enabled"));
+      console.log(chalk16.green("\u2705 Telemetry enabled"));
       console.log(
-        chalk14.dim(
+        chalk16.dim(
           "  Anonymous usage data helps improve pattern recommendations."
         )
       );
     } else {
-      console.log(chalk14.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk16.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.disableTelemetry) {
     const result = await contributorManager.disableTelemetry();
     if (result.success) {
-      console.log(chalk14.green("\u2705 Telemetry disabled"));
+      console.log(chalk16.green("\u2705 Telemetry disabled"));
     } else {
-      console.log(chalk14.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk16.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   if (options.resetId) {
-    const confirmed = await p10.confirm({
+    const confirmed = await p11.confirm({
       message: "Are you sure you want to reset your contributor ID? This cannot be undone.",
       initialValue: false
     });
-    if (p10.isCancel(confirmed) || !confirmed) {
-      p10.cancel("Reset cancelled");
+    if (p11.isCancel(confirmed) || !confirmed) {
+      p11.cancel("Reset cancelled");
       return;
     }
     const result = await contributorManager.resetId();
     if (result.success) {
-      console.log(chalk14.green("\u2705 Contributor ID reset"));
-      console.log(chalk14.dim(`  New ID: ${result.data?.id}`));
+      console.log(chalk16.green("\u2705 Contributor ID reset"));
+      console.log(chalk16.dim(`  New ID: ${result.data?.id}`));
     } else {
-      console.log(chalk14.red(`\u274C Failed: ${result.error}`));
+      console.log(chalk16.red(`\u274C Failed: ${result.error}`));
     }
     return;
   }
   const config = await contributorManager.getConfig();
   if (config.success && config.data) {
-    console.log(chalk14.white("  Current Settings:\n"));
-    console.log(chalk14.dim(`  Contributor ID: ${config.data.id}`));
-    console.log(chalk14.dim(`  Created: ${formatDate(config.data.createdAt)}`));
+    console.log(chalk16.white("  Current Settings:\n"));
+    console.log(chalk16.dim(`  Contributor ID: ${config.data.id}`));
+    console.log(chalk16.dim(`  Created: ${formatDate(config.data.createdAt)}`));
     console.log(
-      chalk14.dim(`  Sync Enabled: ${config.data.syncOptIn ? "Yes" : "No"}`)
+      chalk16.dim(`  Sync Enabled: ${config.data.syncOptIn ? "Yes" : "No"}`)
     );
     console.log(
-      chalk14.dim(
+      chalk16.dim(
         `  Telemetry Enabled: ${config.data.telemetryEnabled ? "Yes" : "No"}`
       )
     );
     if (config.data.syncEnabledAt) {
       console.log(
-        chalk14.dim(
+        chalk16.dim(
           `  Sync Enabled At: ${formatDate(config.data.syncEnabledAt)}`
         )
       );
     }
   } else {
     console.log(
-      chalk14.dim(
+      chalk16.dim(
         "  No configuration found. Settings will be created on first use.\n"
       )
     );
@@ -5236,7 +5765,7 @@ async function learnConfigCommand(options) {
 async function learnDeprecateCommand(patternId, reason) {
   const cwd = getWorkspacePath();
   const store = new PatternStore2(cwd);
-  console.log(chalk14.cyan("\n\u26A0\uFE0F Deprecate Pattern\n"));
+  console.log(chalk16.cyan("\n\u26A0\uFE0F Deprecate Pattern\n"));
   let patternType = "fix";
   let pattern = await store.getFixPattern(patternId);
   if (!pattern.success || !pattern.data) {
@@ -5245,26 +5774,26 @@ async function learnDeprecateCommand(patternId, reason) {
       pattern = bpResult;
       patternType = "blueprint";
     } else {
-      console.log(chalk14.red(`
+      console.log(chalk16.red(`
 \u274C Pattern not found: ${patternId}`));
       process.exit(1);
     }
   }
-  console.log(chalk14.white(`  Pattern: ${pattern.data.name}`));
-  console.log(chalk14.dim(`  Reason: ${reason}`));
-  const confirmed = await p10.confirm({
+  console.log(chalk16.white(`  Pattern: ${pattern.data.name}`));
+  console.log(chalk16.dim(`  Reason: ${reason}`));
+  const confirmed = await p11.confirm({
     message: "Are you sure you want to deprecate this pattern?",
     initialValue: false
   });
-  if (p10.isCancel(confirmed) || !confirmed) {
-    p10.cancel("Deprecation cancelled");
+  if (p11.isCancel(confirmed) || !confirmed) {
+    p11.cancel("Deprecation cancelled");
     return;
   }
   const result = await store.deprecatePattern(patternId, patternType, reason);
   if (result.success) {
-    console.log(chalk14.green("\n\u2705 Pattern deprecated successfully"));
+    console.log(chalk16.green("\n\u2705 Pattern deprecated successfully"));
   } else {
-    console.log(chalk14.red(`
+    console.log(chalk16.red(`
 \u274C Failed: ${result.error}`));
     process.exit(1);
   }
@@ -5273,32 +5802,32 @@ async function learnStatsCommand() {
   const cwd = getWorkspacePath();
   const store = new PatternStore2(cwd);
   const telemetry = new TelemetryCollector2(cwd);
-  console.log(chalk14.cyan("\n\u{1F4CA} Learning Statistics\n"));
+  console.log(chalk16.cyan("\n\u{1F4CA} Learning Statistics\n"));
   const storeStats = await store.getStats();
   const totalPatterns = storeStats.totalFixes + storeStats.totalBlueprints;
   const totalDeprecated = storeStats.deprecatedFixes + storeStats.deprecatedBlueprints;
-  console.log(chalk14.bold.white("  Patterns:\n"));
-  console.log(chalk14.dim(`    Total: ${totalPatterns}`));
-  console.log(chalk14.dim(`    Fix Patterns: ${storeStats.totalFixes}`));
-  console.log(chalk14.dim(`    Blueprints: ${storeStats.totalBlueprints}`));
-  console.log(chalk14.dim(`    Deprecated: ${totalDeprecated}`));
+  console.log(chalk16.bold.white("  Patterns:\n"));
+  console.log(chalk16.dim(`    Total: ${totalPatterns}`));
+  console.log(chalk16.dim(`    Fix Patterns: ${storeStats.totalFixes}`));
+  console.log(chalk16.dim(`    Blueprints: ${storeStats.totalBlueprints}`));
+  console.log(chalk16.dim(`    Deprecated: ${totalDeprecated}`));
   const telemetryStats = await telemetry.getStats();
-  console.log(chalk14.bold.white("\n  Telemetry:\n"));
-  console.log(chalk14.dim(`    Pending Events: ${telemetryStats.pendingEvents}`));
+  console.log(chalk16.bold.white("\n  Telemetry:\n"));
+  console.log(chalk16.dim(`    Pending Events: ${telemetryStats.pendingEvents}`));
   console.log(
-    chalk14.dim(`    Total Events Sent: ${telemetryStats.totalEventsSent}`)
+    chalk16.dim(`    Total Events Sent: ${telemetryStats.totalEventsSent}`)
   );
   if (telemetryStats.lastFlushAt) {
     console.log(
-      chalk14.dim(`    Last Flush: ${formatDate(telemetryStats.lastFlushAt)}`)
+      chalk16.dim(`    Last Flush: ${formatDate(telemetryStats.lastFlushAt)}`)
     );
   }
   console.log("");
 }
 
 // src/cli/commands/solution.ts
-import chalk15 from "chalk";
-import * as p11 from "@clack/prompts";
+import chalk17 from "chalk";
+import * as p12 from "@clack/prompts";
 import * as path2 from "path";
 import {
   PatternStore as PatternStore3,
@@ -5340,10 +5869,10 @@ function truncate(str, maxLen) {
 async function solutionCaptureCommand(options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk15.cyan("\n\u{1F4E6} Capture Solution Pattern\n"));
+  console.log(chalk17.cyan("\n\u{1F4E6} Capture Solution Pattern\n"));
   let targetPath = options.path;
   if (!targetPath) {
-    const pathInput = await p11.text({
+    const pathInput = await p12.text({
       message: "Path to the solution directory:",
       placeholder: "./src/auth",
       validate: (val) => {
@@ -5351,8 +5880,8 @@ async function solutionCaptureCommand(options) {
         return void 0;
       }
     });
-    if (p11.isCancel(pathInput)) {
-      p11.cancel("Operation cancelled");
+    if (p12.isCancel(pathInput)) {
+      p12.cancel("Operation cancelled");
       process.exit(0);
     }
     targetPath = pathInput;
@@ -5360,7 +5889,7 @@ async function solutionCaptureCommand(options) {
   const absolutePath = path2.isAbsolute(targetPath) ? targetPath : path2.resolve(cwd, targetPath);
   let name = options.name;
   if (!name) {
-    const nameInput = await p11.text({
+    const nameInput = await p12.text({
       message: "Solution name:",
       placeholder: "JWT Authentication",
       validate: (val) => {
@@ -5368,15 +5897,15 @@ async function solutionCaptureCommand(options) {
         return void 0;
       }
     });
-    if (p11.isCancel(nameInput)) {
-      p11.cancel("Operation cancelled");
+    if (p12.isCancel(nameInput)) {
+      p12.cancel("Operation cancelled");
       process.exit(0);
     }
     name = nameInput;
   }
   let description = options.description;
   if (!description) {
-    const descInput = await p11.text({
+    const descInput = await p12.text({
       message: "Solution description:",
       placeholder: "Complete JWT-based authentication with refresh tokens",
       validate: (val) => {
@@ -5385,15 +5914,15 @@ async function solutionCaptureCommand(options) {
         return void 0;
       }
     });
-    if (p11.isCancel(descInput)) {
-      p11.cancel("Operation cancelled");
+    if (p12.isCancel(descInput)) {
+      p12.cancel("Operation cancelled");
       process.exit(0);
     }
     description = descInput;
   }
   let category = options.category;
   if (!category) {
-    const categoryChoice = await p11.select({
+    const categoryChoice = await p12.select({
       message: "Solution category:",
       options: [
         { value: "auth", label: "\u{1F510} Authentication" },
@@ -5412,8 +5941,8 @@ async function solutionCaptureCommand(options) {
         { value: "other", label: "\u{1F4E6} Other" }
       ]
     });
-    if (p11.isCancel(categoryChoice)) {
-      p11.cancel("Operation cancelled");
+    if (p12.isCancel(categoryChoice)) {
+      p12.cancel("Operation cancelled");
       process.exit(0);
     }
     category = categoryChoice;
@@ -5422,20 +5951,20 @@ async function solutionCaptureCommand(options) {
   if (options.keywords) {
     keywords = options.keywords.split(",").map((k) => k.trim());
   } else {
-    const keywordsInput = await p11.text({
+    const keywordsInput = await p12.text({
       message: "Keywords (comma-separated):",
       placeholder: "jwt, authentication, login, refresh-token"
     });
-    if (p11.isCancel(keywordsInput)) {
-      p11.cancel("Operation cancelled");
+    if (p12.isCancel(keywordsInput)) {
+      p12.cancel("Operation cancelled");
       process.exit(0);
     }
     if (keywordsInput) {
       keywords = keywordsInput.split(",").map((k) => k.trim());
     }
   }
-  const spinner9 = p11.spinner();
-  spinner9.start("Analyzing solution...");
+  const spinner10 = p12.spinner();
+  spinner10.start("Analyzing solution...");
   const analyzer = new CodeAnalyzer({
     anonymize: options.anonymize ?? false
   });
@@ -5447,38 +5976,38 @@ async function solutionCaptureCommand(options) {
       category,
       keywords
     );
-    spinner9.stop("Solution analyzed");
-    console.log(chalk15.green("\n\u2713 Solution captured successfully!\n"));
-    console.log(chalk15.dim("\u2500".repeat(50)));
-    console.log(`${chalk15.bold("Name:")} ${pattern.name}`);
+    spinner10.stop("Solution analyzed");
+    console.log(chalk17.green("\n\u2713 Solution captured successfully!\n"));
+    console.log(chalk17.dim("\u2500".repeat(50)));
+    console.log(`${chalk17.bold("Name:")} ${pattern.name}`);
     console.log(
-      `${chalk15.bold("Category:")} ${formatCategory(pattern.category)}`
+      `${chalk17.bold("Category:")} ${formatCategory(pattern.category)}`
     );
     console.log(
-      `${chalk15.bold("Files:")} ${pattern.implementation.files.length}`
+      `${chalk17.bold("Files:")} ${pattern.implementation.files.length}`
     );
     console.log(
-      `${chalk15.bold("Dependencies:")} ${pattern.implementation.dependencies.length}`
+      `${chalk17.bold("Dependencies:")} ${pattern.implementation.dependencies.length}`
     );
     console.log(
-      `${chalk15.bold("Framework:")} ${pattern.compatibility.framework || "generic"}`
+      `${chalk17.bold("Framework:")} ${pattern.compatibility.framework || "generic"}`
     );
-    console.log(chalk15.dim("\u2500".repeat(50)));
-    const confirm10 = await p11.confirm({
+    console.log(chalk17.dim("\u2500".repeat(50)));
+    const confirm10 = await p12.confirm({
       message: "Save this solution pattern?",
       initialValue: true
     });
-    if (p11.isCancel(confirm10) || !confirm10) {
-      p11.cancel("Solution not saved");
+    if (p12.isCancel(confirm10) || !confirm10) {
+      p12.cancel("Solution not saved");
       process.exit(0);
     }
     await store.saveSolution(pattern);
-    console.log(chalk15.green(`
+    console.log(chalk17.green(`
 \u2713 Solution saved with ID: ${pattern.id}
 `));
   } catch (error) {
-    spinner9.stop("Analysis failed");
-    console.error(chalk15.red(`
+    spinner10.stop("Analysis failed");
+    console.error(chalk17.red(`
 \u2717 Error: ${error.message}
 `));
     process.exit(1);
@@ -5487,7 +6016,7 @@ async function solutionCaptureCommand(options) {
 async function solutionSearchCommand(query, options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk15.cyan("\n\u{1F50D} Search Solution Patterns\n"));
+  console.log(chalk17.cyan("\n\u{1F50D} Search Solution Patterns\n"));
   const keywords = query.split(/\s+/).filter((k) => k.length > 0);
   const result = await store.searchSolutions(keywords, {
     category: options.category,
@@ -5495,39 +6024,39 @@ async function solutionSearchCommand(query, options) {
     limit: options.limit ?? 10
   });
   if (!result.success || !result.data) {
-    console.error(chalk15.red(`
+    console.error(chalk17.red(`
 \u2717 Search failed: ${result.error}
 `));
     return;
   }
   const solutions = result.data;
   if (solutions.length === 0) {
-    console.log(chalk15.yellow("No solutions found matching your query.\n"));
-    console.log(chalk15.dim("Try different keywords or fewer filters."));
+    console.log(chalk17.yellow("No solutions found matching your query.\n"));
+    console.log(chalk17.dim("Try different keywords or fewer filters."));
     return;
   }
-  console.log(chalk15.green(`Found ${solutions.length} solution(s):
+  console.log(chalk17.green(`Found ${solutions.length} solution(s):
 `));
-  console.log(chalk15.dim("\u2500".repeat(70)));
+  console.log(chalk17.dim("\u2500".repeat(70)));
   for (const solution of solutions) {
     console.log(
-      `${chalk15.bold(solution.name)} ${chalk15.dim(`(${solution.id.slice(0, 8)})`)}`
+      `${chalk17.bold(solution.name)} ${chalk17.dim(`(${solution.id.slice(0, 8)})`)}`
     );
     console.log(`  ${formatCategory(solution.category)}`);
-    console.log(`  ${chalk15.dim(truncate(solution.description, 60))}`);
+    console.log(`  ${chalk17.dim(truncate(solution.description, 60))}`);
     console.log(
       `  Files: ${solution.implementation.files.length} | Framework: ${solution.compatibility.framework || "generic"} | Uses: ${solution.metrics.applications}`
     );
-    console.log(chalk15.dim("\u2500".repeat(70)));
+    console.log(chalk17.dim("\u2500".repeat(70)));
   }
   console.log(
-    chalk15.dim("\nUse 'workflow solution:apply <id>' to apply a solution.")
+    chalk17.dim("\nUse 'workflow solution:apply <id>' to apply a solution.")
   );
 }
 async function solutionListCommand(options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk15.cyan("\n\u{1F4CB} Solution Patterns\n"));
+  console.log(chalk17.cyan("\n\u{1F4CB} Solution Patterns\n"));
   const result = await store.listSolutions({
     category: options.category,
     framework: options.framework,
@@ -5535,20 +6064,20 @@ async function solutionListCommand(options) {
     limit: options.limit ?? 20
   });
   if (!result.success || !result.data) {
-    console.error(chalk15.red(`
+    console.error(chalk17.red(`
 \u2717 List failed: ${result.error}
 `));
     return;
   }
   const solutions = result.data;
   if (solutions.length === 0) {
-    console.log(chalk15.yellow("No solutions found.\n"));
+    console.log(chalk17.yellow("No solutions found.\n"));
     console.log(
-      chalk15.dim("Use 'workflow solution:capture' to capture a solution.")
+      chalk17.dim("Use 'workflow solution:capture' to capture a solution.")
     );
     return;
   }
-  console.log(chalk15.green(`${solutions.length} solution(s):
+  console.log(chalk17.green(`${solutions.length} solution(s):
 `));
   const byCategory = /* @__PURE__ */ new Map();
   for (const solution of solutions) {
@@ -5557,24 +6086,24 @@ async function solutionListCommand(options) {
     byCategory.set(solution.category, list);
   }
   for (const [category, items] of byCategory) {
-    console.log(chalk15.bold(`
+    console.log(chalk17.bold(`
 ${formatCategory(category)}`));
-    console.log(chalk15.dim("\u2500".repeat(50)));
+    console.log(chalk17.dim("\u2500".repeat(50)));
     for (const solution of items) {
-      const deprecated = solution.deprecatedAt ? chalk15.red(" [DEPRECATED]") : "";
+      const deprecated = solution.deprecatedAt ? chalk17.red(" [DEPRECATED]") : "";
       console.log(
-        `  ${chalk15.cyan(solution.id.slice(0, 8))} ${solution.name}${deprecated}`
+        `  ${chalk17.cyan(solution.id.slice(0, 8))} ${solution.name}${deprecated}`
       );
-      console.log(`    ${chalk15.dim(truncate(solution.description, 50))}`);
+      console.log(`    ${chalk17.dim(truncate(solution.description, 50))}`);
       console.log(
-        chalk15.dim(
+        chalk17.dim(
           `    Created: ${formatDate2(solution.createdAt)} | Files: ${solution.implementation.files.length}`
         )
       );
     }
   }
   console.log(
-    chalk15.dim(
+    chalk17.dim(
       "\nUse 'workflow solution:search <query>' to find specific solutions."
     )
   );
@@ -5582,10 +6111,10 @@ ${formatCategory(category)}`));
 async function solutionApplyCommand(solutionId, options) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk15.cyan("\n\u{1F680} Apply Solution Pattern\n"));
+  console.log(chalk17.cyan("\n\u{1F680} Apply Solution Pattern\n"));
   const result = await store.getSolution(solutionId);
   if (!result.success || !result.data) {
-    console.error(chalk15.red(`
+    console.error(chalk17.red(`
 \u2717 Solution not found: ${solutionId}
 `));
     process.exit(1);
@@ -5593,60 +6122,60 @@ async function solutionApplyCommand(solutionId, options) {
   const solution = result.data;
   if (solution.deprecatedAt) {
     console.log(
-      chalk15.yellow(
+      chalk17.yellow(
         `\u26A0\uFE0F  This solution is deprecated: ${solution.deprecationReason || "No reason provided"}
 `
       )
     );
-    const proceed = await p11.confirm({
+    const proceed = await p12.confirm({
       message: "Do you want to continue?",
       initialValue: false
     });
-    if (p11.isCancel(proceed) || !proceed) {
-      p11.cancel("Operation cancelled");
+    if (p12.isCancel(proceed) || !proceed) {
+      p12.cancel("Operation cancelled");
       process.exit(0);
     }
   }
-  console.log(chalk15.bold(`Solution: ${solution.name}`));
-  console.log(chalk15.dim(solution.description));
+  console.log(chalk17.bold(`Solution: ${solution.name}`));
+  console.log(chalk17.dim(solution.description));
   console.log();
-  console.log(chalk15.bold("Files to create:"));
+  console.log(chalk17.bold("Files to create:"));
   const filesToApply = options.includeTests ? solution.implementation.files : solution.implementation.files.filter(
     (f) => f.role !== "test"
   );
   for (const file of filesToApply) {
-    console.log(chalk15.dim(`  \u2022 ${file.path} (${file.role})`));
+    console.log(chalk17.dim(`  \u2022 ${file.path} (${file.role})`));
   }
   console.log();
   if (solution.implementation.dependencies.length > 0) {
-    console.log(chalk15.bold("Dependencies to install:"));
+    console.log(chalk17.bold("Dependencies to install:"));
     for (const dep of solution.implementation.dependencies) {
-      console.log(chalk15.dim(`  \u2022 ${dep.name}@${dep.version}`));
+      console.log(chalk17.dim(`  \u2022 ${dep.name}@${dep.version}`));
     }
     console.log();
   }
   if (solution.implementation.envVars.length > 0) {
-    console.log(chalk15.bold("Environment variables needed:"));
+    console.log(chalk17.bold("Environment variables needed:"));
     for (const env of solution.implementation.envVars) {
-      const required = env.required ? chalk15.red("*") : "";
-      console.log(chalk15.dim(`  \u2022 ${env.name}${required}`));
+      const required = env.required ? chalk17.red("*") : "";
+      console.log(chalk17.dim(`  \u2022 ${env.name}${required}`));
     }
     console.log();
   }
   if (options.dryRun) {
-    console.log(chalk15.yellow("Dry run mode - no files were created.\n"));
+    console.log(chalk17.yellow("Dry run mode - no files were created.\n"));
     return;
   }
-  const confirm10 = await p11.confirm({
+  const confirm10 = await p12.confirm({
     message: "Apply this solution?",
     initialValue: true
   });
-  if (p11.isCancel(confirm10) || !confirm10) {
-    p11.cancel("Operation cancelled");
+  if (p12.isCancel(confirm10) || !confirm10) {
+    p12.cancel("Operation cancelled");
     process.exit(0);
   }
-  const spinner9 = p11.spinner();
-  spinner9.start("Applying solution...");
+  const spinner10 = p12.spinner();
+  spinner10.start("Applying solution...");
   try {
     const outputDir = options.output || cwd;
     const fs2 = await import("fs");
@@ -5658,20 +6187,20 @@ async function solutionApplyCommand(solutionId, options) {
       await fs2.promises.writeFile(filePath, file.content);
     }
     await store.updateSolutionMetrics(solution.id, true);
-    spinner9.stop("Solution applied");
-    console.log(chalk15.green(`
+    spinner10.stop("Solution applied");
+    console.log(chalk17.green(`
 \u2713 Solution applied successfully!
 `));
-    console.log(chalk15.dim(`Created ${filesToApply.length} file(s).`));
+    console.log(chalk17.dim(`Created ${filesToApply.length} file(s).`));
     if (solution.implementation.dependencies.length > 0) {
-      console.log(chalk15.cyan("\nNext step: Install dependencies with:"));
+      console.log(chalk17.cyan("\nNext step: Install dependencies with:"));
       const deps = solution.implementation.dependencies.map((d) => `${d.name}@${d.version}`).join(" ");
-      console.log(chalk15.dim(`  npm install ${deps}`));
+      console.log(chalk17.dim(`  npm install ${deps}`));
     }
   } catch (error) {
-    spinner9.stop("Application failed");
+    spinner10.stop("Application failed");
     await store.updateSolutionMetrics(solution.id, false);
-    console.error(chalk15.red(`
+    console.error(chalk17.red(`
 \u2717 Error: ${error.message}
 `));
     process.exit(1);
@@ -5680,48 +6209,48 @@ async function solutionApplyCommand(solutionId, options) {
 async function solutionDeprecateCommand(solutionId, reason) {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk15.cyan("\n\u26A0\uFE0F  Deprecate Solution Pattern\n"));
+  console.log(chalk17.cyan("\n\u26A0\uFE0F  Deprecate Solution Pattern\n"));
   const result = await store.getSolution(solutionId);
   if (!result.success || !result.data) {
-    console.error(chalk15.red(`
+    console.error(chalk17.red(`
 \u2717 Solution not found: ${solutionId}
 `));
     process.exit(1);
   }
   const solution = result.data;
-  console.log(`Solution: ${chalk15.bold(solution.name)}`);
+  console.log(`Solution: ${chalk17.bold(solution.name)}`);
   console.log(`Reason: ${reason}
 `);
-  const confirm10 = await p11.confirm({
+  const confirm10 = await p12.confirm({
     message: "Deprecate this solution?",
     initialValue: false
   });
-  if (p11.isCancel(confirm10) || !confirm10) {
-    p11.cancel("Operation cancelled");
+  if (p12.isCancel(confirm10) || !confirm10) {
+    p12.cancel("Operation cancelled");
     process.exit(0);
   }
   await store.deprecateSolution(solutionId, reason);
-  console.log(chalk15.green(`
+  console.log(chalk17.green(`
 \u2713 Solution deprecated.
 `));
 }
 async function solutionStatsCommand() {
   const cwd = getWorkspacePath2();
   const store = new PatternStore3(cwd);
-  console.log(chalk15.cyan("\n\u{1F4CA} Solution Pattern Statistics\n"));
+  console.log(chalk17.cyan("\n\u{1F4CA} Solution Pattern Statistics\n"));
   const stats = await store.getStats();
-  console.log(chalk15.dim("\u2500".repeat(40)));
-  console.log(`${chalk15.bold("Solutions:")} ${stats.totalSolutions}`);
+  console.log(chalk17.dim("\u2500".repeat(40)));
+  console.log(`${chalk17.bold("Solutions:")} ${stats.totalSolutions}`);
   console.log(`  Active: ${stats.totalSolutions - stats.deprecatedSolutions}`);
   console.log(`  Deprecated: ${stats.deprecatedSolutions}`);
   console.log(`  Private: ${stats.privateSolutions}`);
   console.log(`  Synced: ${stats.syncedSolutions}`);
-  console.log(chalk15.dim("\u2500".repeat(40)));
-  console.log(`${chalk15.bold("Fixes:")} ${stats.totalFixes}`);
-  console.log(`${chalk15.bold("Blueprints:")} ${stats.totalBlueprints}`);
-  console.log(chalk15.dim("\u2500".repeat(40)));
+  console.log(chalk17.dim("\u2500".repeat(40)));
+  console.log(`${chalk17.bold("Fixes:")} ${stats.totalFixes}`);
+  console.log(`${chalk17.bold("Blueprints:")} ${stats.totalBlueprints}`);
+  console.log(chalk17.dim("\u2500".repeat(40)));
   console.log(`
-${chalk15.bold("By Category:")}`);
+${chalk17.bold("By Category:")}`);
   const listResult = await store.listSolutions({ limit: 1e3 });
   if (listResult.success && listResult.data) {
     const categories = /* @__PURE__ */ new Map();
@@ -5757,7 +6286,8 @@ program.command("suggest").description("Submit an improvement suggestion").argum
   "Category: feature, bug, documentation, performance, other"
 ).action(suggestCommand);
 program.command("setup").description("Add workflow scripts to package.json").action(setupCommand);
-program.command("doctor").description("Run health check and get optimization suggestions").action(doctorCommand);
+program.command("doctor").description("Run health check and get optimization suggestions").option("--check-guidelines-only", "Only check guidelines presence").action(doctorCommand);
+program.command("hooks <action>").description("Manage git hooks").action(hooksCommand);
 program.command("scope:create").description("Create a custom scope package").option("--name <name>", 'Package name (e.g., "fintech", "gaming")').option(
   "--scopes <scopes>",
   "Comma-separated scopes (format: name:description:emoji:category)"
@@ -5774,6 +6304,15 @@ program.command("advisory").description("Generate advisory board analysis and do
 ).option("--timestamp", "Append timestamp to filenames").option("--include-health", "Include code health metrics from verify/doctor").option("--ci", "CI mode with exit codes on high-risk findings").option("--compare <path>", "Compare with previous report").action(advisoryCommand);
 program.command("generate-instructions").description("Generate .github/copilot-instructions.md from guidelines").option("--force", "Regenerate without confirmation").action(generateInstructionsCommand);
 program.command("update-templates").description("Update guideline templates from the latest package version").option("--force", "Overwrite existing template files").option("--skip", "Skip the update (useful in CI)").action(updateTemplatesCommand);
+program.command("docs:validate").description("Validate document references in markdown files").option("--fix", "Interactively fix broken references").option("--patterns <patterns>", "Glob patterns to scan (comma-separated, default: **/*.md)").option("--ignore <patterns>", "Glob patterns to ignore (comma-separated)").action((options) => {
+  const patterns = options.patterns ? options.patterns.split(",").map((p13) => p13.trim()) : void 0;
+  const ignore = options.ignore ? options.ignore.split(",").map((p13) => p13.trim()) : void 0;
+  return docsValidateCommand({
+    fix: options.fix,
+    patterns,
+    ignore
+  });
+});
 program.command("learn:record").description("Record a new pattern from a successful implementation").option("--name <name>", "Pattern name").option("--description <desc>", "Pattern description").option(
   "--category <cat>",
   "Category (migration, security, performance, etc.)"